两数之和

前言：作为即将毕业的大学老学长，感觉自己在算法题上面刷的还是比较少，从今天开始就和大家一起一天一个算法题，希望自己可以坚持。当然，也希望你们可以坚持和我一起，互相讨论。我们以leetCode上面的题目作为练手题。

问题描述：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

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

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

这个问题相信大多数人都会觉得很简单，首先就会想到用两个for循环，像下面这样:

C#

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        
        int [] arr = 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)
                {
                    arr[0] = i;
                    arr[1] = j;
                    return arr;
                }
            }
        }
        return null;
        
    }
}

Java

class Solution {
    public int[] twoSum(int[] nums, int target) {       
        int [] arr = 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)
                {
                    arr[0] = i;
                    arr[1] = j;
                    return arr;
                }
            }
        }
        return null;
    }
}

当然，这样的做法结果是对的，但是效率还是很低的，嵌套两个for循环，时间复杂度都是n平方了。

执行结果以java为例：

执行用时 :57 ms, 在所有 Java 提交中击败了27.46%的用户

内存消耗 :39.2 MB, 在所有 Java 提交中击败了5.02%的用户

显然，效果很不好^_^|||

我们可以用一个容器来存储我们数组的索引和对应的值，这样就不需要嵌套for循环了，所以我们自然而然会想到HashMap，它很符合我们的需求。

解题步骤：

（1）先将数组的元素值和对应的索引作为一个个键值对存储到Map集合中。

（2）开始遍历数组，查找在map集合中是否有(target-nums[i])的key，当然该元素不能是nums[i]元素本身。（比如：[3,2,6]  target = 6      如果没有排除不能是nums[i]元素本身，就会出错,题目提示了不能重复用同一个元素）

（3）如果有，那i和target-nums[i]就是我们要查找的两个索引了

代码实现：

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 a = target - nums[i];
            if (map.containsKey(a) && map.get(a) != i) {
                return new int[] { i, map.get(a) };
            }
        }
        return null;
    }
}

执行结果：

执行用时 :3 ms, 在所有 Java 提交中击败了91.28%的用户

内存消耗 :42.3 MB, 在所有 Java 提交中击败了5.02%的用户

 

对上面的代码我们还可以再优化一下，我们发现上面的做法是先将数组的值和索引存储到Map集合中的。

我们可以对代码进行优化，边存入集合，边进行判断，如下例代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int a = target - nums[i];
            if (map.containsKey(a)) {
                return new int[] { map.get(a), i };
            }
            map.put(nums[i], i);
        }
        return null;
    }
}

 

当然使用C#也是一样的，就是使用Dictionary字典去存储数组的值和对应的索引,代码如下：

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        
       Dictionary<int, int> dic = new Dictionary<int,int>();
        for (int i = 0; i < nums.Length; i++) {
            int a = target - nums[i];
            if (dic.ContainsKey(a)) {
                return new int[] { dic[a], i };
            }
            dic[nums[i]] = i;
        }
        return null;


    }
}

执行用时 :284 ms, 在所有 C# 提交中击败了90.44%的用户

内存消耗 :30.8 MB, 在所有 C# 提交中击败了7.31%的用户

 

欢迎评论留言你的思路和做法，一起交流学习。