LeetCode 24题“两两交换链表中的节点”是我见过最“看着容易、上手翻车”的链表题目之一。它在热门100题里的出镜率很高但很多人第一次提交就超时或死循环哪怕跑通样例换一个“节点数为奇数”的用例又崩。原因很简单这道题要的不是背对一个函数输出而是真正理解链表里“指针即连接”这件事。题目本身不复杂给你一个链表两两交换其中相邻的节点返回交换后链表的头节点。输入 1-2-3-4输出 2-1-4-3输入 1-2-3输出 2-1-3。限制条件里还会明确写着“不能修改节点内部的值只能进行节点交换”。这篇文章不会只丢一份能抄的题解。我会把递归、迭代两种主流解法都拆开讲清楚每一步为什么这么写再看几个最容易踩的坑最后聊聊从两两交换到 K 个一组翻转这类进阶变体。不管你是刚开始刷题还是准备技术面试应该都能从这里带走一套“链表指针操作”的通用手感。1. 两两交换到底在交换什么指针才是链表的主角1.1 题目回顾输入输出与限制先对齐一下题目的语义。LeetCode 24的原题描述是给你一个链表两两交换其中相邻的节点并返回交换后链表的头节点。你不能只是简单的改变节点内部的值而是需要实际的进行节点交换。几个典型的输入输出1 - 2 - 3 - 4输出 2 - 1 - 4 - 31 - 2 - 3输出 2 - 1 - 3空表 null输出 null只有 1 个节点 1输出 1前两个用例大家都能看懂最容易忽略的其实是后两个边界情况空链表和单个节点。很多人在递归出口只写了一个判断条件漏掉单节点的情况结果提交后直接空指针报错。1.2 交换值与交换节点的本质差异链表节点在内存里的结构很简单一个区域存数据 val一个指针 next 指向下一个节点。链表之所以叫链表就是因为它没有连续的数组空间而是靠 next 把一个个分散的节点穿成串。你在链表上做任何结构性操作本质都是改指针而不是改 val。两两交换里的“交换”指的是调整指针指向让节点在链表中的相对顺序发生变化。但有些平台只检查输出序列所以你在 LeetCode 上偶尔能看到一种“偷懒”解法把两个节点的 val 互换不动指针。测试确实能过因为这题判题只关心最终遍历出来的值序列。但面试官看到这种写法一般会立刻追问一句“题目要求不修改节点的值你现在交换的是节点本身吗”这时候你就会意识到内存里节点的物理顺序没有任何变化只是 A 节点里存了 B 的值B 节点里存了 A 的值。严格讲它没有达到题目的语义。那为什么题目非要“实际交换节点”一是工程成本问题。一个链表节点往往不止存一个整数它可能携带几十个字段比如用户信息、状态标记、时间戳、缓存数据。在节点内部来回赋值数据拷来拷去既慢又容易漏字段。二是引用安全问题。如果链表之外还有一个指针直接指向节点 A交换 val 之后那个外部引用看到的内容会跟着变可能引发连锁的语义错误但交换指针的话节点 A 还是那个节点 A只是它在链表里的位置变了。理解这一点你就明白这道题表面考指针操作实际考的是对链表存储模型的领会。1.3 为什么说这道题是链表基本功的试金石链表题里24题几乎是绕不开的基础关卡。它集合了链表操作的三个典型难点头节点不固定、指针改动不止一处、边界条件隐蔽。头节点不固定很好理解交换完前两个节点链表头从 1 变成 2你返回的 head 必须跟着变。指针改动不止一处是因为一次交换要动三条 next 链接顺序错了就断链。边界条件隐蔽是说空链表、单节点、奇数长度这些用例只有你主动想到才会去测。把这道题吃透后面做反转链表 II、删除倒数第 N 个节点、K 个一组翻转会有一种“共用同一套思维底座”的感觉。反过来如果你连 24 题都靠背代码那后面遇到稍微变形一点的题基本就是换个题型就懵。2. 递归解法把后面的节点甩给函数自己处理2.1 核心思想只处理最前面两个节点递归解法的思路可以浓缩成一句话函数只负责交换最前面两个节点交换完之后后面那一条已经处理好的链表会被接回来。用数学归纳法来看递归出口是“链表为空或只有一个节点时不需要交换”。在非出口情况下你从当前链表里取出头部两个节点 first 和 second然后调用同一个 swapPairs 函数去处理 second 后面的所有节点。等递归返回后你已经拥有一段“内部全部完成两两交换”的新链表它的头节点是递归返回的那个节点。再把 first 接到这段新链表的前面然后让 second 指向 first这一对就算交换完成。这里的关键是递归返回给我们的绝对不是原来的 second.next 那个节点而是处理完后的新头节点。以 3-4-5 为例递归处理后会变成 4-3-5返回的是节点 4。如果你想当然地把 first 接到原来的 second.next 上就等于是把一个“没有参与递归交换”的旧 5 接了回来链表结构直接错乱。2.2 代码与逐行解读class Solution: def swapPairs(self, head: ListNode) - ListNode: # 递归出口空链表或单节点无需交换 if not head or not head.next: return head # 取出当前这一对节点 first head second head.next # 递归处理 second 后面的所有节点返回处理后链表的新头 new_head self.swapPairs(second.next) # 交换操作first 指向后续链表的头second 指向 first first.next new_head second.next first # 返回这一对的新头现在是 second return second逐行解释一下出口检查if not head or not head.next。这两个条件缺一不可。只写 not head遇到单节点链表时second 会变成 None下一步访问 second.next 就空指针了。first headsecond head.next把当前两个节点锁进局部变量。有了它们后面代码怎么改 next都不会把这两个节点弄丢。new_head self.swapPairs(second.next)递归调用自己处理 second 后面的链表。这个过程返回的是“后面那段链表完成两两交换之后”的头节点。以 3-4 为例返回的是 4。first.next new_head把 first 接到后面那段链表的新头上。这时 first 不再是原来的 first它变成了“当前这一对的第二个节点”位置。second.next first让 second 指回 first完成这一对内部的换序。return second当前这一对交换完成后second 处在链表的第一个位置所以要返回 second 给上一层。一个让我觉得很有用的生活化类比整理一串手链上的珠子。你只管把最前两颗珠子换个位置然后把身后已经整理好的那一段整体接过来。你不需要自己跑到后面去处理每一颗珠子递归函数就是那个帮你整理后面的人。2.3 递归解法的代价递归解法代码非常短思维上也优雅但有一个没法回避的短板空间复杂度是 O(n)。时间上每个节点只被访问一次很容易得出 O(n)。空间上递归深度大约等于链表中节点对数也就是 n/2 的量级。每进入一层递归系统栈上都要保存一层函数的局部变量和返回地址。链表特别长的时候比如上万节点递归版本有爆栈风险。所以我的建议是递归解法用来理解题意、建立心智模型但真到面试写代码或者处理大规模数据时迭代解法才更稳。3. 迭代解法哨兵节点一举消灭头节点特判3.1 哨兵节点解决了什么问题很多题解一上来就写dummy ListNode(0)新手容易一头雾水。先解释一下它解决的问题。普通链表没有“头节点的前驱”。当你要交换头两个节点 1 和 2 时1 只有一个 next 指向 2没有任何一个指针指向节点 1 本身。所以当你把 2-1 接好之后链表的头变成了 2但你的 head 变量还傻傻指在 1 上。没有 dummy 的话你得单独写一段 if 逻辑处理“被交换的是头节点”这种情况代码变得冗长还容易漏。哨兵节点也叫哑节点、虚拟头节点它的 next 指向原来的 head。因为 dummy 本身不是有效数据所以所有真实节点都拥有了前驱包括原来的头节点。最后返回 dummy.next无论怎么交换它都指向真正的链表头。这招在链表题里几乎万能只要题目的头节点可能变化先放一个 dummy 永远不亏。反转链表、删除节点、归并排序只要是链表题你都可以条件反射地想到它。3.2 四步操作逐步解析迭代版代码如下class Solution: def swapPairs(self, head: ListNode) - ListNode: dummy ListNode(0, head) pre dummy while pre.next and pre.next.next: first pre.next second first.next # 第一步前驱先连到 second pre.next second # 第二步first 指向 second 后面的节点 first.next second.next # 第三步second 指回 first second.next first # 第四步pre 移动到 first准备下一对 pre first return dummy.next拿 dummy - 1 - 2 - 3 - null 举例此刻 first 1second 2。目标是把这一对变成 dummy - 2 - 1 - 3 - null。四步的执行顺序不是随意的pre.next second让前驱先跟 2 接上。这一步建立了一个新的连接但还没有破坏任何旧连接。first.next second.next让 1 指向原来 2 后面的节点 3。这一步很关键它把“后续链表的头”提前固定到了 1 的 next 上。second.next first让 2 指向 1。因为 2 原本指向 3但 3 已经被第 2 步用 first.next 保住了所以这里改掉 second.next 不会丢节点。pre firstpre 从 dummy 移动到节点 1 上。现在 1 是当前这一对的第二个节点同时也是下一对的前驱。如果顺序反了比如先执行 second.next first你和我说说second 原来指向的 3 去哪里了first.next 还指向 2没有任何指针能到达 3。链表断了。C 版本也顺便贴出来面试里 C 出镜率很高class Solution { public: ListNode* swapPairs(ListNode* head) { ListNode* dummy new ListNode(0); dummy-next head; ListNode* pre dummy; while (pre-next pre-next-next) { ListNode* first pre-next; ListNode* second first-next; pre-next second; first-next second-next; second-next first; pre first; } return dummy-next; } };C 版本要注意 dummy 是 new 出来的工程代码里记得释放但 LeetCode 判题环境一般不会盯这个面试时你主动提一句“这里为了演示不释放 dummy生产代码需要 delete”反而是加分项。3.3 复杂度与工程写法迭代解法的时间复杂度是 O(n)空间复杂度是 O(1)。它不需要递归栈只靠三四个指针变量在链表上挪动处理超大链表也不会爆栈。解法时间复杂度空间复杂度核心优点递归O(n)O(n)思路简洁代码最短迭代 哨兵节点O(n)O(1)性能最优面试推荐从工程角度迭代版的可读性也可以做得很好。问题不在写法而在命名。很多人喜欢把三个指针命名为 cur、next、temp代码一长就分不清谁是谁。我建议直接用 pre、first、second 这种表意明确的命名或者干脆叫 prev、node1、node2。链表题本来就是指针游戏命名越清晰定位 bug 越快。4. 先连前驱还是先保后继防止断链的三步走4.1 断链的根源覆盖即丢失链表操作里最常见的灾难是“断链”——某个节点从所有可达路径里消失链表断成两截或者遍历时访问到空指针。断链的根源永远只有一个你在修改某条指针时它原本指向的那个节点没有被其他任何指针保存。信息一旦被覆盖就无法找回。用 24 题演示这个原理。假设你拿到了 first 1、second 2、rest 3。你想让 2 指向 1于是写了 second.next first。可 2 原本的 next 是 3这个赋值直接把 3 从链表里抹掉了。除非你先用变量保存 rest或者先用 first.next second.next 把 3 的位置固定下来否则 3 就成了永远找不到的孤儿节点。这两条路都能走通要么先引入一个临时变量保存 rest要么按标准顺序先修改 first.next。LeetCode 官方题解和大多数答案采用的是后者因为不需要额外变量代码更干净。4.2 三步走保存现场、先连后断、移动指针链表节点级操作我建议养成三个肌肉记忆保存现场。凡是要被覆盖的指针先确认它指向的节点是否还有其他引用。如果只有一个引用就先把它存进局部变量。先连后断。新的连接先建立旧的连接再断开。这样即使中间状态奇怪一点节点也不会丢失。移动指针。处理完一个小段后工作指针必须走到下一小段的前驱否则会反复处理同一段。放到 24 题里first 和 second 被局部变量锁住等于已经完成了“保存现场”。然后 pre.next second 建立新连接first.next second.next 把后续链表固定住最后 second.next first 断掉旧连接并把两个节点换序。每一步都不会造成节点丢失。很多同学在反转链表那道题里也踩过同样的坑。反转链表时你的核心操作是 cur.next prev但如果不先把 cur 原来的 next 保存下来走了两步就找不到后面的链表了。所以你看反转链表和两两交换其实用的是同一套逻辑在改变一个节点的后继之前必须保证它的旧后继已经被其他途径引用。4.3 用“节点计数”自查代码写完链表操作代码怎么快速判断有没有断链一个机械化的方法是计数每次操作结束后从 head 开始完整遍历一遍链表数一数能访问到多少个节点。如果个数小于输入链表的节点总数说明有节点已经不在任何可达路径上断链了。实际调试时我不建议肉眼盯代码找 bug而是直接在关键位置打印。Python 里写个临时函数遍历打印所有节点的值每一步交换后打印一次“当前链表全貌”再打印 pre.val、first.val、second.val。看到打印结果断链处一眼就暴露了。这个方法的另一个好处是能同步发现死循环如果遍历函数打印出来的节点数超过预期或者同一个节点反复出现说明链表里有环。5. 边界用例和两项调试技术空链表、单节点与循环链表5.1 三组常见的边界用例链表题的正确性很大程度靠边界用例支撑。两两交换里最常见的边界是三类第一类空链表。head 为 null。递归版在入口直接返回 null不会崩迭代版 while 条件 pre.next 为假返回 dummy.next也就是 null。两种解法都能正确工作但你必须先想到这个用例。很多人在写代码时根本没考虑空链表提交后判题系统直接给你测出来才会补上判断。第二类单节点链表。链表只有一个节点没有第二个节点可以配对原样返回。递归版必须在出口同时判断not head or not head.next如果你只写了not head那处理单节点链表时会继续执行 first.next second.next而 second 已经是 None直接空指针。第三类奇数长度链表。1-2-3 交换后是 2-1-3最后那个 3 不动直接挂在 1 后面。迭代版 while pre.next and pre.next.next 会在 pre 指向 1 时停下来因为 1 后面的 3 只有一个节点没有配对对象递归版在节点 3 的 base case 返回 3上层把它接到 1 后面逻辑上天然兼容。这三类用例我建议每次写完都手动测一遍。你不用把整个链表都跑一遍只要在草稿纸上画出来观察一下“当前对”和“后续链表”的连接是否成立就能发现大部分错误。5.2 死循环和两种通用调试手段还有一个很隐蔽的问题死循环。最典型的死循环写法是交换后忘记移动 pre。比如循环体里只改了三条指针没写pre firstpre 永远停在 dummy循环会反复交换第一对节点链表永远在原地打转。这种 bug 和断链不同它不会报空指针而是表现为程序超时。遇到疑似死循环第一步先怀疑“工作指针有没有移动”。检查思路很简单变量是不是在循环体内被更新更新的目标是不是下一对节点的前驱如果都没有那就是定位不到下一个处理点。第二步是用快慢指针判圈。如果怀疑自己的操作让链表形成了环用两个指针同时从头部出发一个每次走两步一个每次走一步一旦它们相遇说明链表里存在环。这是 Floyd 判圈算法的基本思想也是调试链表环问题的通用工具。用它来区分“遍历超时”到底是因为死循环还是因为链表环非常快。打印法也值得多说一句。在交换前后打印出链表当前状态有时候比纠结半天更有效率。我自己的习惯是写一个小的 debug 函数把链表从头到尾打印一遍然后在循环体的开头和结尾各调用一次。看到节点序列从“正常顺序”变成“互相指来指去”错误自然就清楚了。6. K 个一组翻转两两交换只是它的一级台阶6.1 从两两交换到K个一组LeetCode 25题“K 个一组翻转链表”可以看作 24题的加强版。K2 时它要求两两交换K3 时要求三个节点一组翻转。处理思路依然是同一个框架配备一个 pre 作为前驱每次都从 pre 后面提取出 K 个节点把这 K 个节点内部做反转或重排再接回 pre然后移动 pre 到这一段末尾。两两交换是吃透 25 题的地基。因为 K 个一组翻转内部要做的那次逆序本质就是“用三个指针保存后继、改 next、再移动”和 24 题完全同源。你先能手写 24 题迭代版再啃 25 题就会顺畅很多。具体到 25 题核心代码框架是这样的先数一数从 pre.next 开始还有几个节点如果不够 K 个直接结束如果够就把这一段反转然后把 pre.next 指向反转后的头之前这一段原来的第一个节点变成尾接上后面的链表最后移动 pre。你会在里面看到 dummy 节点、临时指针、保存后继这些非常熟悉的面孔。所以说24 题不是一道孤立的题目它是一系列链表操作题的入口。6.2 一组同源链表题刷完 24 题之后我建议趁热打铁做这些题它们共享同一套指针操作逻辑反转链表206最经典的指针逆流题核心是保存 next、改 next、移动 cur。反转链表 II92切断链表并反转局部区间和 K 个一组翻转的切割思路很像。删除排序链表中的重复元素 II82需要保留前驱处理完一组节点后正确跳过重复段。旋转链表61找倒数第 K 个节点然后把链表闭环再拆开。这几道题做下来你会慢慢形成一种肌肉记忆凡是单链表的结构变化先问自己三个问题——哪几个节点的 next 会被改动被改动前它们原本指向谁改动之后有没有其他方式还能找到原来的后继这三个问题想明白绝大多数链表题都能写对。6.3 一些个人的面试与工程体会我在带新人或者做技术分享时经常拿 24 题作为链表基本功的试金石。判断一个人有没有真正掌握不是看他能不能背出题解而是问两个小问题为什么迭代版要有 dummy为什么四步操作里必须先让 first 指向 second.next能清楚回答这两点说明下一次遇到反转链表、K 个一组翻转大概率也能举一反三。实际工程里链表的指针交换也不只是面试题。内存分配器的空闲块链表、内核里某些任务队列、缓存淘汰策略里的 LRU 双向链表都可能需要安全地摘下或替换节点。你在这里练的“不丢节点”的手感可以在生产环境省下不少排查脏数据的时间。真实工程代码一般不会裸写指针而是用 intrusive list 这类封装但理解底层逻辑始终是必要的基础。建议你按今天讲的三步走——保存现场、先连后断、移动指针——把这套动作练成固定节奏。先在纸上画三遍交换过程再打开编辑器写代码顺手把空链表、单节点、奇数长度这些边界用例都测一遍。等你把 24 题写得像条件反射一样顺再来做 25 题会突然发现原来考研所谓的“难题”只是把基础题换了个更大的 K。