【leetcode】23. 合并K个升序链表（困难）

23. 合并K个升序链表（困难）

题目描述

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

• k == lists.length
• 0 <= k <= 10^4
• 0 <= lists[i].length <= 500
• -10^4 <= lists[i][j] <= 10^4
• lists[i] 按 升序 排列
• lists[i].length 的总和不超过 10^4

---

思路&代码

---

1. 利用列表作中介来排序，再形成新的链表

将所有结点放入到一个列表中，然后将列表排序，最终将排序后的列表转换成新的链表。

python

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        list_total =[]
        for list_one in lists:
            p = list_one
            while p:
                list_total.append(p)
                p = p.next
        list_total.sort(key=lambda x:x.val)
        head = rear = ListNode()
        for node in list_total:
            rear.next = node
            rear = rear.next
        return head.next

---

2. 优先队列PriorityQueue

逐一比较，每次比较每个链表的头部大小，决定把哪个加入到新链表中。

至于代码中为什么put的是(lists[i].val, i)，主要是第二个参数，不能是lists[i]（这也是我为什么不用**for l in lists:**的原因），因为当优先级一样时，这个队列就将比较后面的参数，而这个链表类是无法比较的。这里可以参考一下：python中PriorityQueue的理解

from queue import PriorityQueue
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        head = rear = ListNode()
        q = PriorityQueue()  # 优先队列
        for i in range(len(lists)):
            if lists[i]:
                # 把每个链表的头插入到队列中，因为每个链表都已经按升序排列，所以每次只比较链表头的值即可
                q.put((lists[i].val, i))
                # ()第一个参数是优先级，数字越小优先级越高，第二个参数是插入到队列中的内容
        while not q.empty():
            val, i = q.get()
            newNode = ListNode(val)
            rear.next = newNode
            rear = rear.next
            lists[i] = lists[i].next
            if lists[i]:
                q.put((lists[i].val, i))
        return head.next

提交后显示这种方法时间花费很大，相比于上一种方法直接翻了一倍多，空间消耗仅减少了一点点。

---

3. 使用headp最小堆复现优先队列

关于heapq的使用可以查看：Python 模块之heapq

复现优先队列主要在于函数heappop(heap)：删除并返回最小值，因为堆的特征是heap[0]永远是最小的元素，所以一般都是删除第一个元素。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
import heapq
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        head = rear = ListNode()
        q = []  # 最小堆（优先队列）
        for i in range(len(lists)):
            if lists[i]:
                # 把每个链表的头插入到队列中，因为每个链表都已经按升序排列，所以每次只比较链表头的值即可
                heapq.heappush(q, (lists[i].val, i))
                # 这里我定义()中第一个参数是优先级，数字越小优先级越高(heapq也是按第一个参数来比较的)，第二个参数是插入到队列中的内容
        while q:
            val, i = heapq.heappop(q)
            newNode = ListNode(val)
            rear.next = newNode
            rear = rear.next
            lists[i] = lists[i].next
            if lists[i]:
                heapq.heappush(q, (lists[i].val, i))
        return head.next

提交后显示时间花费比方法一略高一点，远低于方法二，空间消耗介于两者之间。

4. 分治

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
from queue import PriorityQueue
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        num = len(lists)  # 链表个数
        interval = 1  # 初始间隔
        while interval < num:
            for i in range(0, num - interval, interval * 2):
                lists[i] = self.merge2Lists(lists[i], lists[i + interval])
            interval *= 2
        return lists[0] if num > 0 else None
        
    def merge2Lists(self, l1, l2):  # 合并两个链表
        head = rear = ListNode()
        while l1 and l2:
            if l1.val <= l2.val:
                rear.next = l1
                rear = rear.next
                l1 = l1.next
            else:
                rear.next = l2
                rear = rear.next
                l2 = l2.next
        if l1:
            rear.next = l1
        else:
            rear.next = l2
        return head.next