【剑指 Offer 25. 合并两个排序的链表】

题目描述

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

解题思路

方法1：递归，不使用额外空间，在l1或l2上做修改

两个链表头部值较小的一个节点与剩下元素的 merge 操作结果合并。

算法流程

1. 特殊例子：如果 l1 或者 l2 是空链表 ，返回非空链表。

2. 递归循环：
   判断 l1 和 l2 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。
   $\{\begin{array}{c}list1[0]+merge(list1[1:],list2)，list1[0]<list2[0]\\ list2[0]+merge(list1,list2[1:])，otherwise\end{array}$

3. 终止条件：两个链表有一个为空，将另一个链表加到后面。

代码：

//递归，不使用额外空间，在l1或l2上做修改
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) return l2;
        if(l2 == null) return l1;
        if(l1.val < l2.val){
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        }else{
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }

    }
}

复杂度分析

• 时间复杂度：O(n + m)，其中 n 和 m 分别为两个链表的长度。因为每次调用递归都会去掉 l1 或者 l2 的头节点（直到至少有一个链表为空），函数 mergeTwoList 至多只会递归调用每个节点一次。因此，时间复杂度取决于合并后的链表长度，即 O(n+m)。
• 空间复杂度：O(n + m)，其中 n 和 m 分别为两个链表的长度。递归调用 mergeTwoLists 函数时需要消耗栈空间，栈空间的大小取决于递归调用的深度。结束递归调用时 mergeTwoLists 函数最多调用 n+m 次，因此空间复杂度为 O(n+m)。

方法2：伪头节点

解题思路

• 根据题目描述， 链表 $l_1,l_2$是 递增 的，因此容易想到使用双指针$l_1$ 和 $l_2$ 遍历两链表，根据$l_1.val$和 $l_2.val$ 的大小关系确定节点添加顺序，两节点指针交替前进，直至遍历完毕。

• 引入伪头节点： 由于初始状态合并链表中无节点，因此循环第一轮时无法将节点添加到合并链表中。
  解决方案：初始化一个辅助节点 dum 作为合并链表的伪头节点，将各节点添加至 dum 之后。

算法流程

1. 初始化： 伪头节点 dum ，节点 cur 指向 dum 。
2. 循环合并： 当 $l_1$或$l_2$ 为空时跳出；
   1. 当 $l_1.val<l_2.val$时： cur 的后继节点指定为 $l_1$ ，并 $l_1$ 向前走一步；
   2. 当 $l_1.val\ge l_2.val$时： cur 的后继节点指定为$l_2$ ，并 $l_2$向前走一步 ；
   3. 节点 cur 向前走一步，即 cur = cur.next 。
3. 合并剩余尾部： 跳出时有两种情况，即 $l_1$为空 或 $l_2$为空。
   1. 若 $l_1\ne null$： 将 $l_1$ 添加至节点 cur 之后；
   2. 否则： 将 $l_2$ 添加至节点 cur 之后。
4. 返回值： 合并链表在伪头节点 dum 之后，因此返回 dum.next 即可。

代码

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dum = new ListNode(0), cur = dum;
        while(l1 != null && l2 != null){
            if(l1.val >= l2.val){
            cur.next = l2;
            l2 = l2.next;
        }
        else {
            cur.next = l1;
            l1 = l1.next;
        }
        cur = cur.next;
    }

    cur.next = (l1 != null) ? l1 : l2; //等价于if(l1 != null) cur.next = l1; else cur.next = l2; 

    return dum.next;

    }
}

复杂度分析：

• 时间复杂度 O(M+N) ： M, N 分别为链表 $l_1$ , $l_2$ 的长度，合并操作需遍历两链表。
• 空间复杂度 O(1) ： 节点引用 dum , cur 使用常数大小的额外空间。

作者：jyd
链接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/solution/mian-shi-ti-25-he-bing-liang-ge-pai-xu-de-lian-b-2/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。