堆 (如何手写堆)
作用:维护一个数据集合
是一个完全二叉树,除了最后一层节点之外,上面都是非空的,最后一层从做到右以此排布
基本操作:
1.插入一个数 O(log(n))
2.求集合当中的最小值 O(1)
3.删除最小值 O(log(n))
4.删除任意一个元素 (stl中的堆不能 直接 实现)
5.修改一个元素 (stl中的堆不能 直接 实现)
以小根堆 为例
每个点都小于等于左右儿子,则根节点就是堆里面的最小值
存储;
用一维数组存储,下标从1开始,1为根节点,x的左儿子为2x,x的右儿子为2x+1
两个操作:
down(x) 把一个节点往下移 up(x)把一个节点往上移
其上五个基本操作均可用这两个完成
基本逻辑:
down:
up:
如何实现五种操作:
1.插入一个数 heap[++ size] = x; up (size); 从堆底不断往上移动
2.求集合当中的最小值 heap[1]; 小根堆第一个就是最小的
3.删除最小值 heap[1] = heap[size]; size --; down (1);
把最后一个元素覆盖掉堆顶元素,删掉最后一个节点,再往下移
4.删除任意一个元素 heap[k] = heap[size]; size; down (k); up (k);
同上面,不过不需要考虑是要往上移(k位置上的数变小了)还是往下移(k位置上的数变大了),down和up只会做一个。
5.修改一个元素 heap[k] = x; down (k); up (k);
例题和代码 down操作(包括了插入和删除)
例题:
输入一个长度为 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 = 1e5 + 10;
// 只需要用插入和删除,则只需要用down就行
int n, m;
int h[N], cnt; // h[N]是堆的整体 cnt是数组长度
void down(int u)
{
int t = u; // t是三个里面最小值的下标
if (u * 2 <= cnt && h[u * 2] < h[t]) t = u * 2; // 如果h[t]的左儿子小于h[t]的话,t变成左儿子的下标
if (u * 2 + 1 <= cnt && h[u * 2 + 1] < h[t]) t = u * 2 + 1; // 如果如果h[t]的右儿子小于h[t]的话,t变成右儿子的下标
// 此时t存的就是三个里面最小的那个数的下标
if (u != t) // u不等于t的话说明根节点不是最小值
{
swap(h[u], h[t]); // 要交换一下,将根节点变成最小值
down(t); // 递归处理,此时的t依旧是刚开始的根节点,将其一直往下移
}
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i ++ ) scanf("%d", &h[i]);
cnt = n;
// 从n / 2开始down时间复杂度变为O(n) down完就排好序了
for(int i = n / 2; i; i --) down(i);
while(m --)
{
printf("%d ", h[1]);
h[1] = h[cnt --]; // 将最后一个节点覆盖到第一个,并删除最后一个节点,再将其往下走,这样就删掉了第一个节点
down(1);
}
return 0;
}
为什么要从n / 2开始往下down时间复杂度是O(n)呢?:
例题2:up操作及五种操作
例题
维护一个集合,初始时集合为空,支持如下几种操作:
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 = 1e5 + 10;
// 题中说要删除和修改第k个插入的数,则我们就需要凯两个数组存储第k个数是啥
int n, m;
int h[N], ph[N], hp[N], cnt;
/* ph[i] = k存的是第i个插入的点的下标是k,hp[k] = i是堆里的小标是k的点是第i个插入的点,可以理解为反向指针, 两个是互逆的
也就是说我们用hp来找这个点是第几个插入的,ph找第x个插入的数在堆里的下标是多少,然后就可以用h来知道这个下标的值是多少
*/
void heap_swap(int a, int b) // 映射特有的swap
{
swap(ph[hp[a]], ph[hp[b]]);
swap(hp[a], hp[b]);
swap(h[a], h[b]);
}
void down(int u)
{
int t = u; // t是三个里面最小值的下标
if (u * 2 <= cnt && h[u * 2] < h[t]) t = u * 2; // 如果h[t]的左儿子小于h[t]的话,t变成左儿子的下标
if (u * 2 + 1 <= cnt && h[u * 2 + 1] < h[t]) t = u * 2 + 1; // 如果如果h[t]的右儿子小于h[t]的话,t变成右儿子的下标
// 此时t存的就是三个里面最小的那个数的下标
if (u != t) // u不等于t的话说明根节点不是最小值
{
heap_swap(u, t); // 依旧是交换这两个点
down(t);
}
}
void up(int u)
{
while(u / 2 && h[u / 2] > h [u])
{
heap_swap(u / 2, u);
u /= 2;
}
}
int main()
{
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
while(n --)
{
string op;
int k, x;
cin >> op;
if (op == "I")
{
cin >> x;
cnt ++;
m ++;
ph[m] = cnt, hp[cnt] = m;
h[cnt] = x;
up(cnt);
}
else if (op == "PM") cout << h[1] << endl;
else if (op == "DM")
{
heap_swap(1, cnt); // 交换第一个点和堆最后一个点
cnt --; // 把最后一个点删除 就完成了删除最小值
down(1);// 将其往下移
}
else if (op == "D")
{
cin >> k;
k = ph[k];
heap_swap(k, cnt);
cnt --;
down(k), up(k);
}
else
{
cin >> k >> x;
k = ph[k];
h[k] = x;
down(k), up(k);
}
}
return 0;
}
这种映射不常用,大部分使用的都是普通的up和down操作