1 前言

之所以开始刷 LeetCode 上的算法题，一是快面临秋招，第二点是因为提升自己的编程能力，在博客上争取每天刷 5 道左右的算法题，坚持两个月，希望博友们监督。

这个系列打算用 C# 和 Java 编程，为什么用两门语言，因为经历春招，发现招 C# 的公司是在是太太太少了，只能在学 C# 的同时，将 Java 基础也顺带练一练，C# 和 Java 的语法差不多，不会有点太大难都。

废话不多说，开始上题吧。

2 题目及解决

2.1 题目

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

2.2 C# 解决方法

2.2.1 暴力解决

题目蛮简单，暴力解决即可。

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        int[] res = new int[2];
        for (int i = 0; i < nums.Length - 1; i++){

            for (int j = i + 1; j < nums.Length; j++ ){

                if (nums[i] + nums[j] == target){

                    res[0] = i ;
                    res[1] = j ;
                    break;
                }
            }
        }
        return res;   
    }
}

暴力解法，两次for循环，遍历所有可能，这也是容易想到的方法，时间复杂度O(n^2),空间复杂度O(1);

2.2.2 使用字典

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
           
        Dictionary<int,int> symbol = new Dictionary<int,int>();  
            int[] res = new int[2];  
  
            //数据存入字典
            for(int i=0;i<nums.Length;i++)  
            {  
                symbol.Add(nums[i], i);  
            }  
  
            for(int j=0;j<nums.Length;j++)  
            {  
                int t = target - nums[j];  
                
                if(symbol.ContainsKey(t) && symbol[t]!=j)  
                {  
                    res[0] = j;  
                    res[1] = symbol[t];  
                    break;  
                }  
            }  
            return res;   
        }  
    }

时间复杂度T(n) = O(n)

2.3 Java 解决方法

2.3.1暴力解决

class Solution {
    public int[] twoSum(int[] nums, int target) {
        
        int[] res = new int[2];
        for (int i = 0; i < nums.length - 1; i++){

            for (int j = i + 1; j < nums.length; j++ ){

                if (nums[i] + nums[j] == target){

                    res[0] = i ;
                    res[1] = j ;
                    break;
                }
            }
        }
        return res;       
    }
}

2.3.2 使用HashMap

class Solution {
    public int[] twoSum(int[] nums, int target) {
              
    Map<Integer, Integer> map = new HashMap<>();

    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i], i);
    }

    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement) && map.get(complement) != i) {
            return new int[] { i, map.get(complement) };
        }
    }
    throw new IllegalArgumentException("No two sum solution");        
    }
}

利用哈希表，每次存储target减去当前数的差值(key)，当前值的下标(value)，当再碰到这个值时，即找到了符合要求的值。时间复杂度O(n),空间复杂度O(n);

3 总结

3.1 C# 和 Java 中的数组表示不同

3.1.1 C# 数组表示

一维数组的声明与赋值：

    class Program
    {
        static void Main(string[] args)
        {
            //一、一维数组

            //1.1声明和初始化一维数组
            int[] array1 = new int[10];

            //1.2赋值一维数组

            //方式1   可以创建并初始化一个数组，比如：（【】里也可以不省略数组的大小，但是只要写了数组的大小，后面的赋值就要满足数组的大小）
            int[] array2 = new int[] { 1, 2, 3, 4, 5 };

            int[] array3 = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            
            //方式2   通过使用索引号赋值给一个单独的数组元素，比如：
            array1[0] = 1;

            //方式3   在声明数组的同时给数组赋值，比如：
            double[] balance = { 2340.0, 4523.69, 3421.0 };

            Console.WriteLine(array1.Length);//显示数组长度
            Console.ReadKey();

        }
    }

二维数组的声明与赋值：

        static void Main(string[] args)
        {//声明和初始化以及赋值二维数组
            int[,] a = new int[3, 4] {
                                         {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
                                         {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
                                         {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
                                      };

            Console.WriteLine(a.Length);
            Console.ReadKey();
        }

3.1.2 Java中的数组表示

一维数组和 C# 相同