优先队列啊

priority_queue

priority_queue<Type, Container, Functional>
// type:数据类型
// container:容器类型
// functional:比较的方式		

默认是大顶堆，具体实现

// 升序队列，小顶堆
priority_queue<int,vector<int>,greater<int>> q;
// 降序队列，大顶堆
priority_queue<int,vector<int>,less<int>> q;
//greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了）

例题 LeetCode 23. 合并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:
    // 重构 priority_queue 的operator()
    // 小顶堆，内部排序递增
    struct comp {
            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*>,comp> q;
        // type:数据类型
        // container:容器类型
        // functional:比较的方式，通过重构comp.operator()实现
        for(ListNode* list:lists)   // 首先分别存放k个链表的首个节点
        {
            if(list)	// 如果列表不为空
                q.push(list);
        }
        ListNode* dummy = new ListNode(0),*cur = dummy;
        while (!q.empty())
        {
            cur->next = q.top();
            q.pop();
            cur = cur->next;
            if(cur->next)   // 将第i个链表的第2个节点(if存在)存入最小栈
                q.push(cur->next);
        }  
        return dummy->next;
    }
    
};