例题：（1）AcWing 838. 堆排序
我们可以利用一个一维数组来模拟堆。由于堆本质上是一个完全二叉树，他的每个父节点的权值都小于左右子节点，而每个父节点编号为n时，左节点编号为2*n，右节点编号为2*n+1。用size记录堆的大小便于维护。在初始建立堆时，由于最后一层在前面每一层建立后自然而然就会被排序，因此我们只需要从倒数第二层开始建立到第一层即可。建立的过程利用到down操作，down操作本质上就是在父节点和两个子节点中进行比较换位，直到往下也不需要换位。而由于一维数组不方便删除头结点，但是删除尾节点只需要size--，因此我们删除头节点的操作就是把头结点和尾结点交换，然后把新的头节点down。
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010;
int heap[N],sz;
void down(int u){int t = u;if(u*2<=sz&&heap[u*2] < heap[t]) t = u*2;if(u*2+1<=sz&&heap[u*2+1] < heap[t]) t = u*2+1;if(t!=u){swap(heap[t],heap[u]);down(t);}
}
int main()
{int n,m;scanf("%d%d", &n, &m);for(int i = 1;i<=n;i++){scanf("%d", &heap[i]);}sz = n;for(int i = n/2;i;i--){down(i);}while(m--){printf("%d ",heap[1]);heap[1] = heap[sz--];down(1);}return 0;
}（2）AcWing 839. 模拟堆
模拟堆的过程相比上面多了几个操作：（1）删除第k个数，修改第k个插入的数，需要用一个记录下标-第k个插入的数和相反关系的两个数组进行维护。（2）还需要用up把下面的较小数往上移。
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e5+10;
unordered_map<int,int> id,mp;//id的对应关系：下标-第k个插入的数，mp的对应关系: 第k个插入的数 - 下标
int h[N];
int sz,cnt;
void down(int u){int t = u;if(u*2<=sz&&h[u*2]<h[t]) t = u*2;if(u*2+1<=sz&&h[u*2+1]<h[t]) t = u*2+1;if(t!=u){swap(mp[id[u]],mp[id[t]]);swap(id[u],id[t]);swap(h[u],h[t]);down(t);}
}
void up(int u){int t = u;if(u/2&&h[u/2]>h[t]) t = u/2;if(t!=u){swap(mp[id[u/2]],mp[id[u]]);swap(id[u/2],id[u]);swap(h[u/2],h[u]);up(t);}
}
int main()
{int n;scanf("%d", &n);for(int i = 0;i<n;i++){char op[5];scanf("%s",op);if(!strcmp(op,"I")){int x;scanf("%d", &x);h[++sz] = x;mp[++cnt] = sz;id[sz] = cnt;up(sz);}else if(!strcmp(op,"PM")){printf("%d\n",h[1]);}else if(!strcmp(op,"DM")){swap(mp[id[1]],mp[id[sz]]);swap(id[1],id[sz]);swap(h[1],h[sz]);sz--;down(1);}else if(!strcmp(op,"D")){int k;scanf("%d", &k);k = mp[k];swap(mp[id[k]],mp[id[sz]]);swap(id[k],id[sz]);swap(h[k],h[sz]);sz--;down(k);up(k);}else{int x,k;scanf("%d%d", &k, &x);k = mp[k];h[k] = x;down(k);up(k);}}return 0;
}练习：（1）Leetcode 692.前k个高频单词
没做出来。。优先队列居然还能这么用的吗。。
先用哈希表统计每个单词出现的次数，然后遍历哈希表（可以用auto直接循环），把每个<string,pair>加入到优先队列进行排序。最后由于需要按照字典序排序，我们还需要从后往前放置答案。
class Solution {
public:vector<string> topKFrequent(vector<string>& words, int k) {unordered_map<string,int> x;for(auto c:words){x[c]++;}auto cmp = [](const pair<string,int> &a,pair<string,int> &b){return a.second == b.second ? a.first < b.first : a.second > b.second;};priority_queue<pair<string,int>,vector<pair<string,int>>, decltype(cmp)> ans(cmp);for(auto c:x){ans.push(c);if(ans.size()>k) ans.pop();}vector<string> res(k);for(int i = k-1;i>=0;i--){res[i]=ans.top().first;ans.pop();}return res;}
};（2）Leettcode 703.数据流中的第K大元素
一开始一直想靠sort。。没用。。
由于优先队列只能访问队头数组，所以我们要让数据流中的第K大元素是优先队列的队头，因此我们要保证优先队列中只有K个数，这K个数中的最小的数就一定是第K大的数，也是优先队列的队头。
class KthLargest {
public:priority_queue<int,vector<int>,greater<int>> x;int k;KthLargest(int k, vector<int>& nums) {this->k = k;for(auto c:nums){x.push(c);if(x.size()>k) x.pop();}}int add(int val) {x.push(val);if(x.size()>k) x.pop();return x.top();}
};
（3） Leetcode 264.丑数II
没做出来。。
假如一个数为丑数，那么这个数的两倍，三倍和五倍对应的数也是丑数，当然这么做肯定会有重复，因此我们用一个哈希集合来存储出现过的数，这样保证小根堆里面不出现重复的数，因此第k次取出来的数就是第k个丑数。
class Solution {
public:long nthUglyNumber(int n) {priority_queue<long,vector<long>,greater<long>> x;unordered_set<int> y;x.push(1);y.insert(1);for(int i = 0;i<n-1;i++){long k = x.top();x.pop();if(!y.count(k*2)){x.push(k*2);y.insert(k*2);}if(!y.count(k*3)){x.push(k*3);y.insert(k*3);}if(!y.count(k*5)){x.push(k*5);y.insert(k*5);}}return x.top();}
};
