力扣24题详解：两两交换链表节点的迭代与递归解法

1. 题目到底在考什么：先看懂这道题的核心意图

力扣第24题“两两交换链表中的节点”是一道非常经典的链表操作题，难度标的是Medium，但说实话，它的代码量不大，真正难的是指针操作的顺序和边界条件的处理。题目要求很明确：给定一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。而且题目特别强调，不能只是修改节点内部的值，必须真的把节点交换掉。

这道题为什么值得反复刷？因为它几乎是链表题里“指针操作基本功”的试金石。你如果能把这道题的迭代法和递归法都写明白、讲清楚，那链表相关的很多题（反转链表、K个一组反转、重排链表）基本就通了一大半。

我从自己刷题的经历来看，这道题最典型的“坑”有这几个：交换完之后指针绕不回来、head变化之后返回值搞错、链表长度是奇数时尾巴怎么处理。每个坑都对应一个核心知识点，下面我一个个拆开讲。

提示：如果你完全没接触过链表，先用5分钟搞明白单链表的结构——每个节点有一个value和一个next指针，链表的头节点是入口，遍历靠next一个一个往下走。这道题基于的就是这个最基础的结构。

在进入正题之前，先看一眼题目给的链表节点定义，后面所有代码都基于这个结构：

python复制# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

接下来我们分两条路线来啃这道题：迭代法（虚拟头节点）和递归法。两种写法都要会，因为面试官非常喜欢让你“再写一种方法”。

2. 解法一：迭代法，虚拟头节点是链表题的万能钥匙

2.1 为什么一上来就要用虚拟头节点

迭代法最让人头疼的地方在于：头节点会变。题目要求把第一个节点和第二个节点交换，交换完之后，原来链表的head变成了第二个节点。如果你按常规方法直接操作原head，最后返回值就会很麻烦，要么额外用一个变量记录新head，要么单独处理头节点的特殊情况。

虚拟头节点（dummy node）就是为了解决这个问题出现的。它的思路很简单：在真正的头节点前面再挂一个新的节点，这个节点本身不存有效数据，只是让“头节点的变化”变成一个普通操作，最后返回dummy.next就行。

python复制class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        dummy = ListNode(0)   # 虚拟头节点
        dummy.next = head
        prev = dummy          # prev始终指向“已经处理完的链表的尾部”
        
        while prev.next and prev.next.next:
            node1 = prev.next
            node2 = node1.next
            
            # 核心交换逻辑
            prev.next = node2
            node1.next = node2.next
            node2.next = node1
            
            # 移动prev到下一组的前驱位置
            prev = node1
        
        return dummy.next

这段代码看起来简单，但我第一次写的时候还是绕了半天。关键就三行交换逻辑，我建议你用笔画一下指针变化，比盯着代码看有效得多。

2.2 三行交换逻辑，每一行的顺序都不能错

我们假设当前状态是：prev -> node1 -> node2 -> nextNode，目标是把node1和node2交换，变成prev -> node2 -> node1 -> nextNode。

第一步：prev.next = node2，让prev先指向node2。这一步把node2从后面“提”到了前面。

第二步：node1.next = node2.next，让node1指向node2原来的下一个节点（也就是nextNode）。这一步必须做，否则node1和node2会互相指着，形成环。

第三步：node2.next = node1，让node2指回node1，完成这两个节点的交换。

然后prev = node1，因为交换完之后，node1已经成了这一组的尾部，下一组要交换的节点是从node1.next开始的。

交换顺序为什么不能乱？ 如果你先把node2.next = node1做了，再想执行node1.next = node2.next，你会发现node2.next已经变成node1了，node1的下一个就指向了自己，链表直接断掉。这一步是新手最容易踩的坑，所以一定要记住：先保存好“后面的路”，再回指前面的节点。

2.3 循环条件和奇数长度的处理

循环条件是while prev.next and prev.next.next，这里两个判断缺一不可：

• prev.next为空，说明链表已经走到尾，没有更多节点了。
• prev.next.next为空，说明当前只剩一个节点，没人可以和它配对。

这个条件天然处理了链表节点数为奇数和偶数的情况。链表长度为偶数时，最后一组交换完，prev正好落在倒数第二个节点上，此时prev.next是最后一个节点，prev.next.next是None，循环退出。链表长度为奇数时，最后一组之后还剩一个“光棍”节点，同样满足prev.next.next为None，循环退出，最后的单节点保持原样不动。

这里再多说一句：为什么不是用while node1 and node2？ 从代码可读性上看，用prev.next判断更直观，因为prev永远代表“当前已处理部分的尾部”，这是虚拟头节点写法带来的简洁性。如果你用node1和node2做判断，就得额外维护这两个变量的更新，反而容易漏。

3. 解法二：递归写法，用子问题思维秒杀链表题

3.1 递归的核心：把大问题拆成一模一样的子问题

迭代法虽然不难，但很多人在力扣上还会遇到另一种解法：递归。递归的思路其实更接近人的直觉——你给我两个一换，换完之后剩下的部分也按同样的规则处理。

具体来说：

• 第一个节点head和第二个节点head.next交换。
• 交换完之后，head.next应该指向“从第三个节点开始，两两交换后的结果”。
• 而“从第三个节点开始，两两交换后的结果”恰好是原问题的子问题——只是链表短了一点。

这就是递归最妙的点：子问题和原问题是同一个结构，只是规模变小了。

python复制class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        # 终止条件：空链表或只剩一个节点
        if not head or not head.next:
            return head
        
        # 需要交换的两个节点
        node1 = head
        node2 = head.next
        
        # 先处理子问题：从第三个节点开始两两交换
        sub_head = self.swapPairs(node2.next)
        
        # 当前两个节点交换
        node2.next = node1
        node1.next = sub_head
        
        # node2是新的头节点
        return node2

这个写法最核心的地方在于：先递归处理子问题，再做当前层的交换。很多人写递归容易把顺序搞反，先交换当前层，再递归子问题，然后就发现指向不对了。为什么必须先递归？因为当前层交换完之后，node1.next要指向子问题处理完的头节点，而这个头节点只有在递归返回之后才拿得到。

3.2 递归终止条件为什么是“空链表或只剩一个节点”

递归一定要有终止条件，不然会无限递归直到爆栈。这个子问题每次缩减两个节点，所以终止条件自然就是：没有节点可以交换了。

• not head：空链表，返回None。
• not head.next：只剩一个节点，返回它自己。

这两个条件对应了没有节点和只有一个节点的情况。尤其要注意“只剩一个节点”这个条件，它保证了奇数长度的链表最后那个单节点不会出错。

3.3 递归和迭代怎么选

从力扣的提交记录来看，这两种解法的时空复杂度是一样的，都是O(n)时间和O(n)空间（递归的栈空间）。但在实际面试中，这两者的取舍其实非常有讲究：

• 迭代法：空间是O(1)，代码更贴近底层操作，适合考察指针操作的细节。
• 递归法：代码更简洁、逻辑更清晰，但面试官可能会追问“递归的栈空间是多少”“如果链表有100万个节点会怎样”。

我个人的刷题经验是：两种方法都要能5分钟内写出来。因为面试官很喜欢在同一次面试里让你“先写迭代，再写递归”，或者反过来。这道题就是检验链表基本功的经典题目，两个方向都能写，说明你是真的理解了，而不是背了某一种模板。

4. 实操调试记录：我在这道题上踩过的坑和排查方法

4.1 常见的几个运行错误和逻辑错误

我在刷这道题的过程中，以及帮朋友review代码时，发现几个高频的问题点，整理成了一张速查表：

其中最隐蔽的是“链表中出现环”这个问题。链表有环的直接后果是：调试时你打印输出，会看到节点重复出现，然后程序卡死。这个问题用眼睛盯代码很难发现，我建议你遇到超时先怀疑是不是成环了。

我的排查方法很简单：写一个辅助打印函数。

python复制def print_chain(head):
    vals = []
    while head:
        vals.append(str(head.val))
        head = head.next
    print(" -> ".join(vals))

每执行完一次交换，就打印一次链表当前状态，对比你预想中的每一步，很快能定位是哪一步出了问题。

4.2 一个真实翻车场景：忘记保存node2.next

我第一次自己实现这道题的时候，写出过这样一段错误代码：

python复制# 错误示例
prev.next = node2
node2.next = node1
node1.next = node2.next  # 这里的node2.next已经是node1了

第三次赋值的时候，node2.next已经被改成了node1，所以node1.next = node2.next实际上等于node1.next = node1，链表直接断掉，后面的节点全部丢失。

这个错误特别典型，因为它读起来“很顺”——每一行都像是把指针指到了正确的位置，但实际上前两步已经把后续的路堵死了。记住一个口诀：先接后面的路，再回指前面的节点。

也就是说，node1.next = node2.next必须放在node2.next = node1之前。这个顺序如果记不住，就在纸上画一下链表图，画完基本就不会错了。

4.3 Python链表调试的通用心得

用Python刷链表题有一个天然的优势：Python的变量本质上都是对象的引用，所以节点的“指针”操作实际上是在修改对象的引用关系。这也带来一个坑：如果你不小心把两个变量指向了同一个节点对象，那么修改其中一个，另一个也会跟着变。

举个例子：

python复制node_a = ListNode(1)
node_b = node_a
node_b.next = ListNode(2)
# 此时node_a.next也是这个新节点，因为node_a和node_b是同一个对象

在调试链表题时，这种“引用共享”很容易让你产生误解。我的建议是：需要复制节点对象时用copy模块或者手动创建新节点，不要简单赋值。不过在这道题里，我们只需要操作引用关系，不需要复制节点，所以这个坑不算大。

5. 面试追问与题目变体：一道题怎么吃透一片

5.1 最常见的追问：每K个一组反转

这道题的直系升级版是力扣第25题“K个一组翻转链表”。24题其实可以看作是K=2的特例，而25题要求的是“每K个节点一组翻转”。

如果你能把24题的迭代法理解透，25题其实就是在24题的基础上加了一个“判断下一组是否够K个”的前置步骤。面试时如果你能把从24到25的思路递进讲清楚，说明你对链表的理解已经超过了背答案的水平。

具体延展思路：在24题中，prev指向待交换组的前驱，node1和node2是待交换的两个节点。在25题中，你同样需要prev来定位组的前驱，然后对K个节点进行反转操作，反转到结束条件变成“组内剩余节点不足K个就停止”。

5.2 面试官还会怎么变着花样考

除了25题，还有几个常见的变体思路：

变体一：交换链表中的前N个节点，并且N是偶数。 这个就是24题的子集，处理方式一模一样，N是奇数的话就只处理前N-1个。

变体二：不交换节点，只交换节点对应的值。 这个做法写起来很简单——遍历链表，把相邻两个节点的值互换。但题目不允许这么做，因为面试官真正想考察的是“真的操作指针”。不过如果你先跟面试官确认“有没有要求不能改值”，可以展示你对题目约束的敏感度。

变体三：隔两个节点交换一对。 比如1-2-3-4-5-6，交换之后变成3-4-1-2-5-6（假设每两个一组、间隔一组）。这个其实就是24题的进阶版，需要多个指针配合，核心思想还是虚拟头节点加分组定位，只是移动逻辑更复杂。

把这些变体想清楚之后，你会发现24题是一座枢纽：前面接着最基础的链表遍历，后面接着25题的大规模分组翻转。把它彻底搞懂，性价比非常高。

5.3 面试时的高效表达框架

如果你在面试考场上遇到这道题，我建议你按这个顺序表达：

先说明两种思路——迭代法和递归法，给面试官选择空间。然后选一种你最有把握的先写，写之前用一句话说清楚核心逻辑：“我会用一个虚拟头节点统一头节点的变化，然后用prev维护已处理部分的尾部，每次交换两个节点。”边说边写，写完再主动过一遍边界条件：“空链表、一个节点、奇数长度、偶数长度。”最后如果面试官问复杂度，直接回答“时间O(n)，迭代空间O(1)，递归空间O(n)”。

注意：面试中更重要的是把思路讲清楚，不要一上来闷头写代码。哪怕代码小有瑕疵，但思路和边界条件考虑到位，面试官通常会给不错的评价。

6. 刷题之外的思考：这道题背后的两个通用能力

6.1 抽象能力：从“具体交换两个节点”到“任意分组操作”

24题虽然只是交换两个节点，但它背后的抽象能力是通用的：如何在一个链表中，通过有限几个指针，完成局部结构的调整，同时不破坏整体结构。

这种能力是链表面试题考察的核心。链表题不像数组题那样通过下标直接访问，你只能靠指针一点点往右走。所以链表题的关键就是“指针规划”——想清楚每个指针的作用、移动时机、边界条件。24题帮你练的就是这个。

很多人刷题的时候喜欢背模板，但我更建议你理解模板的“为什么”。比如虚拟头节点，它不止能用在24题和25题，在“删除链表的倒数第N个节点”“删除排序链表中的重复元素”“反转链表II”里都能用。理解了它的本质——避免头节点变化带来的特判——你就能在更多题目里主动想到用它。

6.2 调试能力：把“出了问题”变成“找到原因”

写链表题，一次写对是少数情况，更多时候是要和bug作斗争。24题涉及多个指针的连续赋值，一旦出错，靠眼睛盯代码很费劲。这时候最好的工具就是把链表打印出来。

我强烈建议刷链表题时提前写好一个print_chain函数，放在你的代码模板里。 调试链表比调试数组麻烦，因为数组你可以直接print整个列表，链表则需要自己遍历。每次交换后打印一次当前状态，对比自己脑内推演的结果，很快就能锁定问题出在第几步。

除了打印，还有一个判断链表有没有成环的小技巧：用一个快指针和一个慢指针，慢指针每次走一步，快指针每次走两步，如果快慢指针相遇，说明链表里有环。遇到“运行超时”的时候，可以用这个技巧快速判断。

6.3 对Python刷题者的一点额外建议

Python刷题有一个好处：代码通常比较简短，核心逻辑一眼就能看完。但也有一个需要注意的地方：Python的递归深度默认在1000左右，如果你用递归法处理特别长的链表，理论上可能触发递归深度限制。所以力扣上链表题如果用了递归，测试数据一般不会太长，但面试时最好主动提一句“递归写法有栈深度的限制，如果链表特别长，迭代法更稳妥”。

这个问题虽然在这道题里不明显，但我见过很多人在写“反转链表（递归版）”时被面试官追问过栈深度。提前有这个意识，能显得你考虑问题更全面。

7. 同类题对照：把24题放进整个链表题地图里

链表题在力扣上数量不少，但其实是能归类的。我按“指针操作”的复杂度，把常见的链表题粗略分成了几个梯度。24题位于“基础指针操作”向“复杂分组操作”过渡的位置。

从这个表里能看到，24题处在“从简单到复杂”的中间地带。先刷206题，再刷24题，接着上25题，是一个很顺的进阶路径。很多刷题攻略推荐“按题号顺序刷”，但链表这块真的不建议硬按题号来，按难易梯度递进会更高效。

再补充一个做题时的细节：力扣的Python环境默认给的是ListNode这个类，但你本地的IDE里如果自己写链表测试用例，可能需要自己定义这个类。我建议你把它放到自己的刷题模板里，这样调试的时候可以直接在本地运行。

8. 从操作层面再看一遍完整代码

为了让你能直接照着写，这里把两种解法的完整代码和配套测试代码再整理一遍。

8.1 最终版迭代法

python复制class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        prev = dummy
        
        while prev.next and prev.next.next:
            node1 = prev.next
            node2 = node1.next
            
            prev.next = node2
            node1.next = node2.next
            node2.next = node1
            
            prev = node1
        
        return dummy.next

8.2 最终版递归法

python复制class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return head
        
        node1 = head
        node2 = head.next
        
        sub_head = self.swapPairs(node2.next)
        
        node2.next = node1
        node1.next = sub_head
        
        return node2

8.3 本地调试用的辅助代码

python复制# 构建链表：传入一个列表，返回头节点
def build_linked_list(nums):
    dummy = ListNode(0)
    curr = dummy
    for num in nums:
        curr.next = ListNode(num)
        curr = curr.next
    return dummy.next

# 打印链表
def print_chain(head):
    vals = []
    while head:
        vals.append(str(head.val))
        head = head.next
    print(" -> ".join(vals))

# 测试
head = build_linked_list([1, 2, 3, 4])
result = Solution().swapPairs(head)
print_chain(result)  # 期望输出：2 -> 1 -> 4 -> 3

这几段代码组合起来，就是你本地调试的完整环境。力扣上其实也有自带的debug功能，但我觉得在本地IDE里跑一遍，对理解指针操作帮助更大——因为你可以在关键行打断点，一行一行看变量变化。

9. 总结一下我的个人经验

刷这道题给我最大的收获不是“我会做这道题了”，而是我彻底搞清楚了链表指针操作的核心原则：先接新连接，再断旧连接，全程保证链表不断裂。这个原则在内化之后，后面刷257题“二叉树的所有路径”、114题“二叉树展开为链表”的时候，思路都顺畅了很多。

如果你正在准备面试，我给三条具体的建议：

第一，亲手画出交换过程中的指针变化图。不需要画得多漂亮，只要能让自己看懂每一步的指向变化就行。看完图之后，再对照代码理解，效果比反复看别人的代码好十倍。

第二，把迭代法和递归法都练到5分钟内写出来。这两种写法考察的是不同的理解角度。迭代法是在“操作”层面理解，递归法是在“逻辑”层面理解，两个都会了，才是真的会。

第三，做完之后立刻刷一道25题。趁热打铁，把K=2的特例推广到K个一组的一般情况，你会发现自己对链表操作的信心提升了一大截。

这道题我在各个公开课和题解里都见过无数遍，但真正让我觉得自己“会了”的时候，是我能不看任何资料、两分钟画完指针图、然后清清爽爽把两种写法都写出来的那一刻。希望你也能尽快找到这种感觉。