21. 合并两个有序链表 - 题解与详细分析

题目描述

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例

示例 1：

复制代码

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

复制代码

输入：l1 = [], l2 = []
输出：[]

示例 3：

复制代码

输入：l1 = [], l2 = [0]
输出：[0]

解题思路

这道题要求合并两个有序链表，保持合并后的链表仍然有序。这是一个经典的链表操作问题，可以使用迭代法解决。

核心思想

比较节点值：每次比较两个链表当前节点的值
选择较小节点：将值较小的节点添加到新链表中
移动指针：移动被选中节点所在链表的指针
处理剩余节点：当其中一个链表遍历完后，将另一个链表的剩余部分直接连接到新链表

代码实现

复制代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    // 处理空链表情况
    if(list1 == NULL)
    {
        return list2;
    }

    if(list2 == NULL)
    {
        return list1;
    }

    struct ListNode* newhead = NULL;  // 新链表的头节点
    struct ListNode* newtail = NULL;  // 新链表的尾节点

    // 遍历两个链表，选择较小值的节点添加到新链表
    while(list1 && list2)
    {
        if(list1->val < list2->val)
        {
            // 选择list1的当前节点
            if(newhead == NULL)
            {
                // 新链表为空，初始化头尾节点
                newhead = newtail = list1;
            }
            else
            {
                // 将节点添加到新链表尾部
                newtail->next = list1;
                newtail = list1;
            }
            list1 = list1->next;  // 移动list1指针
        }
        else
        {
            // 选择list2的当前节点
            if(newhead == NULL)
            {
                // 新链表为空，初始化头尾节点
                newhead = newtail = list2;
            }
            else
            {
                // 将节点添加到新链表尾部
                newtail->next = list2;
                newtail = list2;
            }
            list2 = list2->next;  // 移动list2指针
        }
    }

    // 处理剩余节点
    if(list1)
    { 
        newtail->next = list1;
    }

    if(list2)
    {
        newtail->next = list2;
    }

    return newhead;
}

代码详解

第一部分：处理边界情况

复制代码

if(list1 == NULL)
{
    return list2;
}

if(list2 == NULL)
{
    return list1;
}

如果其中一个链表为空，直接返回另一个链表
这样可以简化后续的逻辑处理

第二部分：初始化新链表

复制代码

struct ListNode* newhead = NULL;
struct ListNode* newtail = NULL;

newhead：指向新链表的头节点
newtail：指向新链表的尾节点，用于高效地添加新节点

第三部分：合并过程

复制代码

while(list1 && list2)
{
    if(list1->val < list2->val)
    {
        // 处理list1节点
        if(newhead == NULL)
        {
            newhead = newtail = list1;
        }
        else
        {
            newtail->next = list1;
            newtail = list1;
        }
        list1 = list1->next;
    }
    else
    {
        // 处理list2节点
        if(newhead == NULL)
        {
            newhead = newtail = list2;
        }
        else
        {
            newtail->next = list2;
            newtail = list2;
        }
        list2 = list2->next;
    }
}

核心逻辑：

比较两个链表当前节点的值
选择值较小的节点添加到新链表
移动被选中节点所在链表的指针
更新新链表的尾指针

第四部分：处理剩余节点

复制代码

if(list1)
{ 
    newtail->next = list1;
}

if(list2)
{
    newtail->next = list2;
}

当其中一个链表遍历完后，将另一个链表的剩余部分直接连接到新链表尾部
由于剩余部分已经是有序的，所以可以直接连接

执行过程可视化

以示例1 l1 = [1,2,4], l2 = [1,3,4] 为例：

复制代码

初始状态：
list1: 1 -> 2 -> 4 -> NULL
list2: 1 -> 3 -> 4 -> NULL
newhead = NULL, newtail = NULL

第1次循环：list1->val(1) == list2->val(1)，选择list2
newhead -> 1(list2), newtail -> 1(list2)
list2移动到3

第2次循环：list1->val(1) < list2->val(3)，选择list1
newtail->next = 1(list1), newtail = 1(list1)
list1移动到2

第3次循环：list1->val(2) < list2->val(3)，选择list1
newtail->next = 2, newtail = 2
list1移动到4

第4次循环：list1->val(4) > list2->val(3)，选择list2
newtail->next = 3, newtail = 3
list2移动到4

第5次循环：list1->val(4) == list2->val(4)，选择list2
newtail->next = 4(list2), newtail = 4(list2)
list2移动到NULL

循环结束，list1还有剩余节点4
newtail->next = 4(list1)

最终结果：1->1->2->3->4->4->NULL

优化方案

方法二：使用虚拟头节点

复制代码

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    // 创建虚拟头节点
    struct ListNode dummy;
    struct ListNode* tail = &dummy;
    dummy.next = NULL;
    
    // 合并两个链表
    while (list1 && list2) {
        if (list1->val < list2->val) {
            tail->next = list1;
            list1 = list1->next;
        } else {
            tail->next = list2;
            list2 = list2->next;
        }
        tail = tail->next;
    }
    
    // 处理剩余节点
    tail->next = list1 ? list1 : list2;
    
    return dummy.next;
}

优点：

代码更简洁，不需要单独处理头节点初始化
逻辑更清晰

方法三：递归解法

复制代码

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    // 递归终止条件
    if (list1 == NULL) return list2;
    if (list2 == NULL) return list1;
    
    // 递归合并
    if (list1->val < list2->val) {
        list1->next = mergeTwoLists(list1->next, list2);
        return list1;
    } else {
        list2->next = mergeTwoLists(list1, list2->next);
        return list2;
    }
}

优点：

代码非常简洁
思路清晰

缺点：

递归调用可能产生栈溢出（对于很长的链表）

复杂度分析

迭代法

时间复杂度：O(n+m)，其中 n 和 m 分别是两个链表的长度
空间复杂度：O(1)，只使用了常数级别的额外空间

递归法

时间复杂度：O(n+m)
空间复杂度：O(n+m)，递归调用栈的深度

扩展应用

这种合并有序链表的技巧可以应用于：

合并K个有序链表：使用分治策略或优先队列
归并排序中的合并步骤：链表版本的归并排序
数据库中的多路归并：外部排序算法

总结

合并两个有序链表是链表操作中的经典问题，掌握它对于理解链表操作和分治算法都很重要：

核心技巧：使用双指针遍历两个链表，比较节点值，选择较小者
边界处理：注意处理空链表的情况
效率优化：使用尾指针可以高效地在链表尾部添加节点
代码简洁：使用虚拟头节点可以简化代码逻辑

这道题的解法体现了分治思想在链表操作中的应用，是学习更复杂链表问题的基础。