两数之和

题目

• 给定一个整数组nums和一个目标值target，请你在该数组中找出和为目标值的两个整数，并且返回他们的数组的下标。
• 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例

• 给定nums = [2, 7, 11, 15]，target = 9
• 因为nums[0] + nums[1] = 2 + 7 = 9
• 所以返回[0, 1]

解析（参考了leetcode的解析）

方法一：暴力循环

• 利用两层循环遍历解决，是否存在一个值与目标值-当前值相等
• 时间复杂度是O(n^2)
• 空间复杂度是O(1)
• 代码实现：

    /**
     * 利用两层循环遍历,暴力循环
     * @param nums
     * @param target
     * @return
     */
    public static int[] twoSum_1(int[] nums, int target) {
        int[] result = new int[2];
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (target - nums[j] == nums[i]) {
                    result[0] = i;
                    result[1] = j;
                    return result;
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

---

方法二：两遍哈希表

• 使用两次迭代，第一次将数组中的数据以值为key，下标是value进行存储。在第二次的迭代中，我们就检查target-nums[i] 的值是否在map中，如果存在则返回，注意一点，这里目标的元素不能是其本身。
• 这里我们用两遍Hash表，已经解决了目标元素不是其本身。因为我们的值如果重复，第二个值就会覆盖掉map中的key，然后我们遍历的时候，会先遍历到第一个，这样取出来的值也不是重复的

nums：[1,3,2,3] target：6

• 我们遍历第一遍之后得到的map
  {1:0， 3:3，2:2}，我们的值为3的元素下标有1和3，所以下标是3的覆盖了下标是1的
• 第二次遍历会判断是否map中有target-nums[i]的值
  下标：0， 值：1，target-nums[0] = 6 - 1 = 5，5不在map中，下一个
  下标：1， 值：3，target-nums[0] = 6 - 3 = 3，3在map中，返回下标，注意这里，我们遍历的下标是第一个3即下标是1，而map中的3下标是3，是第二个3，因此我们保证了不重复利用这个数组中同样的元素

• 代码实现

    /**
     * 两遍hash表
     * @param nums
     * @param target
     * @return
     */
    public static int[] twoSum_2(int[] nums, int target) {
        // 1. 先遍历一遍，将nums的值存入map中，key是nums中的值，value是下标
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }

        // 2. 第二遍遍历判断，target-nums[i]的值是否在map中
        for (int i = 0; i < nums.length; i++) {
            int key = target - nums[i];
            // 如果当前的key存在，且当前的值不是自己，即当前的下标不是map中的value
            if (map.containsKey(key) && map.get(key) != i) {
                return new int[]{i, map.get(key)};
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

---

• 时间复杂度：O(n)
• 空间复杂度：O(n)

方法三：一遍哈希表

• 一次遍历的核心就是我们迭代往map中赋值的同时，去判断target-nums[i]的值是否存在在map中，如果不存在就向map中赋值。
• 代码实现：

    /**
     * 一遍hash表
     * @param nums
     * @param target
     * @return
     */
    public static int[] twoSum_3(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        // 1. 遍历的同时，判断map中是否有值
        for (int i = 0; i < nums.length; i++) {
            // 因为是一边判断一边放值，所以根本不需要去判断，当前的下标是不是map中的value
            int key = target - nums[i];
            if (map.containsKey(key)) {
                return new int[]{i, map.get(key)};
            }
            // 如果没有匹配上 放到map中
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }

• 时间复杂度：O(n)
• 空间复杂度：O(n)