文章目录
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，并返回这两个数的下标。
关键点：
- 数组中只有一组符合条件的答案
- 同一个元素不能使用两次
- 可以按任意顺序返回答案
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 代码详解
- 外层循环从索引 0 开始遍历数组
- 内层循环从索引 i+1 开始遍历数组（避免重复检查同一对数字）
- 判断当前两个数的和是否等于目标值 target
- 如果找到符合条件的两个数，立即返回它们的索引数组
- 由于题目保证有唯一解，所以最后的 return 语句不会被执行
3.4 复杂度分析
- 时间复杂度：O(n²)，其中 n 是数组的长度。最坏情况下，我们需要遍历所有的数对，共有 n(n-1)/2 个。
- 空间复杂度：O(1)，只使用了常数额外空间。
3.5 适用场景
当数组较小时，暴力法简单直接，容易实现。但对于大型数组，这种方法效率较低。
4. 解法二：哈希表法
4.1 思路
通过哈希表可以优化搜索过程。我们可以将数组中的每个元素及其索引存储在哈希表中，然后对于每个元素 x，检查哈希表中是否存在 target - x。
具体步骤：
- 创建一个哈希表，用于存储数组元素值及其索引
- 遍历数组，对于每个元素 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 代码详解
- 创建一个 HashMap，键为数组元素的值，值为对应的索引
- 遍历数组，对于每个元素 nums[i]：
- 计算它的补数：complement = target - nums[i]
- 检查 HashMap 中是否已包含这个补数
- 如果包含，说明找到了答案，返回两个索引
- 如果不包含，将当前元素及其索引添加到 HashMap 中
- 每次添加新元素前先检查补数，确保可以立即找到答案
4.4 复杂度分析
- 时间复杂度：O(n)，其中 n 是数组的长度。对于每个元素，我们只需要 O(1) 的时间查找 HashMap。
- 空间复杂度：O(n)，其中 n 是数组的长度。最坏情况下，HashMap 需要存储 n 个元素。
4.5 适用场景
对于大多数情况，哈希表法是首选方案，因为它在保持较低空间复杂度的同时，显著提高了时间效率。
5. 解法三：两遍哈希表法
5.1 思路
两遍哈希表法也使用哈希表，但通过两次遍历来实现：
- 第一次遍历：将所有元素及其索引存入哈希表
- 第二次遍历：检查每个元素的补数是否在哈希表中
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 代码详解
- 创建一个 HashMap，存储数组元素和其索引
- 第一遍遍历：将所有元素及其索引添加到 HashMap 中
- 第二遍遍历：对于每个元素，检查其补数是否在 HashMap 中
- 注意条件
map.get(complement) != i，确保不使用同一个元素两次 - 找到符合条件的元素对后立即返回结果
5.4 复杂度分析
- 时间复杂度：O(n)，需要进行两次遍历，每次 O(n)。
- 空间复杂度：O(n)，需要额外的哈希表存储数组元素及其索引。
5.5 对比一遍哈希表法
一遍哈希表法更加高效，因为它只需要遍历数组一次就能找到答案。但两遍哈希表法的思路可能更容易理解，尤其对于初学者。
6. 解法四：排序双指针法
6.1 思路
这种方法首先对数组进行排序，然后使用双指针从两端向中间移动：
- 创建一个包含原数组元素和索引的新数组
- 对新数组按元素值排序
- 使用左右指针从两端向中间移动
- 如果两指针元素之和等于目标值，返回对应的原始索引
注意：排序会改变元素的原始位置，所以需要额外存储原始索引。
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 代码详解
- 创建一个二维数组
pairs，存储每个元素的值和原始索引 - 按元素值对
pairs进行排序 - 使用双指针 left 和 right 分别指向排序后数组的两端
- 计算当前指针指向的两个元素之和 sum
- 如果 sum 等于 target，返回这两个元素的原始索引
- 如果 sum 小于 target，将 left 向右移动一位（增加 sum）
- 如果 sum 大于 target，将 right 向左移动一位（减小 sum）
- 重复步骤 4-7 直到找到答案
6.4 复杂度分析
- 时间复杂度：O(n log n)，主要是排序所需的时间。
- 空间复杂度：O(n)，需要额外的空间存储排序后的数组和原始索引。
6.5 适用场景
当数组已经排序或者允许修改原数组时，这种方法也是很有效的。对于很大的数组，排序的代价可能超过哈希表法。
7. 进阶思考与变体问题
7.1 如何处理数组中有重复元素的情况？
本题中，即使数组中有重复元素，只要它们的和等于 target，就是有效的答案。哈希表法通过索引判断可以正确处理重复元素。
例如：
nums = [3, 3], target = 6
哈希表法的处理流程：
- 遍历到 nums[0] = 3 时，计算补数 6 - 3 = 3，哈希表中尚未包含 3，添加 (3, 0)
- 遍历到 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 上有这题的扩展问题：
这些问题可以用类似的思路解决，但需要更复杂的实现：
- 三数之和：固定一个数，然后在剩余数组中寻找两数之和
- 四数之和：固定两个数，然后在剩余数组中寻找两数之和
8. 常见错误与优化
8.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}; } -
哈希表更新错误：
// 错误做法：先将元素添加到哈希表再检查，可能导致使用同一元素两次 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 性能优化
-
预估哈希表大小：如果大致知道数组大小，可以在创建哈希表时预设容量，减少再哈希的次数。
Map<Integer, Integer> map = new HashMap<>(nums.length); -
提前返回：一旦找到答案就立即返回，不需要继续遍历。
-
处理特殊情况：对于特别小的数组（如长度为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 解题要点
- 理解问题：确保理解题目要求，包括输入限制和预期输出。
- 暴力法：先考虑最简单的解法，帮助理解问题。
- 优化：使用哈希表将查找复杂度从 O(n) 降低到 O(1)。
- 特殊处理：处理边界情况和特殊输入。
- 代码风格：编写清晰、高效、易于理解的代码。
11.2 学习收获
通过学习两数之和问题，可以掌握：
- 哈希表的应用
- 双指针技巧
- 空间换时间的思想
- 算法效率分析方法
11.3 面试技巧
在面试中遇到类似问题时：
- 先讨论最直观的解法（暴力法）
- 分析其时间和空间复杂度的瓶颈
- 提出优化思路（例如使用哈希表）
- 讨论进一步的优化可能性
- 考虑边界情况和错误处理
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
