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⁴
• 0 <= lists[i].length <= 500
• -10⁴ <= lists[i][j] <= 10⁴
• lists[i] 按 升序 排列
• lists[i].length 的总和不超过 10⁴

思路

算法：
优先队列 O(nlogk)

通过双路归并合并两个有序链表，但是这题要求对多个链表进行并操作。 其实和双路归并思路类似，分别用指针指向该链表的头节点，每次找到这些指针中值最小的节点，然后依次连接起来，并不断向后移动指针。

用小根堆维护指向k个链表当前元素最小的指针，因此这里需要用到优先队列，并且自定义排序规则，如下：

struct cmp{
    bool operator() (ListNode* a, ListNode* b){
        return a->val > b->val;  // val值小的在队列前
    }
};

具体过程如下：

1、定义一个优先队列，并让val值小的元素排在队列前。
2、新建虚拟头节点dummy，定义 cur指针并使其指向 dummy。
3、首先将k个链表的头节点都加入优先队列中。
4、当队列不为空时：

取出队头元素t（队头即为k个指针中元素值最小的指针）;
令cur 的 next 指针指向t，并让cur后移一位；
如果t的next指针不为空，我们将t->next加入优先队列中；
5、最后返回dummy->next

时间复杂度：n表示的是所有链表的总长度，k 表示k个排序链表。，所以总的时间复杂度为 O(nlogk) .

代码

C++代码：

class Solution {
public:

    struct cmp{
        bool operator()(ListNode* a, ListNode * b){
            return a->val > b->val;  //元素值小的在前面
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty()) return nullptr;
        priority_queue<ListNode*, vector<ListNode*>, cmp> heap;
        for(auto l : lists) if(l) heap.push(l);
        ListNode* dummmy = new ListNode(-1);
        ListNode* cur = dummmy;
        while(heap.size()){
            auto t = heap.top();
            heap.pop();
            cur = cur->next = t;
            if(t->next) heap.push(t->next);
        }
        return dummmy->next;
    }
};

python3代码：

import heapq

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        heap = []

        for i, l in enumerate(lists):
            if l:
                heapq.heappush(heap, (l.val, i))

        dummy = ListNode(-1)
        tail = dummy
        while heap:
            v, idx = heapq.heappop(heap)
            tail.next = lists[idx]
            tail = tail.next
            if lists[idx].next:
                lists[idx] = lists[idx].next
                heapq.heappush(heap, (lists[idx].val, idx))

        return dummy.next