两数之和

题目介绍

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。
题目链接：https://leetcode-cn.com/problems/two-sum/

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

只会存在一个有效答案

方法一：暴力法

暴力法其实非常简单：把所有数，两两组合在一起，计算出它们的和，如果是target，就输出。
代码实现如下：

// 方法一：暴力法，穷举所有两数组合 ，时间复杂度为O(n*n)
public int[] twoSum(int[] nums, int target){
    int n = nums.length;
    // 双重for循环
    for (int i = 0; i < n - 1; i++){
        for (int j = i + 1; j < n; j++){
            if (nums[i] + nums[j] == target){
                return new int[]{i, j};
            }
        }
    }
    // 如果找不到，抛出异常
    throw new IllegalArgumentException("no solution");
}

复杂度分析

• 时间复杂度：O(n^2)，对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n)。
• 空间复杂度：O(1)。

方法二：两遍哈希表

为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。这可以使用哈希表来实现。

具体实现方法，最简单就是使用两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中；然后，在第二次迭代中，我们将检查每个元素所对应的目标元素 (target-nums[i]) 是否存在于表中。
代码如下：

// 方法二：哈希表保存所有数的信息
public int[] twoSum(int[] nums, int target){
      int n = nums.length;

      // 定义一个哈希表
      HashMap<Integer, Integer> map = new HashMap<>();

      // 1. 遍历数组，将数据全部保存入hash表
      for (int i = 0; i < n; i++){
          map.put(nums[i], i);//HashMap中的put()方法执行额时间复杂度为O（1）
      }

      // 2. 再次遍历数组，寻找每个数对应的那个数是否存在
      for (int i = 0; i < n; i++){
          int thatNum = target - nums[i];
          // 如果那个数存在，并且不是当前数自身，就直接返回结果
          /**
           * 注意：HashMap要判断对应的key是否存在，只需要计算key的hash值，然后就能一下定位到存储的位置
           * 所以containsKey()方法执行的时间为O(1)，同样get()方法执行的时间也是O(1)
           */
          if (map.containsKey(thatNum) && map.get(thatNum) != i )
              return new int[]{i, map.get(thatNum)};
      }

      // 如果找不到，抛出异常
      throw new IllegalArgumentException("no solution");
}

复杂度分析

• 时间复杂度：O(N)，我们把包含有 N 个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1)，所以时间复杂度为 O(N)。
• 空间复杂度：O(N)，所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 N 个元素。

方法三：一遍哈希表

在上述算法中，我们对哈希表进行了两次扫描，这其实是不必要的。在进行迭代并将元素插入到表中的同时，我们可以直接检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。这样，只需要扫描一次哈希表，就可以完成算法了。
代码实现：

// 方法三：改进，遍历一次哈希表
public int[] twoSum(int[] nums, int target){
      int n = nums.length;

      // 定义一个哈希表
      HashMap<Integer, Integer> map = new HashMap<>();

      // 遍历数组，寻找每个数对应的那个数是否存在（只向前寻找）
      for (int i = 0; i < n; i++){
          int thatNum = target - nums[i];
          // 如果那个数存在，并且不是当前数自身，就直接返回结果
          if (map.containsKey(thatNum) )
              return new int[]{map.get(thatNum), i};

          map.put(nums[i], i);
      }

      // 如果找不到，抛出异常
      throw new IllegalArgumentException("no solution");
}

复杂度分析

• 时间复杂度：O(N)，我们只遍历了包含有 N 个元素的列表一次。在哈希表中进行的每次查找只花费 O(1)
  的时间。其实这个过程中，我们也借鉴了动态规划的思想、把子问题解保存起来，后面用到就直接查询。
• 空间复杂度：O(N)，所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 N 个元素。