当前位置：首页 > news >正文

力扣1. 两数之和

news 2025/10/31 9:57:43

定一个整数数组 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 <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

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

1.暴力求解

class Solution {
public:vector<int> twoSum(vector<int>& nums, int target) {int n = nums.size();for (int i = 0; i < n; ++i){for (int j = i + 1; j < n; ++j){if(nums[i] + nums[j] == target){return {i,j};}}}return {};}
};

1. 函数定义与参数

vector<int> twoSum(vector<int>& nums, int target)

作用：接收一个整数数组 nums 和目标值 target，返回一个包含两个下标的数组（这两个下标对应的元素之和为 target）。
vector<int>& nums：输入的数组（& 表示引用传递，避免复制数组的开销）。
int target：需要达成的目标和。
返回值 vector<int>：存储两个符合条件的元素下标。

2. 获取数组长度

int n = nums.size();

先获取数组 nums 的长度 n（元素个数），避免在循环中多次调用 nums.size()（提升微小效率）。

3. 外层循环（遍历第一个元素）

for (int i = 0; i < n; ++i)

i 是第一个元素的下标，从 0 遍历到 n-1（覆盖数组中所有元素）。
作用：逐个选取数组中的元素作为 “第一个候选元素”（nums[i]）。

4. 内层循环（遍历第二个元素）

for (int j = i + 1; j < n; ++j)

j 是第二个元素的下标，从 i + 1 开始遍历到 n-1。
关键逻辑：j 从 i + 1 开始，是为了避免重复检查同一对元素（比如 i=0, j=1 和 i=1, j=0 是同一对元素，无需重复判断），同时确保 i ≠ j（同一个元素不能用两次）。
作用：为每个 nums[i] 匹配它后面的所有元素作为 “第二个候选元素”（nums[j]）。

5. 判断和是否等于目标值

if(nums[i] + nums[j] == target)

检查当前两个候选元素的和是否等于 target。
如果满足条件，直接返回这两个元素的下标 {i, j}（因为题目保证 “有且仅有一个解”，找到后可立即返回）。

6. 兜底返回（语法兼容）

return {};

题目明确说明 “输入一定存在唯一解”，因此这个语句实际不会被执行。
作用：保证函数在语法上完整（C++ 要求函数必须有返回值）。

核心特点总结

优点：逻辑简单直接，容易理解，不需要额外的存储空间。
缺点：时间复杂度高，为 O(n²)（n 是数组长度），因为外层循环执行 n 次，内层循环平均执行 n/2 次，总操作次数约为 n²/2。
适用场景：适合理解问题逻辑，或处理数据量很小的情况；大数据量时推荐用哈希表解法（时间复杂度 O(n)）。

2.哈希表

class Solution {
public:vector<int> twoSum(vector<int>& nums, int target) {// 哈希表：键为数组元素值，值为对应下标unordered_map<int, int> numMap;// 遍历数组for (int i = 0; i < nums.size(); ++i) {// 计算当前元素的“补数”（目标值 - 当前元素）int complement = target - nums[i];// 若补数存在于哈希表中，说明找到符合条件的两个数if (numMap.find(complement) != numMap.end()) {return {numMap[complement], i};}// 若补数不存在，将当前元素和下标存入哈希表numMap[nums[i]] = i;}// 题目保证有解，此处仅为语法兼容return {};}
};

代码逐行解释

1. 函数定义

vector<int> twoSum(vector<int>& nums, int target) {

这是函数的声明：返回值是 vector<int>（存储两个下标），函数名是 twoSum，参数有两个：nums 是输入的整数数组（引用传递，避免拷贝开销），target 是目标和。

2. 哈希表定义

unordered_map<int, int> numMap;

unordered_map 是 C++ 中的哈希表容器，这里定义了一个名为 numMap 的哈希表。
哈希表的键（key） 是 int 类型，存储数组中已经遍历过的元素的值；
哈希表的值（value） 是 int 类型，存储该元素在数组中的下标。
作用：通过哈希表快速记录 “已遍历元素的值” 和 “其下标” 的对应关系，后续查找时可以直接通过 “值” 定位到 “下标”，时间复杂度为 O (1)（比数组遍历查找的 O (n) 快很多）。

3. 遍历数组

for (int i = 0; i < nums.size(); ++i) {

用 for 循环遍历整个数组 nums，i 是当前遍历到的元素的下标（从 0 开始）。
遍历的目的：逐个处理数组中的每个元素，检查是否存在另一个已遍历的元素，与当前元素的和等于 target。

4. 计算 “补数”

int complement = target - nums[i];

nums[i] 是当前遍历到的元素的值。
complement 翻译为 “补数”，指的是：如果存在一个数 x，使得 nums[i] + x = target，那么 x 就等于 target - nums[i]，也就是这里的 complement。
例如：如果 target 是 9，当前 nums[i] 是 2，那么 complement 就是 7（因为 2 + 7 = 9）。我们需要检查之前是否遍历过 7。

5. 检查补数是否已存在于哈希表中

if (numMap.find(complement) != numMap.end()) {

numMap.find(complement)：在哈希表中查找 “键为 complement” 的元素。如果找到，返回该元素的迭代器（类似指针）；如果没找到，返回 numMap.end()（哈希表的 “结束标记”）。
条件 numMap.find(complement) != numMap.end() 的意思是：补数 complement 存在于哈希表中（即之前已经遍历过值为 complement 的元素）。
此时说明：当前元素 nums[i] 和哈希表中记录的 complement 对应的元素，它们的和就是 target，这两个元素就是我们要找的解。

6. 返回结果

如果上一步的条件成立，直接返回一个包含两个下标的数组：
- numMap[complement]：哈希表中 “键为 complement” 对应的值，也就是之前遍历过的 complement 元素的下标；
- i：当前元素 nums[i] 的下标。
这两个下标对应的元素之和为 target，因此是正确结果。