反转链表详解：迭代与递归实现及面试高频变体题

反转链表这道题，几乎是每个刷算法题的程序员都绕不过去的坎。它在某知名算法测评平台上的编号是206，属于链表类型中最基础的一类题目，但别因为它叫“基础题”就小看它。我在面试里经常拿它当热身题抛出去，实际结果是一小时内能干净利落写完、把边界想清楚、再顺手补一个递归版本的人，比例并不高。可以说，这题就是对链表基本功最直接的一次检验。

题意一句话就能说清：给定单链表头节点，把整条链反转，返回新的头节点。但真正动手时，很多人会卡住：指针应该怎么指、什么时候要保存临时节点、递归函数到底返回什么、空链表和单节点怎么处理。这篇文章会按一条完整的学习路径把它讲透，先讲为什么它是经典，再拆解迭代和递归两条主流路线的实现原理，最后扩展到高频变体题和面试里最常见的坑。无论你是刚开始接触链表数据结构的新手，还是在准备跳槽想把手感练回来的候选人，这篇都能给你一套可以直接参考的思路。

1. 为什么反转链表是绕不开的经典题

1.1 实际场景里链表反转到底用在哪

很多人刷题时有个误区，觉得“反转链表”这种题纯粹是面试敲门砖，工作之后根本用不上。这个说法其实只对了一半。实际工程里，确实不会有人递给你一个函数说“请反转这个链表”，但反转链表背后的指针操作能力，用到的地方非常多。

举几个例子。实现一个LRU缓存时，双向链表里的节点删除、节点移动，本质上就是一连串改prev和next指针的操作，跟反转链表是同一个技能树。再比如判断一条链表是否为回文结构，常规解法是先找到中点，然后把后半段反转之后再做比较，这直接就是206题的具体应用。其他像图形学、嵌入式、底层容器实现中，链表作为基础数据结构出现，逆序遍历或局部逆置的需求也不罕见。

换句话说，206题更像一个“入口”。它后面跟着区间反转、K个一组翻转、成对交换节点这一大串高频题，而这些题几乎都是以206的单段反转作为最小单元。如果206没练到条件反射的程度，做那些题的时候会非常吃力，一边写主逻辑一边还要回头想反转的基本写法，效率就下来了。

1.2 这道题真正考你的是什么

作为面试热身题，206考的东西很聚焦，我总结下来主要有四个方面。

第一是链表结构本身的理解。链表节点不像数组元素那样连续存放，它靠引用把节点串起来。所谓反转，并不是移动节点里的数据值，而是改变节点之间的指向关系。很多新手卡住，根源就是没想明白“我改的是指针，不是值”。

第二是画图推演能力。做链表题最忌讳空想。靠谱的做法是先把节点画成方块，把指针画成箭头，然后把每一步改动标出来。能不能用一张图把过程推清楚，直接决定代码能不能一次写对。我面试时甚至会让候选人在白板上画出prev、cur、next的变化，能画清楚的人代码一般写得很快，画不清楚的人多半要返工。

第三是边界思维。空链表返回什么、单节点链表返回什么、反转完成后原来头节点的next应该指向哪里，这些边界如果能主动想到，代码质量至少高一个档次。

第四是抽象能力。迭代法的“三指针推进”，递归法的“返回值代表新头”，都是非常典型的抽象建模方式。这种思维不只链表题需要，处理树、图这类递归结构时也一样用得上。

所以这道题，我建议每个准备面试的人都把它练到两种写法都熟练，而不是只背一个能过测试用例的版本就收工。

2. 迭代法：用三个指针从头到尾翻转链表

2.1 核心逻辑拆解：为什么必须准备三根指针

迭代法的整体思路非常朴素：遍历链表，把每个当前节点的next改指向前一个节点。

但这里藏着一个关键的“链路断裂”问题。假设链表是1 -> 2 -> 3，如果你在处理节点1时直接把它next改成null，那节点1和节点2、3之间的联系就断了，循环没办法继续。解决办法就是事先把“下一个节点”保存到一个临时变量里，等当前节点的指针改完之后，再通过这个临时变量找回后续的链表入口继续处理。

这就是为什么必须有三根指针：prev指向当前节点的前一个节点，cur指向当前要处理的节点，temp暂存cur原本的next。你可能会问，能不能只用一个变量？不能。因为当你修改cur.next的瞬间，访问后继的唯一入口就丢了。想要继续遍历，就必须提前把它记下来。

可以把整个过程理解成一条流水线：prev是已经改好方向的“成品区”，cur是正在加工的“工作台”，temp是即将进入工作台的“原材料”。每轮循环把原材料搬到工作台，把工作台上的节点翻个方向丢进成品区，然后整条流水线右移一步。这样既不丢数据，又能保证每个节点被处理且只被处理一次。

2.2 代码实现与逐行解读

先给Python版本的完整实现：

def reverse_list(head): prev = None cur = head while cur is not None: temp = cur.next # 先保存后继节点 cur.next = prev # 反转当前节点的指针方向 prev = cur # 当前节点变成下一轮的前驱 cur = temp # 移动到原来的后继节点继续处理 return prev

这段代码只有7行，但每一行都有意义。prev = None对应“反转后原头节点应该指向空”，因为反转之后它变成了新的尾节点。temp = cur.next是整个算法里最容易被漏掉的一行，它负责在指针被改写前记住后续链路的入口。cur.next = prev是真正改变方向的一步，执行完这一步，当前节点就“回头”了。prev = cur和cur = temp则是把三根指针整体向右推进，准备处理下一个节点。

循环结束后，cur变成None，说明所有节点都处理完毕。此时prev停在原来的尾节点上，恰好就是反转后的新头节点，所以return prev。如果你写成了返回head，那就错了——原来的头节点现在变成了新的尾节点，用它当入口只能看到一个节点。

用生活场景再打个比方：一列人面朝前站好，手搭在前面的人肩上。反转就是让大家转身，把手搭到后面的人肩上。转身之前，必须让旁边的人先记住“你身后站的是谁”，不然一转身，后面的人就找不到了。temp就是那个负责“记住身后是谁”的角色。

2.3 边界条件检查：空链表、单节点、双节点

代码写完不等于结束，边界条件必须逐项确认。我习惯在脑子里跑四种情况。

空链表：head是None，进入while时cur就是None，循环体一次都不执行，直接返回prev也就是None，结果正确。

单节点链表：head指向唯一节点。第一轮temp是None，cur.next改成None，prev变成原头节点，cur变成None，循环结束，返回prev。此时返回的就是这个唯一节点，结果正确。

两个节点的链表：1 -> 2。第一轮处理后，1指向null，prev变成1，cur变成2。第二轮temp是None，2的next变成1，prev变成2，cur变成None，返回2，最终得到2 -> 1，正确。

多节点链表的推演模式完全一样。关键在于你要主动去做这个推演，而不是相信“代码看起来没问题”。面试现场，能把空链表、单节点这些边界条件讲得头头是道的人，往往比那些只丢一个主逻辑就完事的人更受认可。

3. 递归法：从后往前反转的另一种思维

3.1 核心思路：先反后续，再接当前节点

迭代法从前往后操作，递归法则换了一种视角：从后往前思考。

关键想法是这样：我先假设“从下一个节点开始的那部分”已经反转好了，此时我手里还有当前节点head，它仍然指向原来的下一个节点，也就是反转后那部分链表的尾节点。我只需要做两件事：让这个尾节点指向head，再把head的next置空，就完成了当前节点这一层的反转。

很多初学递归的人卡在一个点上：递归函数到底返回什么？这里必须记牢——反转链表的递归函数返回的是“反转后那一部分的新头节点”。拿1 -> 2 -> 3举例，对以2开头的部分调用递归，返回的是3，因为反转后整个链表的新头是3。回到处理节点1的这一层，我们不能返回1，因为1最终在链表尾部。所以代码里最后一定是return new_head，而不是return head。

用1 -> 2 -> 3走一遍完整过程。调用reverse_list(1)，发现头节点不是空且next不是空，于是调用reverse_list(2)。reverse_list(2)里继续调用reverse_list(3)。reverse_list(3)发现next为None，直接返回节点3。回到reverse_list(2)这一层，new_head是3，head是2，head.next是3，执行head.next.next = head让3的next指向2，再执行head.next = None让2的next置空，返回3。回到reverse_list(1)，new_head是3，head是1，head.next是2，执行head.next.next = head让2的next指向1，再执行head.next = None让1的next置空，返回3。最终链表变成3 -> 2 -> 1。

3.2 完整代码与关键细节说明

递归版完整代码：

def reverse_list(head): if head is None or head.next is None: return head new_head = reverse_list(head.next) head.next.next = head head.next = None return new_head

递归出口写得很简洁：链表为空或只有一个节点时，反转结果就是它本身，直接返回。

递归体分三步，顺序不能乱。new_head = reverse_list(head.next)先把后续部分彻底反转，拿到新头。之后head.next指向的是“反转后那段链表的尾节点”，也就是原来的下一个节点。head.next.next = head把这个尾节点的next指向当前节点，相当于把当前节点接到新链表末尾。最后head.next = None断开当前节点对原来后继的引用，防止链表成环。

这里必须强调一个顺序问题：head.next.next = head一定要在head.next = None之前执行。如果先置空，后面的head.next.next会访问到空指针，程序直接报错。我第一次写递归版时就卡在这个细节上，排查了好一阵才发现是顺序写反了。

3.3 迭代与递归如何选择：复杂度与面试角度

写题时到底用哪个？取决于场景。

从复杂度看，两者时间复杂度都是O(n)。迭代法空间复杂度O(1)，只用了少量指针变量；递归法空间复杂度O(n)，因为每一层递归都要占用调用栈，链表有多长，栈就有多深。如果链表特别长，比如几十万节点，递归版有栈溢出风险，迭代版完全没有这个问题。真要放在生产环境或大数据量场景，迭代法是更稳的选择。

从面试角度看，通常建议先写迭代，等面试官追问“还有没有其他写法”时再补递归，这样能展示两层深度。反过来，一上来就写递归，能把base case和返回值讲清楚，同样很加分。重点不是选哪个，而是两个都能熟练切换。

我个人练这题时有一个判断标准：能不看参考代码，先手写迭代，再闭眼写递归，并且能用自己的话把递归每一层发生了什么讲清楚。做到这一步，才算真正掌握，而不是背题。

4. 高频变体题：从206延伸出去的连锁题目

4.1 反转前N个节点

206是反转整条链表，但实际场景里更常见的是只反转一部分。先看最简单的变体：反转链表的前N个节点。

比如链表1 -> 2 -> 3 -> 4 -> 5，反转前3个节点，期望结果是3 -> 2 -> 1 -> 4 -> 5。

迭代做法是在206框架上加一个计数器：按正常三指针循环走，但只循环N次。循环结束后，prev指向反转部分的新头，cur指向原链表第N+1个节点。此时需要把原来的头节点，也就是节点1的next指向cur，否则反转后的部分会跟剩余部分断开。对应到代码就是head.next = cur。

很多人第一次写这道题会在最后一步犯迷糊，总以为退出循环就自动接好了。实际上，反转操作只是把前N个节点的内部指向改好了，如果不手动做外部拼接，链表中间是断开的。所以这题的关键口诀是：内部反转靠三指针，外部衔接靠手动。

4.2 区间反转链表为什么需要哑节点

把“前N个”再扩展成“从第m个到第n个”，就是区间反转。这也是一道很常见的题目，可以简单记为92题。

常规思路是：先找到第m个节点的前驱节点，以它为边界，把第m到第n个节点当作一段子链表做反转，再重新接回原链表。思路不复杂，但有一个容易出问题的地方：如果m等于1，反转区间包含原始头节点，反转后整个链表的头会变。如果代码里一直用原来的head当返回入口，最后拿到的就不是正确的新头。

解决办法是引入一个哑节点dummy，令dummy.next = head。这样即使头节点被反转，我们依然可以通过dummy.next拿到正确的新头，完全避开“m是否等于1”的分支讨论。这不是什么高级技巧，但很多人第一次想不到，面试时主动提出来，会让面试官觉得你确实理解链表头变化带来的困扰。

写这道题的另一个建议是：先单独写一个反转子链表并返回新头的辅助函数，再在主函数里做定位和拼接。函数拆分能帮自己理清楚哪些变量是内部反转用的，哪些是外部连接用的。

4.3 K个一组翻转链表

更进阶的变体是K个一组翻转：按每K个节点一组做反转，最后一组如果节点数不足K，保持原样。这道题通常记为25题，是很多大厂面试的高频题，也是206最典型的应用延伸。

实现思路分两大步。第一步，从当前位置数出K个节点。如果不够K个，说明这是最后一组，直接保持原样返回；如果够K个，就把这一小段当作子链表反转。第二步，处理好组与组之间的连接关系，让上一组的尾节点指向当前组反转后的新头。

代码细节上，至少需要记录四个角色：当前组的头、当前组的尾、上一组的尾、下一组的头。初学者最容易在“反转完一组之后，哪个指针该挪到哪个位置”上绕晕。我的建议是先写一个辅助函数，输入一段链表的头和尾，反转这段并返回新的头和尾，主函数里只专心组间拼接。这样代码结构会清爽很多。

面试时如果时间允许，还可以聊一句：分组翻转就是若干次206的组合，再加上组间指针修正。明白这层关系，理解起来会快很多。

4.4 成对交换节点（K=2的简化版）

当K固定为2时，这题就叫成对交换节点，通常记为24题。比如1 -> 2 -> 3 -> 4变成2 -> 1 -> 4 -> 3。

它的实现比K个一组简单，但同样能训练“两步一跳”的指针操作。用迭代写的话，需要一个prev指针记录上一次交换后的尾节点，每一轮交换两个节点，再把它们接回链表。递归写法更短：每层处理两个节点，先把第二个节点提升为新头，再让第一个节点的next指向“后面剩余部分交换后的结果”，最后让第二个节点的next指向第一个节点，返回第二个节点。

这道题很适合作为206学完后的练习题。它跟反转链表共享同一个核心能力——精确控制指针指向，只是多了一个“步长”概念。能流畅做出来，说明你对206的理解已经有一部分内化了。

实际上，从206到区间反转，再到K个一组翻转，是一条很清晰的学习路径。每一次都是在前一次的基础上增加一点复杂度。把这条路径走通，链表题在你眼里就不再是零散的知识点，而是一个整体。

5. 面试实战：常见错误与排查技巧

5.1 三个最容易在考场上犯的错误

根据我面试和带人刷题的经验，反转链表这道题有三个错误反复出现，大家写的时候特别留意。

第一个是忘记保存后继节点。迭代法里直接写cur.next = prev，却忘了先用temp保存cur.next。这一写的直接后果是，从当前节点开始，后面的所有节点都找不到了，链表“断”了。这类错误几乎都来自不画图、凭感觉写代码。解决办法只有一个——写之前先画一张三指针图，看着图写就不容易丢。

第二个是递归中产生循环引用。递归版写完漏掉head.next = None，或者顺序写反，导致链表内部出现环。举个最简单的例子，反转两个节点时，如果2指向1，而1的next仍然指向2，遍历链表就会无限循环。这个错误比较隐蔽，但如果面试官让你展开链表走一遍，会立刻暴露。我的习惯是递归版写完一定检查两行代码：head.next.next = head和head.next = None，一个都不能少，顺序也不能反。

第三个是返回指针错误。迭代法没把prev返回，或者递归法返回head而不是new_head。返回错的本质，是没有想清楚“反转后谁是新的头”。动手之前，先在心里回答这个问题：如果链表是1 -> 2 -> 3，反转后谁是新头？答案是3。如果连这个都还没想清楚，返回指针自然容易写错。

5.2 边界测试与自检清单

写完代码不能直接收工，必须自检。我给自己定的自检顺序是这样的：

有调试环境的话，还可以写一个遍历函数，把链表节点依次打印出来。每轮循环打一次prev.val和cur.val，能快速看出指针错乱是从哪一步开始的。这个习惯比在脑子里空想效率高很多。

面试时，即使代码写对了，我也建议口头把边界条件过一遍。这不是说废话，而是向面试官展示你知道边界在哪里，这在算法面试里是重要的加分项。

5.3 调试技巧与复杂度论证习惯

链表题的调试跟普通业务代码不太一样。它没有复杂的业务逻辑，问题基本都出在“指针指向哪里”。所以调试重点不是看日志，而是“跟指针”。

我常用的办法是，在每次指针变动后，盯住temp、prev、cur三个变量的变化规律。如果发现temp提前变成了None，或者prev没有按预期往右移动，基本就能锁定是哪一行出了问题。跟指针的时候，心态要稳，不要跳着看，一步一步来。

复杂度论证方面，面试官几乎必问。要能清晰说出：迭代法时间复杂度O(n)，因为每个节点恰好被处理一次；空间复杂度O(1)，因为只用了常数个指针变量。递归法时间复杂度O(n)，每个节点触发一次递归调用；空间复杂度O(n)，因为递归调用栈深度和链表长度相同。如果被问“能不能用O(1)空间实现反转”，直接答迭代法即可。这些基本功不仅面试用得上，做系统设计时评估一个方案的成本，也同样有意义。

6. 复盘建议与个人体会

6.1 练习顺序上的建议

这题我给一个个人建议：别满足于“能通过测试用例”。刷题平台的通过率相对容易达成，但反转链表真正的价值，在于把链表操作的思维方式内化成肌肉记忆。我自己第一次接触这题时也是看着答案才搞懂，后来靠反复画图、写递归、做变体题，才真正达到闭眼能写的程度。

建议的练习顺序是：先手画三指针迭代过程，不看参考代码手动实现；再写递归版本，并尝试用自己的话把每一层递归的解释说出来；最后把前N个节点、区间反转、K个一组、成对交换这些变体都过一遍。遇到底层逻辑不清晰的地方，就回到206对照基础写法。这样一轮下来，链表相关面试题的基本盘就算打牢了。

6.2 一个很实用的小技巧

最后分享一个我写链表题时的小习惯：动手之前，先花五秒钟问自己一句——“反转完成后，谁会成为新的头节点”。这个问题看起来简单，但能帮你在一开始就锁定返回值的逻辑，也能帮你判断是否需要dummy节点。整链反转，新头是原链表尾节点；区间反转且区间包含原头，新头就变了；K个一组翻转，每组的新头是这一组的原尾节点。想清楚这一点，写代码的时候手都会稳很多。

这道题刷完不是结束，而是链表技能树的起点。后面的路很长，但206绝对值得你多花时间把它吃透。