陆拾贰號在 LeetCode 官方的热门题单和“热题 HOT 100”里，240. 搜索二维矩阵 II、160. 相交链表、206. 反转链表这三道题经常被当成独立问题来刷。我平时带新同事，有个观察：很多人看完题解能把代码敲出来，但面试官一追问“为什么从右上角搜而不是左上角”“双指针为什么不会死循环”“递归反转到底哪里把指针接上了”，就卡住了。真正的问题不是没背过答案，而是没想明白“为什么最优解比暴力少走了那么多步”。
这三道题放一起其实是一条线：搜索二维矩阵 II 考的是利用有序结构的空间方向；相交链表考的是用两次遍历抹平长度差；反转链表考的是单链表指针重连的基本功。它们的暴力解都很好想，但高效解背后的共同点是——把题目里隐含的结构特征，转化成减少无效判断的依据。这篇文章不打算把三道题的代码念一遍，而是把推导过程、边界情况、以及我实际写代码时踩过的坑拆开说清楚。适合正在准备面试、或者已经刷过一遍想重新理顺思路的人，新手按顺序读也能直接照练。
1. 三道题为什么值得放在一起复盘
先说结论：如果只把它们当成三道孤立的题去刷，你得到的只是三个“印象”；如果放在一起看，你会得到一套分析复杂度、找冗余操作的通用方法。
1.1 三道题对应的能力模块
-
搜索二维矩阵 II（LeetCode 240），输入是一个“每行左到右升序、每列上到下升序”的矩阵，问 target 是否存在。它考的是对空间有序性的理解，以及搜索方向的选择。这是“矩阵类搜索题”里最经典的模型之一，LeetCode 74 搜索二维矩阵是它的简化版本，很多人会把这两题搞混，后面我会专门讲区别。
-
相交链表（LeetCode 160），给两个单链表头节点，判断它们在哪个节点相交。它考的是链表结构里“共享后缀”的性质，以及如何不借助额外空间判断两条路径的汇合。剑指 Offer 里同题出现率极高，面试官也喜欢在这里加问。
-
反转链表（LeetCode 206），把整个单链表反转。它考的是指针操作的最基本功，也是后续反转区间、K 个一组翻转这些难题的“器官基础”。别看它简单，递归版本里
head.next.next = head这一行，很多人写不出来也不理解。
1.2 表面不一样，优化路径是一样的
我让新同事做的第一步，不是看题解，而是先把自己的暴力思路写出来。
- 搜索矩阵的暴力思路是：两层循环，逐个元素比较。复杂度 O(m×n)，完全忽略有序条件。
- 相交链表的暴力思路是：固定一个链表的每个节点，遍历另一个链表找相同节点。复杂度 O(m×n)，完全忽略“相交之后共享相同尾部”的含义。好一点的版本用哈希集合，空间 O(m)。
- 反转链表甚至不存在“暴力解”，因为它要求原地反转，最直觉的“新建一条链表然后头插”实际上违反了题目对空间的要求，所以必须直接想明白指针操作。
这三道题的优化路径可以抽象成同一个问题：“算法里哪些遍历是重复的，哪些比较是可以提前结束的？”搜索矩阵的答案是把搜索起点放在右上角，每一次比较都能排除一整行或一整列；相交链表的答案是让两个指针走完自己的路再走对方的路，距离差在路程中自然消失；反转链表的答案是沿途修改指针方向，且每步只需要三个引用。
所以与其一道题一道题死记，不如先建立一个“找无效工作”的意识。下面逐个展开。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 搜索二维矩阵 II：右上角出发，每一步都在排除一整行
2.1 有序矩阵的无效遍历和第一个优化
题目定义了一个 m x n 矩阵 matrix：
- 每行的元素从左到右升序排列；
- 每列的元素从上到下升序排列。
目标：判断一个整数 target 是否存在于矩阵中。存在返回 true，否则返回 false。
我第一次做这题，第一反应就是两层循环逐行逐列扫一遍。这个解法当然对，但面试官一定会追问：“题目给你有序条件，你不用，浪费时间。”其实每行本身是有序的，所以第二个自然想到的思路是：把每一行看成一个一维有序数组，对每一行做二分查找。于是单次查找的复杂度从 O(m×n) 降到 O(m×log n)。这个解已经能过，但它仍然没有完全利用“列也有序”这个条件，扫描完整矩阵仍然会访问到很多和目标完全不在同一数量级的区域。
真正的最优解把矩阵看成一张二维“等高线图”：左上角是最小值，右下角是最大值，而右上角和左下角是两个中间状态点。关键在于，我们要选一个“左右方向增大、上下方向减小”（或反过来）的位置作为搜索起点。
2.2 为什么起点是右上角，而不是左上角
我把这题拿来给校招生讲，至少有一半人第一反应是“从左上角开始走，当前值小于 target 就往下或往右”。这个思路听起来合理，但细想就坏了：从左上角的矩阵最小值出发，它只能告诉你“我该变大”，可变成大的方向有两个——下和右，你怎么知道往哪走？同理，从右下角出发也只有两个方向都是变小，也无法唯一判断。
但是如果你站在右上角这个位置，情况完全不同：
- 当前值大于 target，说明这一列中，当前元素以及它下方的所有元素都比 target 大，因为每一列往下是递增的。所以整列可以直接排除，向左移动一列。
- 当前值小于 target，说明这一行中，当前元素以及它左边的所有元素都比 target 小，因为每一行往左是递减的。所以整行可以直接排除，向下移动一行。
这就是“排除一行/一列”的决策依据：每一步选择都有一个方向是严格明确无效的，所以不需要回退。整个过程像在矩阵里走一个之字形路径，最多走到左下角就结束。
我从右上角 (0, n-1) 开始，设 i = 0, j = n - 1。用 matrix[i][j] 和目标比较：
- 相等，返回 true；
matrix[i][j] > target，说明当前列下方都比 target 大，排除当前列，j 减一；matrix[i][j] < target，说明当前行左边都比 target 小，排除当前行，i 加一。
模拟一个例子：矩阵
code复制[1, 4, 7, 11, 15]
[2, 5, 8, 12, 19]
[3, 6, 9, 16, 22]
[10, 13, 14, 17, 24]
[18, 21, 23, 26, 30]
target = 5。起点是 15，15 大于 5，说明第五列全部大于 5，j 移到 3。看 11，还是大于 5，排除列，j 移到 2。看 7，大于 5，排除列，j 移到 1。看 4，小于 5，说明第一行左边没有 5，i 移到 1。看 5，命中。整个过程只比较了 5 个元素，如果蛮力扫描需要扫描到第二行第二列才发现，如果是暴力两重循环，最大可能要比较 25 个元素。
2.3 复杂度、代码和两个容易踩的坑
时间复杂度是 O(m+n)，因为每一步要么行号增加 1，要么列号减少 1，最多走 m+n 步。空间复杂度是 O(1)。以下是我实际用的 Python 实现：
python复制def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
if not matrix or not matrix[0]:
return False
m, n = len(matrix), len(matrix[0])
i, j = 0, n - 1
while i < m and j >= 0:
if matrix[i][j] == target:
return True
elif matrix[i][j] > target:
j -= 1
else:
i += 1
return False
第一个容易踩的坑是循环条件顺序。有人把 i < m 和 j >= 0 写反了，或者用 while i < m or j >= 0，一旦走到左下角后，要么 j 变成 -1 还在循环里访问 matrix[i][-1]，这是 Python 的倒数索引，结果真的会让你怀疑人生；要么 i 越界直接抛异常。记住，必须同时满足行没走完、列没走完才能继续。
第二个坑是把 LeetCode 74（每行整体有序、且下一行第一个元素大于上一行最后一个元素）的做法直接套过来。74 可以把整个矩阵拍平成一个递增数组做一次二分，因为它的有序性是“全矩阵整体一维递增”；但 240 只保证每行内和每列内递增，不保证 matrix[0][n-1] < matrix[1][0]。所以 240 不能拍平二分，只能走二维搜索。面试时被问“能不能优化到 O(log(mn))”，一定要能说出为什么 240 不行。
3. 相交链表：双指针把两条路拼成一条，长度差自然归零
3.1 先搞清楚“相交”到底判断什么
LeetCode 160 的输入是两个单链表的头节点 headA 和 headB，要求返回相交节点；不相交返回 null。题目有个容易被忽略的前提：如下面的示例，链表 A 是 4 -> 1 -> 8 -> 4 -> 5，链表 B 是 5 -> 6 -> 1 -> 8 -> 4 -> 5，它们在值为 8 的节点开始共享后面的节点。面试里用 Java 或 C++ 要尤其注意，这里的“相同”指的是同一个节点对象，也就是引用地址相同，不是节点里的 val 相等。链表 B 里有一个值为 1 的节点，链表 A 里也有一个值为 1 的节点，但它们是两个不同的节点对象，只是值碰巧相等。如果直接按值判断，很容易误判。
第一反应自然是哈希集合：遍历 headA，把所有节点放进一个 Set，然后遍历 headB，如果某个节点已经在 Set 里，它就是交点。这是 O(m+n) 的时间，O(m) 的空间。这道题如果没有“空间 O(1)”的要求，用哈希集合完全没问题。但面试官只要追问“能不能不用额外空间”，许多人就开始紧张了。
3.2 双指针为什么能走到一起：核心是一条等式
最优解是双指针，而且代码极短，短到很多人背下来却解释不清。
用 pA 和 pB 分别从 headA、headB 出发。两个指针都一步一步走。当 pA 走到链表末尾时，把它重新定位到 headB；当 pB 走到链表末尾时，把它重新定位到 headA。继续走，两者相遇处就是相交节点。如果两个链表不相交，它们最终会在空指针处相遇，返回 null。
原理应当这样看：设链表 A 不相交的前缀长度为 a，链表 B 不相交的前缀长度为 b，公共部分长度为 c。链表相交时，pA 从 headA 出发，走到交点需要走 a 步，然后接着走公共部分，走完 A 的长度 a+c 后跳到 headB，继续走 B 的前缀 b，此时 pA 总共走了 a+c+b 步，位置在交点。再看 pB，从 headB 出发，走到交点需要 b 步，走完 B 的长度 b+c 后跳到 headA，继续走 A 的前缀 a，此时 pB 总共走了 b+c+a 步，位置也在交点。因为 a+c+b 等于 b+c+a，所以在同一时刻两个指针都到达交点。
换句话说，双指针通过“把两个链表拼接起来”的方式，人为地让两个指针比较的总里程相等，从而忽略了 a 和 b 的长度差。这在本质上和“先算出两个链表长度差 d，然后让长链表指针先走 d 步，再一起走”是同一思想，但代码更简洁。
两个链表不相交的情况也同理：pA 走完 A 再走 B，pB 走完 B 再走 A，最终都在空指针处停下。很多人担心这里会死循环——不会。如果 m = len(A)，n = len(B)，pA 一共走 m+n 步，pB 一共走 n+m 步，然后两者都是 null，while pA != pB 的循环条件不成立，自然退出。这里一定要用“引用相等”比较，不要用 val。
3.3 完整代码与隐藏的边界问题
Python 实现很直接：
python复制def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
if not headA or not headB:
return None
pA, pB = headA, headB
while pA != pB:
pA = pA.next if pA else headB
pB = pB.next if pB else headA
return pA
这段代码看起来简单，边界问题都在细节里。一个是两个链表中有一个为空时，直接返回 null，否则后面 pA.next 会访问空引用；另一个是当两个链表恰好长度相等且相交时，它们不需要切换链表就能直接相遇，这也应该被正确处理——循环第一次判断就可能在某个非空节点处命中。在面试白板写代码的时候可以顺手把“如果没必要切换怎么办”想清楚。
面试官在这个题上还有一个常见升级问法：如果链表中存在环怎么办？这个问题其实是单独类型，我的建议是把它当作独立的一环问题来分析：先分别判断两个链表是否有环，处理环的入口点，把环拆掉再回到无环相交逻辑。实际面试中真正要求当场写出完整有环相交解的概率不高，但把“先判环、再拆环回退成无环问题”的思路说出来，会比只会背无环双指针版本的人高一截。
4. 反转链表：指针重连的所有细节，都在迭代和递归之间
4.1 迭代版本：三引用到底在倒腾什么
LeetCode 206 要求反转一个单链表。所谓反转，就是把原来的 1 -> 2 -> 3 -> 4 -> 5 变成 5 -> 4 -> 3 -> 2 -> 1，也就是把每条边的方向都换掉。最基础且面试常考的是迭代法。
有人说“三指针反转链表”，指的是 prev、curr 和 next。prev 初始化 null，表示当前节点反转后应该连向的节点；curr 初始化 head，表示当前正在处理的节点；next 用于在 curr 的指针被修改前保存它的后继，不然你把 curr.next 改成 prev 之后，原本后面的链表就跟丢了。
每一步做四件事：
- 用
nextTemp = curr.next记住下一步要去哪； - 把
curr.next指向 prev，完成当前节点的指针反向； - 把 prev 前移到 curr，让它变成下一个节点的“前驱”；
- 把 curr 前移到 nextTemp，进入下一轮。
模拟 1 -> 2 -> 3：
- 初始：prev = null，curr = 1。
- 第 1 轮：nextTemp = 2，1.next = null，prev = 1，curr = 2。链表变成
1 -> null，后面 2 -> 3 暂存于 nextTemp，但 curr 已经指向 2。 - 第 2 轮：nextTemp = 3，2.next = 1，prev = 2，curr = 3。现在局部是
2 -> 1 -> null。 - 第 3 轮：nextTemp = null，3.next = 2，prev = 3，curr = null。完成。
- 最后返回 prev（就是新的头节点 3）。
对应代码：
python复制def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
prev = None
curr = head
while curr:
next_temp = curr.next
curr.next = prev
prev = curr
curr = next_temp
return prev
这个代码有两个地方容易写错：一旦忘记 next_temp = curr.next，循环里第二步后原链表断裂，导致 curr 无法前进；或者最后返回了旧的 head——旧 head 变成尾节点，它的 next 已经是 null，返回它结果是空链表，不是反转后的结果。
4.2 递归版本：理解 head.next.next = head
递归版本代码更短，但理解门槛更高：
python复制def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
if not head or not head.next:
return head
new_head = self.reverseList(head.next)
head.next.next = head
head.next = None
return new_head
如果只背代码，过两天就忘。要理解它，关键在于“相信递归的返回值”：调用 reverseList(head.next) 之后，从 head.next 开始的整条子链表已经被反转了，并且返回的是这段子链表的新头。此时 head.next 这个节点，在新的子链表中变成了尾节点。所以要让 head 接上去，只需要让原来子链表的尾节点 head.next.next 指向 head，也就是 head.next.next = head，然后把 head 的下一个置空，防止成环。
我举个例子：链表 1 -> 2 -> 3 -> 4 -> 5，递归调用反转 2 -> 3 -> 4 -> 5 得到 5 -> 4 -> 3 -> 2，new_head 是 5，此时 head 还是 1，head.next 是 2，而 2 在这个反转后的子链表里恰好是尾节点。执行 head.next.next = head，就是让 2.next = 1；再执行 head.next = null，断开 1 和 2 原来的方向。整体变成 5 -> 4 -> 3 -> 2 -> 1。
有人会问：那为什么不直接 head.next.next = head 就行，还要把 head.next 置 null？因为如果原来的链表中 head 不是原始链表的头，而是中间某个节点，那 head 在原本链表里还指着一个后继。反转后 head 变成这段子链表的尾节点，尾节点的 next 必须为 null；否则整个链表会产生环。这是一个很隐蔽的坑，单步调试时能观察得到。
4.3 递归与迭代的取舍，以及这题的延伸价值
从时间复杂度和实现步骤上看，迭代就是标准的 O(n) 时间、O(1) 空间；递归虽然代码短，但需要 O(n) 的递归调用栈空间，很多面试官会追问“递归解法空间是多少”，如果你答“也是 O(1)”，就错了。考虑到工程上链表可能很长，递归栈溢出不是理论问题。但在面试中，递归解法体现了对“递归定义反转”的理解，也是后续许多题的基础。
反转链表本身是基础，但它的延伸极其重要。LeetCode 92 要求反转从 left 到 right 的区间，LeetCode 25 要求 K 个一组翻转链表。后两者都需要先掌握整链反转。尤其是 K 个一组反转，本质是“先把链表按 K 个分组，每组内用反转链表的方法处理，再处理组与组之间的拼接”。我建议把 206 练到能默写迭代、能讲解递归、能把时间空间复杂度说清楚，再碰 92 和 25，顺序才不会乱。
5. 三种典型错误和判断思路总结
5.1 一个“失败场景”对照表，调试时直接查
我自己在带人过程中，发现这三道题的错误非常集中。整理成一个表，调试时可以先做排除：
三道题共同的调试重点，是“优先检查访问空指针/越界”，其次才是逻辑错误。刷题时我习惯在白板上先画出初始状态和走三步后的指针快照，再对照代码，比自己反复 println 快很多。
5.2 面试里，怎么跟面试官解释你的每一步优化
很多候选人有一个坏习惯：一上来就甩最优解，面试官根本不知道你为什么想到这个方向。更稳妥的方式是分三层讲：
第一层讲暴力。先承认最直接的方法是什么，比如“矩阵搜索先想到每行二分”“相交链表先想到哈希集合”。这展示你具备“从最朴素想法出发”的能力。
第二层分析冗余。指出暴力解里哪些比较是不必要的。对搜索矩阵，二分已经利用行序但浪费列序；对相交链表，哈希集合的额外空间冗余明显。面试官想听的就是这句话。
第三层把结构特征转化为搜索方向的唯一性。矩阵题的关键话术是“右上角同时是一个方向的极大值、另一个方向的极小值，所以比较结果可以排除一整行或一整列”；链表相交的关键话术是“两个指针分别走完 A+B 的总长度，相遇条件由 a+c+b 等于 b+c+a 保证”。
把这些讲清楚，比背 20 道题还管用。我之前带的一位实习生，第一次模拟面试时只会背代码，我要求他每次讲题都必须先讲暴力解、再说哪里冗余、再动笔。练了二十道题之后，他面对没见过的新题也能给出有条理的思路，而不是慌乱地回忆题解。刷题这件事，真正值钱的不是你做过的题量，而是你能不能在没有题解的情况下，自己想清楚“为什么可以少走这几步”。这三道题恰好就是最便宜的训练场。