合并两个有序列表：双指针归并的数组与链表实现解析

合并两个有序列表，这个题目看着简单，但面试里出场率极高，工作里也经常能碰到类似的需求——比如把两个有序的配置文件合并成一个，把两个有序的日志流归并成一个，本质都是同一套归并思维。数组有数组的解法，链表有链表的套路，两者核心逻辑相通，但实现细节差异很大。这篇文章就把两种结构分别拆开讲清楚，从思路推导到代码落地，再到常见的坑和变种题，一次性聊透。

1. 内容整体设计与思路拆解

1.1 核心需求解析：到底在考什么

先明确题目要做什么：给你两个已经有序的列表，合并成一个新的有序列表。注意“已经有序”这个前提条件，它决定了这道题的最优解是线性复杂度，也就是 O(m+n)，m 和 n 分别是两个列表的长度。如果输入是无序的，那直接拼起来再排序，复杂度是 O((m+n)log(m+n))，那是另一道题。

这道题本质上考的是双指针归并。不需要额外复杂的算法，就是两个指针分别指向两个列表的头部，谁小谁先进结果集，然后移动对应指针，直到某个列表走完，剩下那个列表直接整体接上。这个思路朴素得像是把两堆按大小排好的积木聚在一起，每次只取顶部最小的那一块。

但真正拉开差距的地方在于：数组和链表在“取最小”“接上去”这两个动作上的代价完全不同。数组支持 O(1) 随机访问，但插入删除是 O(n)；链表插入删除是 O(1)，但没办法下标访问，只能一个个遍历。所以同样的归并逻辑，落到两种数据结构上，写法和边界处理都不一样。很多人数组版本写得顺手，链表版本一写就乱，原因就在这里——没有意识到两种结构在“连接”这个操作上本质不同。

1.2 为什么选择双指针归并而不是其他方案

有几种做法摆在面前：暴力拼接再排序、把其中一个插到另一个里、用额外数组归并、双指针原地归并。

暴力拼接再排序，代码最短，但浪费了输入有序这个条件，而且如果原题要求原地合并（比如 LeetCode 88 题，nums1 后面留了空间让你直接往里塞），这种方法根本没法用。把短的插入长的，思想是没错，但数组插入是 O(n) 操作，总复杂度会退化到 O(m*n)；链表上这么做倒还行，但写起来啰嗦，容易在指针操作里迷路。用额外数组归并，思路清晰，但不是所有场景都允许你开新空间——数组版本的面试官往往就盯着“能不能原地”这一点。

双指针归并是这几种方案里唯一能做到时间 O(m+n)、空间 O(1)（链表版本）或 O(m+n) 辅助数组（数组版本原地时空间为 O(1)）的写法。它最贴合“有序”这个输入条件，把两个序列的头部看作两个候选最小值，每次决策只比较一次，信息利用率最高。

1.3 数组和链表实现差异的根源

先说数组。数组的痛点在于元素连续存放，你在中间插入一个数，后面的都得往后挪。但题目有一个常见变体：两个有序数组，nums1 长度为 m+n，前 m 个是有效数据，后 n 个是空闲位，要求把 nums2 合并进 nums1，不使用额外数组。这种场景下，如果从前往后归并，每次移动元素都会产生覆盖问题，你得额外开空间存临时结果。但如果从后往前归并，把两个数组的末尾指针和结果位置的末尾指针三根指针同时移动，谁大谁放到结果末尾，这样永远不会覆盖还没处理的元素。

再说链表。链表不存在连续内存的问题，把两个节点串起来只需要改指针。但是链表的难点在于：你不能像数组那样从后往前倒着看。单向链表只能往一个方向走，所以只能老老实实从前往后，用一个 prev 指针串联结果链。这也是为什么链表题特别强调 dummy 节点——它能让你在处理头节点的时候不需要写 if 判断，让代码逻辑统一。

一句话概括：数组版本难在“覆盖”，解决思路是倒着走；链表版本难在“指针管理”，解决思路是 dummy + prev。理解了这一层，代码只是顺手的事。

2. 数组版本实操：合并两个有序数组的完整拆解

2.1 题目背景与输入条件说明

数组版本的代表题是 LeetCode 88. Merge Sorted Array。题目输入是两个有序数组，假设第一个数组 nums1 长度是 m+n，其中前 m 个位置是有效数据，后面 n 个位置是留给合并结果的空间，初始值是 0 或者任意垃圾值；第二个数组 nums2 长度是 n。要求把 nums2 合并进 nums1，使 nums1 整体有序，结果仍存在 nums1 中，不允许额外开数组。

这里最反直觉的一点是：为什么 nums1 要预留空间？直接新建一个数组返回不行吗？从工程角度讲，有时候你需要在一个已经分配好的内存区域里完成数据更新，重新分配内存代价高，或者外部接口只认这个数组的地址。从面试角度讲，这是一个空间约束条件，考察的就是你在限制条件下调整算法的能力。所以题目描述里的每一个条件都值得琢磨，很多解法写崩就是因为没意识到 nums1 后半段是空的。

2.2 从后往前归并的核心逻辑

归并过程可以这样想：既然整体要分成三个逻辑部分——nums1 有效区的末尾、nums2 的末尾、nums1 结果区的末尾——那我们就维护三个指针：

• p1 = m - 1，指向 nums1 有效数据的最后一个元素
• p2 = n - 1，指向 nums2 的最后一个元素
• p = m + n - 1，指向 nums1 数组最后一个位置，也就是结果区末尾

每一轮比较 nums1[p1] 和 nums2[p2]，谁更大就放到 nums[p] 上，然后相应指针前移。比如 nums1[p1] 更大，就 nums1[p] = nums1[p1]，p1 减一，p 减一；否则就 nums1[p] = nums2[p2]，p2 减一，p 减一。循环结束条件是 p1 < 0 或者 p2 < 0。

循环结束后，如果 p2 还 >= 0，说明 nums2 还剩一部分没搬完，直接循环把剩余元素复制到 nums1 前面；如果 p1 还 >= 0，那不用管，因为剩下的元素本来就在 nums1 里，位置已经是对的。

这里有个细节容易被忽略：从后往前填，结果区末尾和 nums1 有效区末尾不会交叉覆盖。你可以这样理解：p 永远大于等于 p1，因为 p 的初始值是 m+n-1，而 p1 初始值只有 m-1，p 每次至少前移一个位置，p1 只有在 nums1[p1] 被选中时才会前移。所以 nums1[p1] 的值在放到 nums1[p] 之前，它原来的位置 p1 一定小于 p，不会互相踩踏。这就是“倒着走”安全的数学本质。

2.3 代码实现与关键参数说明

用 Python 写一版最直观的实现：

python复制def merge(nums1, m, nums2, n):
    p1 = m - 1
    p2 = n - 1
    p = m + n - 1

    while p1 >= 0 and p2 >= 0:
        if nums1[p1] > nums2[p2]:
            nums1[p] = nums1[p1]
            p1 -= 1
        else:
            nums1[p] = nums2[p2]
            p2 -= 1
        p -= 1

    # 如果 nums2 还有剩余，直接搬过去
    while p2 >= 0:
        nums1[p] = nums2[p2]
        p2 -= 1
        p -= 1

几个关键点：

• 比较用的是 >，不是 >=。用 >= 也能工作，用 > 会让两个数组相等元素的相对顺序保持 nums2 在前。不同题目对稳定性没有要求时无所谓，但养成用 > 的习惯，遇到要求稳定归并的场景不会踩坑。
• 最后只需要处理 p2 >= 0 的情况，不需要处理 p1 >= 0 的情况。因为 p1 剩下的元素已经在 nums1 里，并且它们应该待的位置就是当前位置和更前面的位置，是天然有序且正确的。
• 这个实现的空间复杂度是 O(1)，时间复杂度是 O(m+n)，一次遍历解决。

对比从前往后的写法：

python复制def merge_forward(nums1, m, nums2, n):
    # 这种写法需要额外数组，否则会覆盖未处理的元素
    result = nums1[:m]
    i, j, k = 0, 0, 0
    while i < m and j < n:
        if result[i] <= nums2[j]:
            nums1[k] = result[i]
            i += 1
        else:
            nums1[k] = nums2[j]
            j += 1
        k += 1
    while i < m:
        nums1[k] = result[i]
        i += 1
        k += 1
    while j < n:
        nums1[k] = nums2[j]
        j += 1
        k += 1

这个写法虽然逻辑上更容易理解，但它需要先复制一份 nums1 的有效数据，空间复杂度 O(m)，而且多了一次复制开销。实际工程里如果数组非常大（比如内存快不够用），多出来这份拷贝可能就是压垮系统的最后一根稻草。所以面试时优先写从后往前的版本，不仅代码短，还能展示你对空间复杂度的控制意识。

2.4 数组版常见边界情况处理

边界 cases 是这种题的送分点也是送命题。我通常固定先跑下面这几个 case：

• nums1 = [0], m = 0, nums2 = [1], n = 1：m 为 0，p1 初始就是 -1，第一个 while 直接跳过，进入第二个 while 把 nums2 搬到 nums1。这个 case 验证的是“第一个数组为空”的情况。
• nums1 = [1], m = 1, nums2 = [], n = 0：n 为 0，上面第一个 while 也跳过，第二个 while 条件不进入，直接结束。验证“第二个数组为空”。
• nums1 = [1, 2, 3, 0, 0, 0], m = 3, nums2 = [4, 5, 6], n = 3：nums2 的所有元素都比 nums1 大，p2 会一路搬到头。验证“一个数组的所有元素都比另一个大”。
• nums1 = [4, 5, 6, 0, 0, 0], m = 3, nums2 = [1, 2, 3], n = 3：nums1 的所有元素都比 nums2 大，p1 一路搬到头，最后 p2 不为负，把 nums2 全部铺到前面。验证“另一个方向”。

这四组跑完，基本覆盖了所有指针转移的路径，代码逻辑的每个分支都被 hit 到。我自己判断一个归并实现是否可靠，就看它在这四个 case 下能不能一次通过。

3. 链表版本实操：合并两个有序链表的完整拆解

3.1 链表节点的定义与题目描述

链表版本的代表题是 LeetCode 21. Merge Two Sorted Lists。输入是两个有序单链表的头节点，要求返回合并后新链表的头节点。链表节点的标准定义是：

python复制class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

这里和数组最大的区别是：输入的两个链表是“既有的内存对象”，你不能复制它们的节点，只能通过修改 next 指针来重新组织它们。这意味着合并结果实际上是把两个链表的节点重新串了一遍，没有 new 出任何新节点。空间复杂度是 O(1)，额外开的内存只有几个指针变量。

很多人写链表题最怕的就是指针一多就绕晕。这里给你一个口诀：每个指针只干一件事。prev 管结果链的尾部，l1 管第一个链表当前节点，l2 管第二个链表当前节点。每轮循环只做三件事——比大小、挂节点、推指针。

3.2 迭代法：dummy 节点与尾插法的配合

先上代码：

python复制def merge_two_lists(l1, l2):
    dummy = ListNode(0)
    prev = dummy

    while l1 and l2:
        if l1.val <= l2.val:
            prev.next = l1
            l1 = l1.next
        else:
            prev.next = l2
            l2 = l2.next
        prev = prev.next

    # 把剩余链表直接接上
    prev.next = l1 if l1 else l2

    return dummy.next

这个代码只有十几行，但每一行都有讲究。

dummy 节点的作用前面提过一嘴，这里展开说。假设没有 dummy，你在处理第一个节点时需要特殊判断——如果 l1.val < l2.val，结果头节点是 l1；否则是 l2。这会导致代码开头多出一大段 if-else，而且后面的循环逻辑没法统一处理“当前结果是空还是非空”这个问题。有了 dummy，头节点变成了 dummy.next，你只需要在循环里不断往 prev.next 挂节点，最后返回 dummy.next 就行。所有节点一视同仁，没有头节点特判。

尾插法的逻辑是：prev 永远指向结果链表的最后一个节点，每次从 l1 或 l2 里摘下一个更小的节点，挂到 prev.next 上，然后 prev 前移。这里有个细节：当你把 l1（或 l2）的当前节点挂到结果链上时，l1 本身也要前移到 l1.next。这个动作有两个效果：一是待比较的候选节点更新，二是原链表不会因为指针操作而断掉后续节点。

循环结束后，l1 和 l2 中至少有一个是 None，你只需要把非空的那个整体接上。为什么可以直接接上？因为剩余链表本身有序，而它的所有节点都大于等于结果链上已选出的最后一个节点，直接接上不破坏全局有序性。这个“剩余整体接上”的操作是链表版本最爽的一步，数组版本却做不到——数组只能挨个复制，链表可以 O(1) 拼接。

复杂度方面，时间 O(m+n)，空间 O(1)。注意这里空间不算递归栈，因为迭代法没有递归调用。

3.3 递归法：代码最短但理解门槛高

递归版本也很经典，代码更加短：

python复制def merge_two_lists_recursive(l1, l2):
    if not l1:
        return l2
    if not l2:
        return l1
    if l1.val <= l2.val:
        l1.next = merge_two_lists_recursive(l1.next, l2)
        return l1
    else:
        l2.next = merge_two_lists_recursive(l1, l2.next)
        return l2

这个递归的思考方式是：不要试图跟踪每一层调用发生了什么，只需要相信函数定义本身——它返回的是合并后链表的头节点。当前这一层只负责一件事：选出 l1 和 l2 中较小的那个作为结果头节点，然后递归地合并“除去这个节点外的剩余链表”和另一个链表。

比如 l1.val <= l2.val，那么结果头节点就是 l1，剩下的工作就是合并 l1.next 和 l2，用递归函数去处理，返回的头节点挂到 l1.next 上。

递归版本代码确实短，但有两个隐患：一是当链表长度较大时，递归深度等于合并后链表长度，而 Python 默认递归深度限制约 1000，可能导致 RecursionError；二是每层递归都有函数调用开销，性能上不如迭代。所以面试时候先用迭代法写出稳妥版本，如果面试官问“还能怎么写”，再补充递归版作为思路展示。

3.4 链表版常见边界情况处理

链表版本的边界情况比数组版本容易处理，但还是有一些容易翻车的点：

• 两个链表都为空：返回 None。迭代版本 while 循环不进入，prev.next = l1 if l1 else l2，l1 和 l2 都是 None，dummy.next 也是 None，正确。
• 其中一个链表为空：直接返回非空那个。这个特性意味着你不需要像数组那样写“复制剩余元素”的循环，一个三元表达式搞定。
• 两个链表等长且元素交替大小：比如 1->3->5 和 2->4->6，这时循环会一直交替摘节点，prev 不断移动，最考验你的指针更新是否忘记。
• 两个链表中有大量相等元素：用 <= 或 < 决定优先级。LeetCode 21 对相等元素的处理没有要求，但如果面试官追问“相等的节点怎么处理”，你要能说出：如果要求稳定归并，应该优先取第一个链表的节点，也就是用 <=。
• 循环单链表的坑：题目给的是无环单链表，但实际工作中如果链表有环，这个代码会死循环。面试时如果时间充裕，可以提一句“假设输入无环，如果需要检测环形链表得先跑快慢指针”。

4. 常见问题与排查技巧实录

4.1 数组版本最容易踩的坑：覆盖未处理元素

数组版本大家最容易出问题的地方是：从前往后合并时，把还没比较的元素覆盖掉了。举个例子：nums1 = [3, 4, 5, 0, 0, 0]，nums2 = [1, 2, 6]。如果从前往后，先把 1 放到 nums1[0]，那原来的 3 就被覆盖了，后面的比较全错了。

排查思路：如果你发现输出数组开头是对的、后面是乱的，往往是覆盖问题；如果你发现输出数组前面有不该存在的 0，说明你漏掉了 nums2 搬完剩余元素的循环；如果你发现结果数组末尾有残留的 0，说明 p1 或 p2 的边界条件写错了，比如某个 while 该 >= 0 写成了 > 0。

这种问题最简单的排查工具就是 print。在每一轮循环里把 p1、p2、p 和当前数组状态打印出来，一眼就能看出指针走到哪里出了问题。

4.2 链表版本最容易踩的坑：断链与丢失节点

链表版本最常见的 bug 是丢失节点或者链表成环。丢失节点通常发生在这个场景：你把 l1 的当前节点挂到 prev.next 之后，忘了先保存 l1.next 再移动 l1。如果先执行 l1 = l1.next 再 prev.next = l1，那结果链表里挂的节点和原链表后续节点的关系就乱了。好在上面推荐的代码先挂节点再移动指针，恰好避开了这个坑。

另一个常见的错误是在循环结束后的拼接阶段。有些人会写：

python复制while l1:
    prev.next = l1
    prev = prev.next
    l1 = l1.next
while l2:
    prev.next = l2
    prev = prev.next
    l2 = l2.next

这种写法功能上没问题，但完全多余。可以直接用 prev.next = l1 if l1 else l2 一步搞定。记住：剩余链表天然有序，不需要重新逐个遍历。

还有一个隐蔽的问题：dummy 节点必须初始化，比如 dummy = ListNode(0)。如果你偷懒写成 dummy = None，那 prev.next 这一步直接 AttributeError。这个错误新手经常犯，因为数组版本里没有这种“占位”概念。

4.3 常见问题速查表

4.4 从刷题到实战：归并思路在工程里的延伸

这道题刷完，别急着划走。归并思维在工程里特别常见，我举几个真实例子。

第一个是外部排序。当内存装不下一个超大文件时，你先把它切成多个小文件，分别排序后落盘，然后同时对多个文件做归并，每次从每个文件头部取出最小的记录写入输出文件。这其实就是这道题的 m 路扩展版本——把“两个链表”换成“多个文件句柄”，核心逻辑还是每轮找最小。

第二个是日志归并。假设你有两个服务的日志文件，各自按时间戳排序，现在需要合并成一个全局时间序的日志流，用于排查跨服务调用链路。这就是两个有序数组的归并，只不过比较的字段是时间戳，输出目标不是数组而是标准输出。

第三个是 Git 分支合并不太一样，git merge 更多依赖三方合并，和归并排序不是一回事，但分支里的 commit 列表按时间序排列时，合并两个分支的 commit 历史也会用到类似的“双指针拉起”的思路。

所以这道题的价值不只是面试，它训练的是“两个有序序列如何高效交汇”这个通用问题的解法，很多系统里都能找到它的影子。

5. 变种题与进阶场景分析

5.1 多个有序列表的合并

两个列表会了，那 k 个呢？LeetCode 23. Merge k Sorted Lists 就是这道题的进阶版。最简单的做法是两两合并，第一轮把所有链表两两配对合并，第二轮继续两两配对，直到只剩一个链表。这样的时间复杂度是 O(n log k)，其中 n 是每个链表的平均长度，k 是链表个数。

更常见的做法是优先队列。把每个链表的头节点放进一个小顶堆，每次弹出堆顶元素，然后把这个节点所在链表的下一个节点补进堆里。复杂度同样是 O(n log k)，但实现上要维护一个“这个节点来自哪个链表”的信息，因为 Python 的 heapq 没法直接比较 ListNode 对象，你得包装成元组 (val, index, node)。

如果面试官问 k 路归并，优先队列方案是更符合工程直觉的答案。实际场景里，k 往往不大（比如 4 个日志文件），两两合并反而更简单直观，不需要引入堆的数据结构。

5.2 不新增数组节点的原地合并变体

有一种变体题：给定两个有序链表的头节点，要求把第二个链表“插入”到第一个链表中，还是用第一个链表的头节点作为结果头节点，不创建 dummy 节点。这种题其实考验的是对链表头节点特殊处理的熟练度。一般做法是先比较两个头节点，把较小的那个设成结果头节点，然后用双指针归并剩余部分。核心还是同样的归并逻辑，只不过多了一个“头节点特判”，更容易写错。

如果你能熟练使用 dummy 节点，我建议还是先用 dummy 写一版，然后面试官如果问“能不能不 new 节点”，你再把 dummy 去掉改成头节点特判。先写对，再优化，这是面试的基本策略。

5.3 转化为其他数据结构的归并问题

这个思路还能平移。比如合并两个有序的字符串数组，归并逻辑一模一样，只是比较函数换成字符串的普通比较。再比如合并两个有序的区间列表，LeetCode 986 就是这类题，归并时还要同时判断区间是否重叠，逻辑会比单纯比较元素复杂一步。

我见过不少人把这道题背得滚瓜烂熟，但换个包装就认不出来。其实识别这类题的关键词是：两个有序序列、合并、不允许额外空间或需要处理重叠。碰到这种描述，先想双指针归并，再根据具体比较语义微调。

6. 现场调试技巧与测试用例设计

6.1 用边界用例驱动代码修正

我给这套题总结了一套固定测试流程，先跑边界再跑普通 case，效率最高。对于数组版，我固定跑以下用例：

python复制# 边界 1: nums1 为空
assert merge([0], 0, [1], 1) == [1]

# 边界 2: nums2 为空
assert merge([1], 1, [], 0) == [1]

# 边界 3: 普通交错
assert merge([1, 2, 3, 0, 0, 0], 3, [2, 5, 6], 3) == [1, 2, 2, 3, 5, 6]

# 边界 4: nums2 全部偏大
assert merge([1, 2, 3, 0, 0, 0], 3, [4, 5, 6], 3) == [1, 2, 3, 4, 5, 6]

# 边界 5: nums2 全部偏小
assert merge([4, 5, 6, 0, 0, 0], 3, [1, 2, 3], 3) == [1, 2, 3, 4, 5, 6]

对于链表版，我会写一个链表转数组的辅助函数，然后同样跑这些边界：

python复制def linked_list_to_array(head):
    result = []
    while head:
        result.append(head.val)
        head = head.next
    return result

def array_to_linked_list(arr):
    dummy = ListNode(0)
    prev = dummy
    for val in arr:
        prev.next = ListNode(val)
        prev = prev.next
    return dummy.next

# 两个链表都为空
assert linked_list_to_array(merge_two_lists(None, None)) == []

# 一个链表为空
assert linked_list_to_array(merge_two_lists(None, array_to_linked_list([1, 2]))) == [1, 2]

# 交错相等
assert linked_list_to_array(
    merge_two_lists(array_to_linked_list([1, 2, 4]), array_to_linked_list([1, 3, 4]))
) == [1, 1, 2, 3, 4, 4]

如果你用 Python，可以直接在代码文件底部放 assertions，本质上就是一个轻量级测试套件，跑一遍全绿基本可以放心提交。

6.2 调试时打印指针状态的经验

链表题排查问题时，我习惯在每个关键步骤后打印一张“指针速览表”，用表格呈现比 print 乱糊一顿更清晰。

python复制def debug_print(l1, l2, prev):
    values_l1 = []
    while l1:
        values_l1.append(l1.val)
        l1 = l1.next
    values_l2 = []
    while l2:
        values_l2.append(l2.val)
        l2 = l2.next
    values_prev = []
    while prev:
        values_prev.append(prev.val)
        prev = prev.next
    # 打印三个列表的状态

不过要提醒一句：debug 打印是临时手段，调完就删。把打印代码留在最终版本里，不仅影响性能，还容易让代码变得难以阅读。

6.3 面试现场的时间与代码展示节奏

如果你是在面试环境里写这道题，我建议按这个顺序展示思路：

先聊清楚输入：

• 数组版：nums1 预留了 m+n 个位置吗？允不允许用额外数组？m 和 n 各是多少？
• 链表版：可不可以修改原链表节点的 next 指针？两个链表有没有可能为空？

再说复杂度目标：

• 时间必然 O(m+n)，因为你得看每个元素至少一眼。
• 空间争取 O(1)，数组版用倒序归并，链表版用迭代。

然后写代码：

• 先写主逻辑循环，再写剩余处理，最后返回结果。
• 数组版一句话点明“从后往前防止覆盖”。
• 链表版一句话点明“dummy 统一头节点处理”。

最后主动跑测试用例：

• 说一句“我跑几个边界 case 验证一下”，然后快速跑一遍空数组、一空一非空、交错大小、全部偏大偏小这四组。
• 不要干等面试官提示，主动讲边界情况是加分项。

7. 实操总结与个人体会

刷这道题最赚的地方，是你把“双指针归并”这个思维模型焊死在脑子里之后，后面碰到各种变体题都会感觉似曾相识。数组、链表只是归并的两种载体，真正的灵魂是“每轮比较只看两个序列的头部，谁小取谁”这个决策规则。把这个规则内化，你再看 k 路归并、有序矩阵合并、区间合并，都是同一棵树上长出来的枝叶。

我个人在实际操作中有一个习惯：不管题目要求的是数组还是链表，我都会先把归并的核心规则用伪代码写一遍，再根据数据结构特性去填空。数组版本填的是“游标怎么移动、剩余怎么复制”，链表版本填的是“指针怎么串联、边界怎么处理”。这个习惯帮我少踩了很多“思路对但代码崩”的坑。

再分享一个小技巧：面试时如果时间紧张，代码写完后不一定要跑完整测试套件，但至少要在心里演算一遍“其中一个列表为空”和“第一个元素被选中”这两个瞬间的指针变化。百分之八十的链表崩溃现场都是在这两个时刻发生的，提前在心中过一遍，能救你于水火。

说实话，这道题网上题解一抓一大把，但真正拉开差距的不是会不会默写代码，而是能不能在写之前说清楚“为什么倒着合并”“为什么需要 dummy 节点”。等你把这两个为什么刻进肌肉记忆，合并两个有序列表对你来说就不再是面试题，而是一种本能的工程直觉了。