如果你打开力扣准备开始刷题，第一道题大概率就是《两数之和》。这道题看起来简单，但我见过太多人第一遍写的时候翻车：有人忘了处理重复元素，有人把返回下标写成了返回值，有人只会双重循环被面试官一问复杂度就卡壳。这篇笔记会把我刷这道题沉淀下来的东西一次讲清楚——从暴力解到哈希解，再到实际提交时容易踩的坑，以及面试官围绕这题最喜欢问的变体。不管你是刚接触算法题的新手，还是准备跳槽想复习热手的老手，这篇都值得认真看一遍，尤其是第4章和第5章，都是常规题解里不会写的经验。
1. 先读懂题面：两数之和到底在问什么
1.1 题目约束里的隐藏信息
先不急着写代码，把题目要求拆开看。题目通常会给你一个整数数组nums和一个目标值target，要求你在数组里找出两个数，让它们的和等于target，然后返回这两个数的数组下标。就这么一句话，里面藏着三个容易被忽略的约束：
- 数组里可能有负数，这一点很多人下意识忽略。
nums = [-3, 4, 6, 1]，target = 3，这题依然要能算出来，不能只盯着正数。 - 题目保证“每种输入只对应一种答案”，也就是说不会出现多个正确组合让你纠结。这个约束很重要，它直接让暴力解变得可以接受，也让哈希法的“先查再存”能稳定返回。
- “不能重复使用同一个元素”，意思是两个下标必须不同。比如
nums = [3, 3]，target = 6，正确结果是[0, 1]，你不能因为3 + 3 = 6就返回[0, 0]。
很多新手不看题面就开始写，结果用nums[0] + nums[0]凑出了答案，提交之后被测试用例打脸。我当年第一次刷这道题，就是没仔细看“同一个元素不能重复使用”这句话，用了个非常蠢的写法，后来才发现题目里早就写清楚了。
1.2 为什么它适合当第一题
力扣把这道题放在第一题不是偶然的，它是极少数能同时覆盖“暴力思维”“哈希优化”“复杂度分析”三个层次的题目。你刚开始刷题时，能用嵌套循环做出来；刷了半个月后回来看，能自然地想到用空间换时间；再过几个月准备面试时，还能从它延伸出三数之和、双指针、去重等一系列话题。
所以我建议你从一开始就别只满足于“能通过”。真正的刷题笔记，应该是从一道题里榨出十道题的价值。后面我会详细展开怎么榨。
2. 暴力双循环：不是最优，但必须会写
2.1 最简单的两层循环写法
暴力解法不需要任何前置知识，核心思路就是枚举所有下标对。外层循环固定第一个数i，内层循环从i + 1开始枚举第二个数j。为什么从i + 1开始？因为如果从0开始，i和j会重复，而且会出现[0,1]和[1,0]这种重复组合，纯属浪费。
def two_sum_brute(nums, target): n = len(nums) for i in range(n): for j in range(i + 1, n): if nums[i] + nums[j] == target: return [i, j] return []就这么简单。range(i + 1, n)这个细节，保证了j永远在i后面，也保证了不会用到同一个下标。如果你在面试时先说这个暴力解，面试官不会觉得你水平差，反而会觉得你思路清晰，因为很多问题第一反应就应该是“能不能直接枚举”。
2.2 暴力法的复杂度账要算明白
暴力法的时间复杂度是O(n^2)。为什么？外层循环跑n次，内层循环在每一轮里平均跑n/2次，总共约n^2 / 2次加法比较。空间复杂度是O(1)，因为除了原数组，没有额外申请什么大结构。
这个复杂度在实际中意味着什么？假设n = 10000，那就是大约五千万次运算，本地跑还能接受；但n到100000，就是五十亿次，直接超时。所以力扣上这道题的测试用例规模一旦拉大，暴力法就可能过不去。这也是为什么你必须掌握更优解——不是为了炫技，而是为了能在数据规模变大时活下来。
反过来，我也要说一句：暴力解不是没用。在数据量很小、或者你还没想清楚边界条件时，先写一个暴力解核对结果，是很有效的调试手段。我刷题时经常先写暴力版本作为“标准答案”，再用优化版本去对比输出，这样定位问题非常快。
3. 哈希表解法：把查找从O(n)降到O(1)
3.1 两遍哈希：先把数组装进哈希表
暴力解慢在哪儿？每次匹配都要在数组里重新找“另外一个数”。如果能提前把所有数都放到一个哈希表里，那么每次查找就只需要O(1)的时间。这是典型的“空间换时间”。
两遍哈希的思路分两步：第一遍遍历数组，把nums[i]作为 key、下标i作为 value 存进字典；第二遍再遍历数组，对于每个i，计算complement = target - nums[i]，然后去字典里查complement是否存在。如果存在，并且查到的小标不是i自己，就返回结果。
def two_sum_hash_twice(nums, target): table = {} for i, num in enumerate(nums): table[num] = i for i, num in enumerate(nums): complement = target - num if complement in table and table[complement] != i: return [i, table[complement]] return []这里的关键是table[complement] != i这一句。因为字典是无序的，而且遇到重复值后，后一个下标会覆盖前一个下标。比如nums = [3, 3]，第一遍存完后table[3] = 1，第二遍遍历到i = 0时查到table[3] = 1，不等于 0，所以返回[0, 1]，这是对的。但如果不加这个判断，当complement == num时，你会把i本身也算进去，返回[0, 0]这种非法答案。
两遍哈希写法容易理解，但不是最优，因为要遍历两次数组。真正刷题时更常用的是下面这种一遍哈希。
3.2 一遍哈希：边遍历边判断，少一次循环
一遍哈希的核心变化是：不提前建表，而是一边遍历数组，一边在字典里查找。具体来说，遍历到当前元素num时，先检查target - num是不是已经在字典里了。如果在，说明之前已经遍历过某个数和当前数能凑成 target，直接返回；如果不在，就把当前num存进字典，继续往下走。
def two_sum_hash_once(nums, target): table = {} for i, num in enumerate(nums): complement = target - num if complement in table: return [table[complement], i] table[num] = i return []我比较喜欢用一个生活化的类比：你到一间教室里找人一起凑一个数字，手上拿一个登记册。每问一个人，就先看登记册上有没有名字能和自己凑成目标数；如果没有，就把这个人的名字和座位号记到册子上。这样你不用等全班人都登记完再开始配对，效率高了很多。
这个写法还有一个天然优势：它不会用到自己。因为当前元素在判断时还没有存进字典，所以你查到的 complement 一定是之前已经遍历过的某个下标，永远不可能等于当前i。这也是我强烈建议所有人主写一遍哈希的原因——它能从结构上规避一类边界问题。
3.3 为什么哈希查找是O(1)
很多人只知道“字典快”，但不知道快在哪儿。哈希表底层是一个数组，配合哈希函数把 key 映射到数组的某个位置。你查一个 key 时，直接算出它的哈希值，定位到对应桶，大多数情况下一次就能找到，所以平均复杂度是O(1)。
当然，哈希会有冲突。多个 key 被映射到同一个桶，这时 Python 字典会采用开放寻址法继续找空位，或者用链表/红黑树等结构处理冲突。实际使用中，Python 字典有自带的扰动机制和扩容策略，性能非常稳定。对这道题来说，你不用担心哈希冲突导致退化，面试官通常也只要求你答出“平均O(1)，最坏O(n)”就够了。
空间上，哈希法需要额外存一个字典，最坏情况下要存 n 个元素，所以空间复杂度是O(n)。这就是典型的拿空间换时间。
4. 我刷这道题踩过的几个真实坑
4.1 重复元素导致的误判
两数之和这个题，数组经常会有重复元素。很多人第一次写两遍哈希时，下意识认为“存到字典里后面的会覆盖前面的，所以应该没问题”，但实际上覆盖带来的行为并不直观。我前面说过nums = [3, 3]的例子，能通过。你换个用例试试：nums = [1, 1, 2]，target = 3。两遍哈希里，table[1]最终存的是下标 1。遍历到i = 0时，complement = 2，查到下标 2，返回[0, 2]，没问题。但如果target = 2，遍历到i = 0时，complement = 1，查到table[1] = 1，需要判断不等于 0，否则就错了。
所以我的建议是：如果写两遍哈希，table[complement] != i这个条件一个都不能省；如果写一遍哈希，根本没这个烦恼。这也是我把一遍哈希称为“最稳写法”的原因。
4.2 先存再查还是先查再存，顺序别搞反
一遍哈希里，先存再查是致命的。想象nums = [3, 2, 4]，target = 6。如果你先执行table[num] = i再查target - num，遍历到第一个元素 3 时，会把3:0存进去，紧接着查到complement = 3，发现3 in table，于是返回[0, 0]。这明显违反了“不能重复使用同一个元素”的约束。
正确顺序必须是：先查，查到了直接返回；查不到再存。这样当前元素永远不会提前出现在字典里，自配对问题就被彻底消灭了。我后来刷遍哈希类题目时，都会刻意提醒自己：查和存是两件事，顺序不要反。
4.3 返回下标，不是返回值，也不是第几个数
看起来是废话，但我在实际批改别人代码时见过太多次：有人return [num, complement]，返回的是两个数的值；有人用enumerate(nums, start=1)从 1 开始计数，返回[1, 2]。题目要求的数组下标是从 0 开始的，[1, 2]表示第二个和第三个元素，直接判错。
这里还有一个隐藏点：如果题目说的是“返回任意一种答案”还是“返回所有答案”，逻辑会完全不同。力扣原题因为是唯一解，所以返回一个就行。但如果你自己扩展练习时改成多解，就不能只return一次了，要用列表收集所有结果。
5. 从两数之和延伸出去：同类型题目的通用套路
5.1 三数之和、四数之和的变化
很多人在两数之和之后直接跳去三数之和，然后被去重搞到崩溃。其实三数之和可以理解为“先固定一个数，剩下的问题变成两数之和”。比如遍历数组，把当前元素当成第一个数，然后对后续子数组找两数之和，使三者相加等于 0。但这时要注意两个新问题：第一个是去重，重复的三元组不能出现；第二个是排序，因为无序情况下哈希去重非常麻烦。
我的建议是：三数之和优先排序加双指针，而不是直接用哈希表。因为排序之后，相同元素会聚在一起，移动指针时跳过重复元素就行。哈希表解法在去重上容易出错，面试时也不是最优解。
5.2 有序数组的变题：双指针才是主角
如果题目条件从“无序数组”变成“有序数组”，比如nums = [1, 3, 5, 7, 9]，那么更快、更省空间的解法是双指针。左指针left指向开头，右指针right指向末尾，计算两个指针所指数的和：如果和大于 target，说明右边太大了，right -= 1；如果和小于 target，说明左边太小了，left += 1；相等就返回。
双指针的时间复杂度是O(n)，空间复杂度是O(1)，比哈希法更优。为什么能这样做？因为数组有序，这个“大了缩右，小了扩左”的移动方向是确定的，不会错过任何一对。所以看到“有序”两个字，第一反应应该是双指针，而不是无脑哈希。
5.3 哈希里存什么，决定了这道题的难度
两数之和里哈希存的是“值 -> 下标”，因为要返回下标。如果题目改成“只判断是否存在两个数”，哈希存“值 -> True”就够了，代码还能更短。但如果问“返回所有和为 target 的数字组合并对重复组合去重”，哈希就不好使了，因为你要存“值 -> 一组下标”，去重逻辑非常麻烦。
这里值得养成一个思维习惯：拿到题目先想“题目最后要我返回什么”。如果是下标，哈希的 value 存下标；如果是布尔值，存布尔；如果是数字本身，可能根本不需要哈希。这个习惯能帮你应对后面一大票哈希表题目，比如两数之和、字母异位词分组、最长连续序列等。它们的核心都是“我能用空间记住哪些信息，来让后续查找变快”。
6. 面试时怎么回答两数之和才加分
6.1 先说思路再写代码
面试现场最忌讳拿到题目就闷头写。你应该先说：“最直接的做法是双重循环，复杂度 O(n²)；但每轮都要在数组里找 target-nums[i]，如果能把之前遍历过的元素存进哈希表，查找就能降到 O(1)，整体 O(n)。我倾向于一遍哈希，先查再存，避免重复使用同一个元素。”这段话一说完，面试官就知道你不仅会写题，还懂复杂度分析。
然后你再去写代码。写的时候可以同步解释每一行为什么这么写，特别是complement in table和table[nums[i]] = i这两行的顺序。面试官很看重你有没有真的理解，而不是背模板。
6.2 面试官会追问的几个高频变体
我面试别人时，如果候选人写出了哈希解，我会继续问下面这几个问题，这里也分享给你：
- 如果数组里有多个答案，要求返回所有组合并且不重复，怎么改？最简单的思路是排序后双指针，或者哈希加集合去重，但要注意边界。
- 如果内存很紧张，不能用额外空间怎么办？那就要看数组是否有序。有序直接双指针；无序可以先排序再双指针，时间复杂度会变成
O(n log n)，但空间能压到O(1)。 - 如果数组特别大，字典冲突严重怎么办？这是一个偏系统的追问，你可以答：从哈希表换成平衡树，查找从平均
O(1)变成O(log n)，但冲突问题会好一些；或者看能否优化哈希函数。实际工程中，哈希表仍然是默认选择，因为平均性能足够好。
面试官问这些问题的目的，不是为了让你背答案，而是看你在基础解法之外能不能灵活权衡时间和空间。所以平时刷题时，每道题都顺手想想“如果内存少一点”“如果数组有序”“如果有多解”这三个变体，进步会非常明显。
我个人刷这道题已经很多遍，每次刷完两数之和都会把一遍哈希解法在手边重写一次。它就像算法世界里的“九九乘法表”：简单，但你反复用，就能在上面搭出很多更复杂的结构。下次做题看到“两数”两个字，先想哈希，再看有序无序，这道题你就真正吃透了。
