（优先队列）23. 合并K个排序链表

21.合并2个排序链表

在解决「合并K个排序链表」这个问题之前，我们先来看一个更简单的问题：如何合并两个有序链表？假设链表 a 和 b 的长度都是 n，如何在 O(n) 的时间代价以及 O(1) 的空间代价完成合并？
这个问题在面试中常常出现，为了达到空间代价是 O(1)，我们的宗旨是「原地调整链表元素的 next 指针完成合并」。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        
        if ((!l1) || (!l2)) return l1 ? l1 : l2;
        // 创建一个虚拟的链表头，该局部变量在函数结束时被回收
        ListNode root;
        ListNode *head = &root;
        // 2条链表都有内容，当1条链表空了之后，就退出
        while(l1  && l2 ){
            if (l1->val < l2->val){
                // 为了达到空间代价是 O(1)，使用了输入链表的空间
                // 避免了new操作，提高效率
                head->next = l1;
                l1 = l1->next;
            } else {
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }
        // 将剩下的链表全部接入。
        head->next = l1 ? l1 : l2;
        return root.next;
    }
};

复杂度

• 时间复杂度：O(n)
• 空间复杂度：O(1)

23.合并K个排序链表

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

示例:

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

法1：逐条链表合并

参考上面合并2条有序链表的做法，每次合并2条链表，直到最后全部接到一起。

class Solution {
public:
	// 合并2条排序链表
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *ans = nullptr;
        // 将k条链表逐条接到一起，循环k次即可
        for (size_t i = 0; i < lists.size(); ++i) {
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }
};

复杂度：

• 时间复杂度：O(K²N)
  循环K次，每次循环链表长度都会增加，合并k-1次，那么链表长度变成KN，因此最坏的情况下，时间复杂度O(K·KN)
• 空间复杂度：O(1)

法2：分治合并，两两合并

法2是对法1的优化，将链表两两合并，最后合并成1条，例如，4条变2条，2条变1条。

class Solution {
public:
	// 合并2条排序链表
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }
	// 分而治之，递归合并
    ListNode* merge(vector <ListNode*> &lists, int l, int r) {
        // 有效区间是左闭右闭，l==r时，只有1条链表
        if (l == r) return lists[l];
        if (l > r) return nullptr;
        int mid = (l + r) >> 1;
        // 有效区间是左闭右闭
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
    	// 有效区间是左闭右闭
        return merge(lists, 0, lists.size() - 1);
    }
};

复杂度

• 时间复杂度O(KN·logK)：二分法的时间复杂度是O(logK)，而每次递归处理中，对2个链表的合并又是O(KN)，因此时间复杂度为O(KN·logK)
• 空间复杂度O(1)

法3：使用优先队列合并，如同切葱花一般

这个方法和前两种方法的思路有所不同，我们需要维护一个有限队列（小顶堆），里面存放的是每个非空链表头，每次循环从这个队列中取出最小值，放入结果中，然后移动对应链表头部。

class Solution {
public:
    struct Status {
        int val;
        ListNode *ptr;
        // 对于自定义数据类型的优先队列，需要重载 operator < 因为队列的内部排序会使用到该运算符
        bool operator < (const Status &rhs) const {
        	// c++中优先队列默认是大顶堆，而本题是使用小顶堆，所以将小于号的逻辑取反了，就变成小顶堆了。
            return val > rhs.val;
        }
    };
	// 自定义数据类型的优先队列，只能对队列头进行操作
    priority_queue <Status> q;

	// 传入长度K的链表头向量，返回合并后的链表头
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        for (auto node: lists) {
        	// 将链表头推入队列，内部自动整理
            if (node) q.push({node->val, node});
        }
        ListNode head, *tail = &head;
        while (!q.empty()) {
        	// 将小顶堆的堆顶元素取出
            auto f = q.top(); q.pop();
            // 存入结果链表，依旧是使用了旧链表空间的拼接法
            tail->next = f.ptr; 
            tail = tail->next;
            // 补充优先队列
            if (f.ptr->next) q.push({f.ptr->next->val, f.ptr->next});
        }
        return head.next;
    }
};

复杂度：

• 时间复杂度：考虑优先队列中的元素不超过 k 个，那么插入和删除的时间代价为 O(logk)，这里最多有 kn 个点，对于每个点都被插入删除各一次，故总的时间代价即渐进时间复杂度为 O(kn×logk)。
• 空间复杂度：这里用了优先队列，优先队列中的元素不超过 k 个，故渐进空间复杂度为 O(k)。