STL优先队列实现堆（模板 附力扣题目）

讲解视频：https://www.bilibili.com/video/BV12i4y1f7ky/

堆的本质

堆是一种特殊的完全二叉树。每一个节点的值都大于等于或者小于等于其孩子节点的值。

堆的操作时间复杂度如下：

• 插入：$O(lo{g}_n)$
• 删除：$O(lo{g}_n)$
• 获取最大/最小值：$O(1)$

堆的分类（大根堆、小根堆）

大根堆

数据结构（STL优先队列实现）表示：priority_queue<int> q;

小根堆

表示方法：priority_queue<int, vector<int>, greater<int> q;

图片选自“爱学习的饲养员”小姐姐手绘

实战

一般用于TOP K类型。

前K个最大值就小根堆；前K个最小值就大根堆（贪心）

先把STL的优先队列写前面

priority_queue<Type, Container, Functional> //数据类型 容器类型 比较方式

大根堆模板如下：（Top K最小值）

priority_queue<int> q; //定义大根堆
for(auto &i : arr) //arr是容器 这里假设是vector<int> arr
    if(q.size() < k) q.push(i);
    else 
	    if(i < q.top())  //贪心策略
        	q.pop(), q.push(i);

小根堆模板如下：（Top K最大值）

priority_queue<int, vector<int>, greater<int>> q; //定义小根堆
for(auto &i : nums)//假设 vector<int> nums
	if(q.size() < k) q.push(i);
	else if(q.top() < i) q.pop(), q.push(i);

由int变pair<int, int>后的模板如下：

在写模板之前要了解对pair的排序默认为对第一个值（.first）排序，如果想要对第二个值排序需要由自定义函数实现。

static bool cmp1(pair<int, int> &p1, pair<int, int> &p2)
{
	return p1.y > p2.y; //是否交换 父节点将小于子节点 所以小根堆
}
static bool cmp2(pair<int, int> &p1, pair<int, int> &p2)
{
	return p1.y < p2.y; //是否交换 父节点将大于子节点 所以大根堆
}

priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp1)> q(cmp1); //自定义排序second 小根堆

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q; //默认对first排序 小根堆

priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp2)> q(cmp2); //自定义排序second 大根堆

直接上四个裸题吧，把上面的模板一套就AC了，具体怎么套不再赘述：（点击文字跳转题目）

一、剑指 Offer 40. 最小的k个数

二、数组中的第K个最大元素

三、数据流中的第 K 大元素

四、前 K 个高频元素（pair<int, int> 自定义排序）

p.s.依据“爱学习的饲养员”小姐姐讲解、对她的讲解做的笔记

（快去关注“爱学习的饲养员”小姐姐吧~

---

修改时间：2022.2.17

更新背景：昨天躺床上睡觉（实际在玩犯罪大师。更新了互动板块，贼好玩。玩到了两点半）时想到不能只有简单的模板题、那样会让满怀期待的人失望。又想到我还没补周赛题（老咕咕了）、只是十五那天中午去北湖的时候看着湖面想了想。于是这道题被加了进来。

压轴题、删除元素后和的最小差值

题目

给你一个下标从 0 开始的整数数组 nums ，它包含 3 * n 个元素。

你可以从 nums 中删除 恰好 n 个元素，剩下的 2 * n 个元素将会被分成两个 相同大小 的部分。

前面 n 个元素属于第一部分，它们的和记为 sumfirst 。
后面 n 个元素属于第二部分，它们的和记为 sumsecond 。

两部分和的 差值 记为 $su{m}_{first}-su{m}_{second}$ 。

比方说，sumfirst = 3 且 sumsecond = 2 ，它们的差值为 1 。
再比方，sumfirst = 2 且 sumsecond = 3 ，它们的差值为 -1 。

请你返回删除 n 个元素之后，剩下两部分和的 差值的最小值 是多少。

示例 1：

输入：nums = [3,1,2]
输出：-1
解释：nums 有 3 个元素，所以 n = 1 。
所以我们需要从 nums 中删除 1 个元素，并将剩下的元素分成两部分。

- 如果我们删除 nums[0] = 3 ，数组变为 [1,2] 。两部分和的差值为 1 - 2 = -1 。
- 如果我们删除 nums[1] = 1 ，数组变为 [3,2] 。两部分和的差值为 3 - 2 = 1 。
- 如果我们删除 nums[2] = 2 ，数组变为 [3,1] 。两部分和的差值为 3 - 1 = 2 。
  两部分和的最小差值为 min(-1,1,2) = -1 。

示例 2：

输入：nums = [7,9,5,8,1,3]
输出：1
解释：n = 2 。所以我们需要删除 2 个元素，并将剩下元素分为 2 部分。
如果我们删除元素 nums[2] = 5 和 nums[3] = 8 ，剩下元素为 [7,9,1,3] 。和的差值为 (7+9) - (1+3) = 12 。
为了得到最小差值，我们应该删除 nums[1] = 9 和 nums[4] = 1 ，剩下的元素为 [7,5,8,3] 。和的差值为 (7+5) - (8+3) = 1 。
观察可知，最优答案为 1 。

提示：

nums.length == 3 * n
1 <= n <= 105
1 <= nums[i] <= 105

分析

• 题目自定义了差值 -> 两部分和的 差值 记为 $su{m}_{first}-su{m}_{second}$ 。
• 用堆求出前面和后面的前缀和
• 枚举分割点

参考代码

typedef long long LL;
class Solution {
public:
    long long minimumDifference(vector<int>& nums) {
        //令前缀和左闭右开
        int n = nums.size(), m = n / 3;
        priority_queue<int> q1;
        priority_queue<int, vector<int>, greater<int>> q2;
        //a从左到右 b从右到左(前缀和)
        vector<LL>a(n + 1), b(n + 1);

        //用堆计算Top K
        LL tmp = 0;
        for(int i = 0; i < m; ++ i) 
        {
            tmp += nums[i];
            q1.push(nums[i]);
        } 
        a[m] = tmp;
        for(int i = m; i < m * 2; ++ i)
        {
            if(nums[i] < q1.top())
            {
                tmp = tmp - q1.top() + nums[i];
                q1.pop();
                q1.push(nums[i]);
            }
            a[i + 1] = tmp; 
        }

        tmp = 0;
        for(int i = n - 1; i >= 2 * m; -- i)
        {
            tmp += nums[i];
            q2.push(nums[i]);
        }
        b[m] = tmp;
        int idx = m;
        for(int i = 2 * m - 1; i >= m; -- i)
        {
            if(nums[i] > q2.top())
            {
                tmp = tmp - q2.top() + nums[i];
                q2.pop();
                q2.push(nums[i]);
            }
            b[ ++ idx] = tmp;
        }

        //枚举分割点
        LL minn = 1e11;
        for(int i = m; i <= m * 2; ++ i)
            minn = min(minn, a[i] - b[n - i]);
        return minn;
    }
};