手写堆，而非stl中的堆
如何手写一个堆？
//将数组建成堆 <O(n)
for (int i = n / 2;i;i--) //从n/2开始down
down(i);
从n/2元素开始down，最下面一层元素的个数是n/2，其余上面的元素的个数是n/2，从最下面一层到最高层，每层元素的个数是n/2^m【m从下到上，从1计算，m=1时是最下面一层】，时间复杂度就是元素个数*高度【高度从下到上，从0计算】
性质
1.堆是一棵完全二叉树【除叶子结点之外，所有结点都是非空的】
2.小根堆：每个点的值都是小于等于其左右两个儿子的，根结点就是整个数据中的最小值
静态数组存储------一维数组
用一个一维数组来存，根结点放在数组开头，1号点是根结点，结点x的左儿子下标为2x，右儿子下标为2x+1
两个基本操作
对于所有的堆操作而言，每个操作都可以使用这两个操作构建。
down(x) 向下调整------从下往上down一次就变成一个堆
大数位于上面，需要向下移
每次与其两个儿子进行比较，找到较小的儿子与其进行交换，直到小于所有的儿子为止【该结点的子结点都大于该结点】
//递归实现
void down(int u) {
int t = u;//用t表示三个点中的最小值
if (u * 2 <= size1 && h[u * 2] < h[t])//先判断是否有左儿子，然后判断左儿子是否小于其本身,如果成立，交换
t = u * 2;
if (u * 2 + 1 <= size1 && h[u * 2 + 1] < h[t])//再判断是否有右儿子，然后判断右儿子是否小于其本身,如果成立，交换
t = u * 2 + 1;
//最终，t存的就是三个点中最小的结点编号
if (u != t) {//如果u!=t，说明根结点就不是最小的，需要交换
swap(h[u], h[t]);//交换
down(t);//递归，交换之前h[t]<=h[u]，交换之后h[t]>h[u]，h[t]中存的是大数，对其再进行down操作，即递归
}
return;
}
up(x) 向上调整
小数位于下面，需要向上移
每次只需要与其根结点比较，如果小于其根结点，就与其根结点进行交换，直到>=其根结点为止
//循环实现
void up(int u) {
while (u / 2 && h[u / 2] > h[u]) {//u的父结点为u/2,父结点存在且大于本身，交换
swap(h[u / 2], h[u]);
u = u / 2;
}
return;
}
操作
【前三最重要】
【下标从1开始】
1.向集合中插入一个数
在整个堆的最后一个位置插入，然后再向上调整
heap[++size]=x;
up(size);
2.求集合中的最小值
heap[1];
3.删除最小值
用整个堆的最后一个元素覆盖掉堆顶的元素，然后size--，然后向下调整
因为删去最后一个结点特别容易，而删除根结点却不易
heap[1]=heap[size];
size--;
down(1);
4.删除任意一个元素
用堆的最后一个结点覆盖该结点，然后size--，然后向下调整（变大）、向上调整（变小），二选一执行
heap[k]=heap[size];
size--;
down(k);//变大
up(k);//变小
5.修改任意一个操作
heap[k]=x;
down(k);//变大
up(k);//变小
例题------堆排序
题目描述
输入一个长度为n的整数数列，从小到大输出前m小的数。
输入格式
第一行包含整数n和m。
第二行包含n个整数，表示整数数列。
输出格式
共一行，包含m个整数，表示整数数列中前m小的数。
数据范围
1≤m≤n≤10^5，
1≤数列中元素≤10^9
输入样例
5 3
4 5 1 3 2
输出样例
1 2 3
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 100010;
int n, m;
int h[N], size1;//h[N]就是heap[N],size1存储当前有多少个元素
int main() {
scanf("%d%d", &n, &m);
for (int i = 1;i <= n;i++)
scanf("%d", &h[i]);
size1 = n;
//将数组建成堆 <O(n)
for (int i = n / 2;i;i--) //从n/2开始down
down(i);
while (m--) {
printf("%d ", h[1]);//每次输出堆顶元素，并将其删去
h[1] = h[size1];
size1--;
down(1);
}
return 0;
}
例题------模拟堆[包含映射]
增加两个数组
使用两个数组维护两个映射关系，ph[k] 存第k个插入的点在堆中的下标，hp[k] 存堆中下标为k的点是第几个插入的点
增加的原因
因为按第几个插入元素更改内容，需要知道第i个插入的元素在堆中的下标，所以需要ph的存在，而因为元素在进行down与up操作时，使得ph内容与实际堆的元素不对应，所以要改变ph，而改变ph应该知道，每一个下标对应的插入元素是第几个，所以需要hp的存在。每次交换位置时应该共同维护这两个数组。
交换操作
void heap_swap(int a, int b) {
swap(ph[hp[a]], ph[hp[b]]);//交换指向
swap(hp[a], hp[b]);
swap(h[a], h[b]);
return;
}
交换堆中的两个元素时，hp 和 ph 也改变。先改变 hp 和 ph 中的内容，然后改变这两个结点中的值。先根据交换的下标找到对应的 hp，并以两个 hp 元素值作为 ph 的下标，交换这2个 ph 元素值。之后根据下标交换 hp。
swap(ph[hp[a]], ph[hp[b]])；为什么这里的ph的下标是hp的元素值而不是堆中元素的编号？
因为ph的下标k的含义【即ph[k]的k的含义】是第k个插入的点，所以我们要找到第k个插入的点而不是堆中下标为k的点。
改变后的操作
up 操作
手写的heap_swap函数代替原来的swap函数
void up(int u) {
while (u / 2 && h[u / 2] > h[u]) {//u的父结点为u/2,父结点存在且大于本身，交换
heap_swap(u / 2, u);
u = u / 2;
}
return;
}
down 操作
手写的heap_swap函数代替原来的swap函数
void down(int u) {
int t = u;//用t表示三个点中的最小值
if (u * 2 <= size1 && h[u * 2] < h[t])//先判断是否有左儿子，然后判断左儿子是否小于其本身,如果成立，交换
t = u * 2;
if (u * 2 + 1 <= size1 && h[u * 2 + 1] < h[t])//再判断是否有右儿子，然后判断右儿子是否小于其本身,如果成立，交换
t = u * 2 + 1;
//最终，t存的就是三个点中最小的结点编号
if (u != t) {//如果u!=t，说明根结点就不是最小的，需要交换
heap_swap(u, t);//交换
down(t);
}
return;
}
向集合中插入一个数
添加hp和ph数组中的映射关系
scanf("%d", &x);//向堆中插入x
size1++;
m++;
ph[m] = size1;
hp[size1] = m;
h[size1] = x;
up(size1);
输出集合中的最小值
printf("%d\n", h[1])
删除最小值
手写的heap_swap函数代替原来的swap函数
heap_swap(1, size1);
size1--;
down(1);
删除第k个插入的元素
scanf("%d", &k);//输入k
k = ph[k];//找到第k个插入的元素在堆中的下标，然会对其进行删除
heap_swap(k, size1);//用堆中最后一个元素覆盖找到的元素，然会进行调整
size1--;
down(k), up(k);
修改第k个插入的元素
scanf("%d%d", &k, &x);//输入k和修改后的值x
k = ph[k];//找到第k个插入的元素在堆中的下标，然后修改其值，修改后进行调整
h[k] = x;
down(k), up(k);
题目描述
维护一个集合，初始时集合为空，支持如下几种操作：
"I x"，插入一个数x；
"PM"，输出当前集合中的最小值；
"DM"，删除当前集合中的最小值（当最小值不唯一时，删除最早插入的最小值）；
"D k"，删除第k个插入的数；
"C k x"，修改第k个插入的数，将其变为x；
现在要进行N次操作，对于所有第2个操作，输出当前集合的最小值。
输入格式
第一行包含整数N。
接下来N行，每行包含一个操作指令，操作指令为"I x"，"PM"，"DM"，"D k"或"C k x"中的一种。
输出格式
对于每个输出指令"PM"，输出一个结果，表示当前集合中的最小值。
每个结果占一行。
数据范围
1≤N≤10^5
−10^9≤x≤10^9
数据保证合法。
输入样例
8
I -10
PM
I -10
D 1
C 2 8
I 6
PM
DM
输出样例
-10
6
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int N = 100010;
int h[N], ph[N], hp[N], size1;//h[N]就是heap[N],size1存储当前有多少个元素,ph[k]存第k个插入数组的下标
//ph[j]=k【第j次插入数组的数的下标是k】,hp[k]=j【下标为k的数是第j次插入数组中的数】
void heap_swap(int a, int b) {
swap(ph[hp[a]], ph[hp[b]]);//交换指向
swap(hp[a], hp[b]);
swap(h[a], h[b]);
return;
}
void down(int u) {
int t = u;//用t表示三个点中的最小值
if (u * 2 <= size1 && h[u * 2] < h[t])//先判断是否有左儿子，然后判断左儿子是否小于其本身,如果成立，交换
t = u * 2;
if (u * 2 + 1 <= size1 && h[u * 2 + 1] < h[t])//再判断是否有右儿子，然后判断右儿子是否小于其本身,如果成立，交换
t = u * 2 + 1;
//最终，t存的就是三个点中最小的结点编号
if (u != t) {//如果u!=t，说明根结点就不是最小的，需要交换
heap_swap(u, t);//交换
down(t);
}
return;
}
void up(int u) {
while (u / 2 && h[u / 2] > h[u]) {//u的父结点为u/2,父结点存在且大于本身，交换
heap_swap(u / 2, u);
u = u / 2;
}
return;
}
int main() {
int n, m = 0;
scanf("%d", &n);
while (n--) {
char op[10];
int k, x;
scanf("%s", op);
if (!strcmp(op, "I")) {
scanf("%d", &x);
size1++;
m++;
ph[m] = size1;
hp[size1] = m;
h[size1] = x;
up(size1);
}
else if (!strcmp(op, "PM"))
printf("%d\n", h[1]);
else if (!strcmp(op, "DM")) {
heap_swap(1, size1);
size1--;
down(1);
}
else if (!strcmp(op, "D")) {
scanf("%d", &k);
k = ph[k];
heap_swap(k, size1);
size1--;
down(k), up(k);
}
else {
scanf("%d%d", &k, &x);
k = ph[k];
h[k] = x;
down(k), up(k);
}
}
return 0;
}