LeetCode1 两数之和

两数之和

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

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

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

分析

• 方法1：暴力循环，时间复杂度$O(n^2)$ ，也能AC
• 方法2：两遍hash。利用hash表存储每个数对应的下标，时间复杂度$O(n)$
• 方法3：一遍hash。只迭代一次hash表，但这种方法时空复杂度都没变，但程序可读性下降了很多，不建议使用
• 方法4：先排序，后双指针左右夹逼，排序$O(nlogn)$，左右夹逼$O(n)$，加上hash元素查找$O(1)$，最终$max(O(n),O(nlogn))$。但是这题需要返回的是下标，不是数字本身，所以本方法行不通。
  因此这里建议采用方法2。

代码实现

方法1

两层循环扫描整个数组
时间复杂度：$O(n^2)$
空间复杂度：$O(1)$

public static int[] twoSum(int[] nums, int target) {
  for (int i = 0; i < nums.length; i++) {
    for (int j = 0; j < nums.length && j!= i; j++) {
      if (nums[i] + nums[j] == target) return new int[]{i, j};
     }
  }
    throw new IllegalArgumentException("No two solution");
}

暴力循环的优化：因为num[j]出现不可能出现在num[i]之前，因此我们可以对内层循环改为for (int j = i+1; j < nums.length; j++)

方法2

两遍hash。利用hash表提高查找元素的速度，将方法1中用于查找对应元素的内层循环使用hash表的查找过程替代，将查找时间从O(n)降低到O(1)。
算法描述：第一次迭代中，将每个元素和它的索引添加到表中。然后，在第二次迭代中，检查每个元素对应的目标元素（target-nums[i]）是否存在于表中。注意，该目标元素不能是nums[i]本身。
时间复杂度$O(n)$
空间复杂度$O(n)$

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

方法3

一遍hash。在添加元素的同时查看map中是否存在了当前元素对应的目标元素。
时间复杂度$O(n)$
空间复杂度$O(n)$

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