【剑指offer】JZ25 合并两个排序的链表

1 问题

输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。
数据范围：
0≤n≤1000，−1000≤节点值≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n)

如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}，转换过程如下图所示：

或输入{-1,2,4},{1,3,4}时，合并后的链表为{-1,1,2,3,4,4}，所以对应的输出为{-1,1,2,3,4,4}，转换过程如下图所示：

示例1
输入：{1,3,5},{2,4,6}
返回值：{1,2,3,4,5,6}

示例2
输入：{},{}
返回值：{}

示例3
输入：{-1,2,4},{1,3,4}
返回值：{-1,1,2,3,4,4}

2 答案

自己写的，需要一个dummy，一个cur

class Solution:
    def Merge(self , pHead1: ListNode, pHead2: ListNode) -> ListNode:
        dummy = ListNode(0)
        cur = dummy
        while pHead1 or pHead2:
            if not pHead1:
                cur.next = pHead2
                break
            elif not pHead2:
                cur.next = pHead1
                break
            elif pHead1.val <= pHead2.val:
                cur.next = pHead1
                pHead1 = pHead1.next
                cur = cur.next
            else:
                cur.next = pHead2
                pHead2 = pHead2.next
                cur = cur.next
        return dummy.next

官方解

1. 双指针迭代，思路比较相似，一个head，一个cur

这道题既然两个链表已经是排好序的，都是从小到大的顺序，那我们要将其组合，可以使用归并排序的思想：每次比较两个头部，从中取出最小的元素，然后依次往后。这样两个链表依次往后，我们肯定需要两个指针同方向访问才能实现。

• step 1：判断空链表的情况，只要有一个链表为空，那答案必定就是另一个链表了，就算另一个链表也为空。
• step 2：新建一个空的表头后面连接两个链表排序后的节点，两个指针分别指向两链表头。
• step 3：遍历两个链表都不为空的情况，取较小值添加在新的链表后面，每次只把被添加的链表的指针后移。
• step 4：遍历到最后肯定有一个链表还有剩余的节点，它们的值将大于前面所有的，直接连在新的链表后面即可。

class Solution:
    def Merge(self , pHead1: ListNode, pHead2: ListNode) -> ListNode:
        #一个已经为空了，直接返回另一个
        if pHead1 == None: 
            return pHead2
        if pHead2 == None:
            return pHead1
        #加一个表头
        head = ListNode(0) 
        cur = head
        #两个链表都要不为空
        while pHead1 and pHead2: 
            #取较小值的节点
            if pHead1.val <= pHead2.val: 
                cur.next = pHead1
                #只移动取值的指针
                pHead1 = pHead1.next 
            else:
                cur.next = pHead2
                #只移动取值的指针
                pHead2 = pHead2.next 
            #指针后移
            cur = cur.next 
        #哪个链表还有剩，直接连在后面
        if pHead1: 
            cur.next = pHead1
        else:
            cur.next = pHead2
        #返回值去掉表头
        return head.next 

2. 双指针递归，回溯，即其实是倒着走的

思路：

• 终止条件： 当一个链表已经因为递归到了末尾，另一个链表剩余部分一定都大于前面的，因此我们可以将另一个链表剩余部分拼在结果后面，结束递归。
• 返回值： 每次返回拼接好的较大部分的子链表。
• 本级任务： 每级不断进入下一个较小的值后的链表部分与另一个链表剩余部分，再将本次的节点接在后面较大值拼好的结果前面。

具体做法：

• step 1：每次比较两个链表当前节点的值，然后取较小值的链表指针往后，另一个不变，两段子链表作为新的链表送入递归中。
• step 2：递归回来的结果我们要加在当前较小值的节点后面，相当于不断在较小值后面添加节点。
• step 3：递归的终止是两个链表有一个为空。

class Solution:
    def Merge(self , pHead1: ListNode, pHead2: ListNode) -> ListNode:
        #一个已经为空了，返回另一个
        if pHead1 == None: 
            return pHead2
        if pHead2 == None:
            return pHead1
        #先用较小的值的节点
        if pHead1.val <= pHead2.val: 
            #递归往下
            pHead1.next = self.Merge(pHead1.next, pHead2) 
            return pHead1
        else:
            #递归往下
            pHead2.next = self.Merge(pHead1, pHead2.next) 
            return pHead2

https://www.nowcoder.com/share/jump/9318638301698510009341