Java详解LeetCode 热题 100(01):LeetCode 1. 两数之和（Two Sum）详解

1. 题目描述

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

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

你可以按任意顺序返回答案。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 2 <= nums.length <= 10^4
• -10^9 <= nums[i] <= 10^9
• -10^9 <= target <= 10^9
• 只会存在一个有效答案

进阶： 你可以想出一个时间复杂度小于 O(n²) 的算法吗？

2. 理解题目

这道题的意思很简单：从数组中找出两个数，使它们的和等于目标值 target，并返回这两个数的下标。

关键点：

1. 数组中只有一组符合条件的答案
2. 同一个元素不能使用两次
3. 可以按任意顺序返回答案

3. 解法一：暴力枚举法

3.1 思路

最直观的方法是使用两层嵌套循环：

• 第一层循环遍历数组中的每个元素 x
• 第二层循环寻找是否存在另一个值等于 target - x

这种方法的时间复杂度为 O(n²)，空间复杂度为 O(1)。

3.2 Java代码实现

public class Solution {public int[] twoSum(int[] nums, int target) {int n = nums.length;for (int i = 0; i < n; i++) {for (int j = i + 1; j < n; j++) {if (nums[i] + nums[j] == target) {return new int[]{i, j};}}}// 根据题意，一定有解，所以这行代码不会执行return new int[]{-1, -1};}
}

3.3 代码详解

1. 外层循环从索引 0 开始遍历数组
2. 内层循环从索引 i+1 开始遍历数组（避免重复检查同一对数字）
3. 判断当前两个数的和是否等于目标值 target
4. 如果找到符合条件的两个数，立即返回它们的索引数组
5. 由于题目保证有唯一解，所以最后的 return 语句不会被执行

3.4 复杂度分析

• 时间复杂度：O(n²)，其中 n 是数组的长度。最坏情况下，我们需要遍历所有的数对，共有 n(n-1)/2 个。
• 空间复杂度：O(1)，只使用了常数额外空间。

3.5 适用场景

当数组较小时，暴力法简单直接，容易实现。但对于大型数组，这种方法效率较低。

4. 解法二：哈希表法

4.1 思路

通过哈希表可以优化搜索过程。我们可以将数组中的每个元素及其索引存储在哈希表中，然后对于每个元素 x，检查哈希表中是否存在 target - x。

具体步骤：

1. 创建一个哈希表，用于存储数组元素值及其索引
2. 遍历数组，对于每个元素 x：
   • 计算补数值 complement = target - x
   • 检查哈希表中是否已存在补数值 complement
   • 如果存在，返回补数值的索引和当前元素的索引
   • 如果不存在，将当前元素及其索引存入哈希表

这种方法的时间复杂度降至 O(n)，但空间复杂度增加到 O(n)。

4.2 Java代码实现

import java.util.HashMap;
import java.util.Map;public class Solution {public int[] twoSum(int[] nums, int target) {Map<Integer, Integer> map = new HashMap<>();for (int i = 0; i < nums.length; i++) {int complement = target - nums[i];if (map.containsKey(complement)) {return new int[]{map.get(complement), i};}map.put(nums[i], i);}// 根据题意，一定有解，所以这行代码不会执行return new int[]{-1, -1};}
}

4.3 代码详解

1. 创建一个 HashMap，键为数组元素的值，值为对应的索引
2. 遍历数组，对于每个元素 nums[i]：
   • 计算它的补数：complement = target - nums[i]
   • 检查 HashMap 中是否已包含这个补数
   • 如果包含，说明找到了答案，返回两个索引
   • 如果不包含，将当前元素及其索引添加到 HashMap 中
3. 每次添加新元素前先检查补数，确保可以立即找到答案

4.4 复杂度分析

• 时间复杂度：O(n)，其中 n 是数组的长度。对于每个元素，我们只需要 O(1) 的时间查找 HashMap。
• 空间复杂度：O(n)，其中 n 是数组的长度。最坏情况下，HashMap 需要存储 n 个元素。

4.5 适用场景

对于大多数情况，哈希表法是首选方案，因为它在保持较低空间复杂度的同时，显著提高了时间效率。

5. 解法三：两遍哈希表法

5.1 思路

两遍哈希表法也使用哈希表，但通过两次遍历来实现：

1. 第一次遍历：将所有元素及其索引存入哈希表
2. 第二次遍历：检查每个元素的补数是否在哈希表中

5.2 Java代码实现

import java.util.HashMap;
import java.util.Map;public 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)};}}// 根据题意，一定有解，所以这行代码不会执行return new int[]{-1, -1};}
}

5.3 代码详解

1. 创建一个 HashMap，存储数组元素和其索引
2. 第一遍遍历：将所有元素及其索引添加到 HashMap 中
3. 第二遍遍历：对于每个元素，检查其补数是否在 HashMap 中
4. 注意条件 map.get(complement) != i，确保不使用同一个元素两次
5. 找到符合条件的元素对后立即返回结果

5.4 复杂度分析

• 时间复杂度：O(n)，需要进行两次遍历，每次 O(n)。
• 空间复杂度：O(n)，需要额外的哈希表存储数组元素及其索引。

5.5 对比一遍哈希表法

一遍哈希表法更加高效，因为它只需要遍历数组一次就能找到答案。但两遍哈希表法的思路可能更容易理解，尤其对于初学者。

6. 解法四：排序双指针法

6.1 思路

这种方法首先对数组进行排序，然后使用双指针从两端向中间移动：

1. 创建一个包含原数组元素和索引的新数组
2. 对新数组按元素值排序
3. 使用左右指针从两端向中间移动
4. 如果两指针元素之和等于目标值，返回对应的原始索引

注意：排序会改变元素的原始位置，所以需要额外存储原始索引。

6.2 Java代码实现

import java.util.Arrays;public class Solution {public int[] twoSum(int[] nums, int target) {int n = nums.length;// 创建一个二维数组，存储元素值和原始索引int[][] pairs = new int[n][2];for (int i = 0; i < n; i++) {pairs[i][0] = nums[i];pairs[i][1] = i;}// 按元素值排序Arrays.sort(pairs, (a, b) -> Integer.compare(a[0], b[0]));// 双指针搜索int left = 0;int right = n - 1;while (left < right) {int sum = pairs[left][0] + pairs[right][0];if (sum == target) {return new int[]{pairs[left][1], pairs[right][1]};} else if (sum < target) {left++;} else {right--;}}// 根据题意，一定有解，所以这行代码不会执行return new int[]{-1, -1};}
}

6.3 代码详解

1. 创建一个二维数组 pairs，存储每个元素的值和原始索引
2. 按元素值对 pairs 进行排序
3. 使用双指针 left 和 right 分别指向排序后数组的两端
4. 计算当前指针指向的两个元素之和 sum
5. 如果 sum 等于 target，返回这两个元素的原始索引
6. 如果 sum 小于 target，将 left 向右移动一位（增加 sum）
7. 如果 sum 大于 target，将 right 向左移动一位（减小 sum）
8. 重复步骤 4-7 直到找到答案

6.4 复杂度分析

• 时间复杂度：O(n log n)，主要是排序所需的时间。
• 空间复杂度：O(n)，需要额外的空间存储排序后的数组和原始索引。

6.5 适用场景

当数组已经排序或者允许修改原数组时，这种方法也是很有效的。对于很大的数组，排序的代价可能超过哈希表法。

7. 进阶思考与变体问题

7.1 如何处理数组中有重复元素的情况？

本题中，即使数组中有重复元素，只要它们的和等于 target，就是有效的答案。哈希表法通过索引判断可以正确处理重复元素。

例如：

nums = [3, 3], target = 6

哈希表法的处理流程：

1. 遍历到 nums[0] = 3 时，计算补数 6 - 3 = 3，哈希表中尚未包含 3，添加 (3, 0)
2. 遍历到 nums[1] = 3 时，计算补数 6 - 3 = 3，哈希表已包含 3，返回 [0, 1]

7.2 如果题目要求返回所有可能的解怎么办？

对于返回所有可能解的变体，我们可以修改算法：

• 不在找到一个解后立即返回
• 继续搜索并收集所有满足条件的索引对
• 注意去重，避免返回相同的索引对

import java.util.*;public class Solution {public List<int[]> twoSumAll(int[] nums, int target) {List<int[]> result = new ArrayList<>();Map<Integer, List<Integer>> map = new HashMap<>();// 构建哈希表，处理重复元素for (int i = 0; i < nums.length; i++) {if (!map.containsKey(nums[i])) {map.put(nums[i], new ArrayList<>());}map.get(nums[i]).add(i);}// 检查每个元素Set<String> seen = new HashSet<>(); // 用于去重for (int i = 0; i < nums.length; i++) {int complement = target - nums[i];if (map.containsKey(complement)) {for (int j : map.get(complement)) {if (j > i) { // 确保不重复且不使用同一元素String pair = i + "," + j; // 创建唯一标识if (!seen.contains(pair)) {result.add(new int[]{i, j});seen.add(pair);}}}}}return result;}
}

7.3 三数之和、四数之和等扩展问题

LeetCode 上有这题的扩展问题：

• 15. 三数之和
• 18. 四数之和

这些问题可以用类似的思路解决，但需要更复杂的实现：

• 三数之和：固定一个数，然后在剩余数组中寻找两数之和
• 四数之和：固定两个数，然后在剩余数组中寻找两数之和

8. 常见错误与优化

8.1 常见错误

1. 忽略数组中的重复元素：

   // 错误做法
   if (map.containsKey(complement)) {// 如果complement和nums[i]是同一个元素，这里会错误地使用同一元素两次return new int[]{map.get(complement), i};
   }
   

   正确的做法是确保不使用同一个元素两次：

   if (map.containsKey(complement) && map.get(complement) != i) {return new int[]{map.get(complement), i};
   }
   

2. 哈希表更新错误：

   // 错误做法：先将元素添加到哈希表再检查，可能导致使用同一元素两次
   map.put(nums[i], i);
   if (map.containsKey(target - nums[i])) {// ...
   }
   

   正确的做法是先检查再添加：

   int complement = target - nums[i];
   if (map.containsKey(complement)) {// ...
   }
   map.put(nums[i], i);
   

8.2 性能优化

1. 预估哈希表大小：如果大致知道数组大小，可以在创建哈希表时预设容量，减少再哈希的次数。

   Map<Integer, Integer> map = new HashMap<>(nums.length);
   

2. 提前返回：一旦找到答案就立即返回，不需要继续遍历。

3. 处理特殊情况：对于特别小的数组（如长度为2），可以直接检查而不使用哈希表。

   if (nums.length == 2) {return new int[]{0, 1};
   }
   

9. 完整的 Java 解决方案

下面是结合了各种最佳实践的最优解法：

import java.util.HashMap;
import java.util.Map;class Solution {public int[] twoSum(int[] nums, int target) {// 处理边界情况if (nums == null || nums.length < 2) {throw new IllegalArgumentException("输入数组至少需要两个元素");}// 特殊情况：只有两个元素if (nums.length == 2) {return new int[]{0, 1};}// 创建哈希表，用于存储元素值及其索引Map<Integer, Integer> numMap = new HashMap<>(nums.length);// 一次遍历for (int i = 0; i < nums.length; i++) {int complement = target - nums[i];// 检查互补元素是否已在哈希表中if (numMap.containsKey(complement)) {return new int[]{numMap.get(complement), i};}// 将当前元素加入哈希表numMap.put(nums[i], i);}// 根据题意一定有解，但为了代码完整性，添加这行throw new IllegalArgumentException("无解");}
}

10. 实际运用示例

10.1 LeetCode提交结果

哈希表法在LeetCode上提交的结果通常如下：

• 执行用时：1-2 ms（击败约 99% 的 Java 提交）
• 内存消耗：38-39 MB（击败约 80% 的 Java 提交）

10.2 应用场景

两数之和问题在实际编程中有很多应用场景，例如：

• 在金融系统中寻找交易对
• 在数据分析中查找数据对
• 在游戏开发中配对玩家
• 在算法设计中作为子问题出现

10.3 扩展用例

public class TwoSumApplication {public static void main(String[] args) {// 基本测试用例test(new int[]{2, 7, 11, 15}, 9);test(new int[]{3, 2, 4}, 6);test(new int[]{3, 3}, 6);// 边界测试用例test(new int[]{1, 5}, 6);test(new int[]{1, 2, 3, 4, 5}, 9);// 大数组测试int[] largeArray = new int[10000];for (int i = 0; i < 10000; i++) {largeArray[i] = i;}test(largeArray, 19998);}private static void test(int[] nums, int target) {Solution solution = new Solution();int[] result = solution.twoSum(nums, target);System.out.printf("输入：nums = %s, target = %d\n", Arrays.toString(nums), target);System.out.printf("输出：%s\n", Arrays.toString(result));System.out.printf("验证：%d + %d = %d\n\n", nums[result[0]], nums[result[1]], target);}
}

11. 总结与技巧

11.1 解题要点

1. 理解问题：确保理解题目要求，包括输入限制和预期输出。
2. 暴力法：先考虑最简单的解法，帮助理解问题。
3. 优化：使用哈希表将查找复杂度从 O(n) 降低到 O(1)。
4. 特殊处理：处理边界情况和特殊输入。
5. 代码风格：编写清晰、高效、易于理解的代码。

11.2 学习收获

通过学习两数之和问题，可以掌握：

• 哈希表的应用
• 双指针技巧
• 空间换时间的思想
• 算法效率分析方法

11.3 面试技巧

在面试中遇到类似问题时：

1. 先讨论最直观的解法（暴力法）
2. 分析其时间和空间复杂度的瓶颈
3. 提出优化思路（例如使用哈希表）
4. 讨论进一步的优化可能性
5. 考虑边界情况和错误处理

12. 参考资料

• LeetCode 官方题解
• LeetCode 两数之和问题