剑指offer第二版（Python3）--面试题25：合并两个排序的链表，合并K个排序链表

第2章 面试需要的基础知识

第3章 高质量的代码

  面试题16：数值的整数次方

  面试题21：调整数组顺序使奇数位于偶数前面

  面试题22：链表中倒数第k个结点

  面试题24 ：翻转链表

  面试题25 ：合并两个排序的链表，合并K个排序链表

第4章 解决面试题的思路

第5章 优化时间和空间效率

第6章 面试中的各项能力

第7章 两个面试案例

---

题目描述
  输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

  这是一道经常被各公司采用的面试题----《剑指offer》
解题思路
  要求O(1)空间复杂度

解法一：
  用两个指针p1和p2分别指向两个链表头节点。

1. 比较p1和p2节点值。若p1.val<=p2.val，用pre_p1保留p1位置，然后p1右移一位，重复步骤1；若p1.val>p2.val，则pre_p1.next=p2，转入步骤2；
2. 比较p1和p2节点值。若p2.val<p1.val，用pre_p2保留p2位置，然后p2右移一位，重复步骤2；若p2.val>p1.val，则pre_p2.next=p1，转入步骤1；
3. 直到p1或者p2为空。

实战

def Merge(pHead1, pHead2):
    # write code here
    if not pHead1:
        return pHead2
    if not pHead2:
        return pHead1
    if pHead1.val <= pHead2.val:
        new_head = pHead1
    else:
        new_head = pHead2

    pre_pHead1, pre_pHead2 = None, None
    while pHead1 and pHead2:
        while pHead1 and pHead2 and pHead1.val <= pHead2.val:
            pre_pHead1 = pHead1
            pHead1 = pHead1.next
        if pre_pHead1:
            pre_pHead1.next = pHead2
            pre_pHead1 = None
        while pHead1 and pHead2 and pHead2.val < pHead1.val:
            pre_pHead2 = pHead2
            pHead2 = pHead2.next
        if pre_pHead2:
            pre_pHead2.next = pHead1
            pre_pHead2 = None
    return new_head

上述解法稍显复杂，代码容易出错。

解法二：
  示例：
    链表1：[1， 3， 5， 7]
    链表2：[2，4， 6， 8]

  首先分析合并两个链表的过程。从头结点开始，链表1的头结点值小于链表2的值，因此链表1的头结点是合并后链表的头结点。我们拿出链表1的头结点，剩下情况如下：
    已确定节点：1
    链表1：[3， 5， 7]
    链表2：[2，4， 6， 8]
  重复上述过程，从头结点开始，链表1的头结点值大于链表2的值，因此链表2的头结点是合并后链表的头结点。我们拿出链表2的头结点，剩下情况如下：
    已确定节点：1， 2
    链表1：[3， 5， 7]
    链表2：[4， 6， 8]
  一直重复上述过程，直到链表1或者链表2为空。这种解法是每次从两个链表的头结点中选出一个来，这样选出的节点可以确保是非递减的。
实战
循环解法

class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
		head = node = ListNode(0)
        while pHead1 and pHead2:
            if pHead1.val <= pHead2.val:
                node.next = pHead1
                pHead1 = pHead1.next
            else:
                node.next = pHead2
                pHead2 = pHead2.next
			node = node.next
			
        if pHead1:
            node.next = pHead1
        if pHead2:
            node.next = pHead2
        return head.next

---

题目描述：
  合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
leetcode

解题思路：
leetcode

因此，我们在每一次配对合并的过程中都会遍历几乎全部 N个节点，并重复这一过程 次。

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

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        amount = len(lists)
        interval = 1
        while interval < amount:
            for i in range(0, amount - interval, interval * 2):
                lists[i] = self.merge2Lists(lists[i], lists[i + interval])
            interval *= 2
        return lists[0] if amount > 0 else None

    def merge2Lists(self, l1, l2):
        head = point = ListNode(0)
        while l1 and l2:
            if l1.val <= l2.val:
                point.next = l1
                l1 = l1.next
            else:
                point.next = l2
                l2 = l2.next
            point = point.next
        if not l1:
            point.next=l2
        else:
            point.next=l1
        return head.next