【LeetCode】23.合并 K 个排序链表(python版)

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

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

思路：
这个题是简单难度的《合并两个排序链表》的加强版。

1. 方法一：
   一个很容易想的思路是：先合并前两个链表得到一个新链表，再将新链表与第三个链表合并…。

# 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:
        if len(lists) == 0:
            return None
        l1 = lists[0]
        for l2 in lists[1:]:
            l1 = self.mergeTwoLists(l1, l2)
        return l1

    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        head = ListNode(0)
        t = head
        p, q = l1, l2
        while p and q:
            if p.val <= q.val:
                t.next = p
                p = p.next
            else:
                t.next = q
                q = q.next
            t = t.next
        if p:
            t.next = p
        else:
            t.next = q
        return head.next

复杂度分析：

假设所有链表总长度为 $N$，平均每个链表节点数为$，N/k$每一次合并需要再次扫描新链表中所有节点，也就是说每个链表分别被扫描 1 ，2，3，k-1 次，所以总的时间复杂度为$O\left({\sum }_{i=1}^{k-1}\left(i\ast \left(\frac{N}{k}\right)+\frac{N}{k}\right)\right)=O(kN)$

2. 方法二：
   类似于归并排序，先两两合并，得到$k/2$个链表，然后再对这些链表两两合并…，重复这个过程$lo{g}_2^k$ 次

# 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:
        num_list = len(lists)
        interval = 1
        while interval < num_list:
            # 注意这里的循环条件，因为如果按照(0,1), (2,3)...(k-1, k)分组，对于数量奇偶不同的列表，临界条件处理比较复杂，
            # 所以采用一头一尾组合，(0,k-1), (1,k-2)...的方式分组
            for i in range(0, num_list - interval, interval * 2):
                # 产生的新链表放在了偶数索引的位置
                lists[i] = self.mergeTwoLists(lists[i], lists[i + interval])
            interval *= 2
        return lists[0] if num_list > 0 else None

    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        head = ListNode(0)
        t = head
        p, q = l1, l2
        while p and q:
            if p.val <= q.val:
                t.next = p
                p = p.next
            else:
                t.next = q
                q = q.next
            t = t.next
        if p:
            t.next = p
        else:
            t.next = q
        return head.next

复杂度分析：

相对于方法一，分支法将合并中扫描次数由 k-1 次减少为 $lo{g}_2^k$次，所以时间复杂度为$O(lo{g}_2^{k}N)$

3. 方法三：

暴力法：与之前的题目不同，本题并没有要求新链表要由原链表的节点组成，所以有一个取巧的方法，将所有链表的值收集起来排序，根据排序结果重新生成一个完整的链表。