题目

给定一个链表数组，每个链表都已经按升序排列。
请将所有链表合并到一个升序链表中，返回合并后的链表。

示例 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

解法

优先级队列解法：
建立优先队列，并自定义回调函数（采用小根堆的方式）
由于各个链表都已经按升序排列好了，所以链表头结点就是各个链表中的最小值:

• 初始时让各个链表的头结点入队，然后出队链接到哑结点dummy后面;
• 然后再让出队元素的next入队补上，依次循环直至队列空即可。

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        ListNode.__lt__ = lambda a, b: 0 # 只需要定义即可，返回值我们用不到
        
        if not lists: return None
        nodeheap = []
        for node in lists: # 将每个链表的第一个node全部丢入heap
            if node:
                heapq.heappush(nodeheap, (node.val, node))
        
        dummy = ListNode(-1)
        p = dummy
        
        while nodeheap: # 每pop一个node，push它的下一个node
            val, node = heapq.heappop(nodeheap)
            p.next = ListNode(val, None)
            p = p.next
            if node.next:
                heapq.heappush(nodeheap, (node.next.val, node.next))

        return dummy.next

第二种方式：快排
把所有节点都加到一个list中，然后对list排序，将排序后的list中的节点串起来。

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        # 快排
        res = []
        for item in lists:
            while item:
                res.append(item)
                item = item.next
        res.sort(key=lambda x: x.val)
        dummy = ListNode(-1)
        p = dummy
        for i in res:
            p.next = i
            p = p.next
        return dummy.next