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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

优先级队列

//第一种
priority_queue<int, vector<int>, greater<int> > q


//第二种
//定义排序的方式，这个定义的方式需要注意cmp后面没有（），operator后面使用了（）而不是<等（但是在其他文章中看到可以使用<，但是我使用了之后有点错误），结束的}后面需要加上;
struct cmp{
       bool operator () (ListNode* a, ListNode* b)
       {
           return a->val > b->val;
       }
   };
priority_queue<ListNode*, vector<ListNode*>, cmp> q;

相关链接

优先级队列的用法（基本）
这个是最基本的方法说明

题解

使用了优先队列进行存储和自动排序，然后保存到一个全新的链表中。
用一个大小为K的最小堆（用优先队列+自定义降序实现）(优先队列就是大顶堆，队头元素最大,自定义为降序后，就变成小顶堆，队头元素最小)，先把K个链表的头结点放入堆中，每次取堆顶元素，然后将堆顶元素所在链表的下一个结点加入堆中。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:

    struct cmp{
        bool operator () (ListNode* a, ListNode* b)
        {
            return a->val > b->val;
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
    	//定义优先队列
        priority_queue<ListNode*, vector<ListNode*>, cmp> q;
		// 默认 priority_queue 是大顶堆， 这个题目中要使用小顶堆, 额外传入重载之后的比较函数
        // 第一个参数代表 priority_queue 中存储的数据类型
        // 第二个参数代表 priority_queue 底层使用的容器，第三个参数代表自己自定义的比较参数


        // 将 k 个链表的头结点加入最小堆，放入堆中的数据已经按照从小到大进行了排序
        for(ListNode* t:lists)
        {
            if(t!=nullptr)
            {
                q.push(t);
            }
        }

        //定义存储数据的新链表
        ListNode* prehead = new ListNode(),*p = prehead;
		
		//根据优先队列中存储的各个链表的头节点自动比较大小，输出小的值存储到新的链表中，并把最小值的下一个节点输入到优先队列中
        while(q.size())
        {
            ListNode* t = q.top();
            q.pop();
            p->next = t;
            if(t->next!=nullptr)
            {
                q.push(t->next);
                // 再次放入优先队列q中，这样每次取出来的链表都是最小的那一个
            }
            p = p->next;
        }

        return prehead->next;

    }
};

知识点

将 k 个链表的头结点加入最小堆

第一种：

// 将 k 个链表的头结点加入最小堆
for(ListNode* t:lists)
{
    if(t!=nullptr)
    {
        q.push(t);
    }
}

第二种：将每个list[i]的第一个节点送入堆中

for (int i = 0; i < lists.size(); ++i)
{
	heap.push(lists[i]);
}

其他解题链接

算法导论第三版第六章 合并K个有序链表的三种解法（最小堆法和分治递归法）