Leetcode 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

思路：
和合并两个有序链表类似，我们只需要用k个指针分别指向k个链表即可，如果用循环遍历则时间复杂度就是nk的，这里可以用堆来维护一个最小值，这样时间复杂度是nlogk的。

并且这里要重载括号，比较生僻的语法，可以背住。

在 C++ 标准库中，priority_queue 的默认比较函数是小于运算符（operator<），这意味着在默认情况下，priority_queue 是一个最大堆，其中较大的元素具有较高的优先级。

在 priority_queue 内部，它使用比较函数来确定元素的顺序。当您不提供比较函数时，它会使用默认的比较函数 std::less，即小于运算符（operator<）。因此，默认情况下，priority_queue 中的元素将按照元素类型的 < 运算符进行排序。

因此想用小根堆的 话， 可以用大于号

/**
 * 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; // 因为C++默认大根堆，这里反着用>就相当于小根堆
        }
    };

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, Cmp> heap;
        auto dummy = new ListNode(-1);
        auto a = dummy;
        for(auto l : lists) if(l) heap.push(l);

        while(heap.size()) {
            auto t = heap.top();
            heap.pop();

            a = a->next = t;
            if(t->next) heap.push(t->next);
        }

        return dummy->next;
    }
};