算法学习09-数据结构04：堆

算法学习09：堆

---

---

前言

---

---

要记忆的模版：

int h[N], size;//h：堆用数组存储 
//将数组 变为 堆 
for(int i = n / 2; i; i --) down(i);

void down(int u)
{
	int t = u;
	//判断 u 是不是比它的左右孩子小。
	//先判断是否有左右孩子 
	if(u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
	if(u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
	if(u != t)
	{
		swap(h[u], h[t]);
		//递归 
		down(t);//调整之后看，t是否会影响 堆的结构 
	}
}

void up(int u)
{
	//判断 u的父节点 是不是比u小 
	//先判断是否存在 父结点 
	while(u / 2 && h[u / 2] > h[u])
	{
		swap(h[u / 2], h[u]);
		u /= 2;//迭代 
	}
 } 

// *****************分割线******************************
// 特别注意：要标记第k个插入的点，所以会有点复杂，自己写交换函数

int h[N], ph[N], hp[N], size;// ph：指向堆， hp： 指向下标
//ph索引：第i个点  hp：堆中的第i个点 
//ph[j] = k：第j个插入的点，在堆里面的下标是k
//hp[k] = j：堆里面下标为k的点，对应的ph数组的下标是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]); 
}

void down(int u)
{
	int t = u;
	//判断 u 是不是比它的左右孩子小。
	if(u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
	if(u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
	if(u != t)
	{
		heap_swap(u, t);
		down(t);//递归 
	}
}

void up(int u)
{
	//判断 u的父节点 是不是比u小 
	while(u / 2 && h[u / 2] > h[u])
	{
		heap_swap(u / 2, u);
		u /= 2;//迭代 
	}
 } 

---

提示：以下是本篇文章正文内容：

一、例题1：堆排序

---

---

堆排序：输入一个长度为n的整数数列，从小到大输出前m小的数。

---

#include <iostream>
#include <algorithm> 

using namespace std;

const int N = le5 + 10;

int n, m;
int h[N], size;//h：堆用数组存储 

void down(int u)
{
	int t = u;
	//判断 u 是不是比它的左右孩子小。
	//先判断是否有左右孩子 
	if(u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
	if(u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
	if(u != t)
	{
		swap(h[u], h[t]);
		//递归 
		down(t);//调整之后看，t是否会影响 堆的结构 
	}
}

void up(int u)
{
	//判断 u的父节点 是不是比u小 
	//先判断是否存在 父结点 
	while(u / 2 && h[u / 2] > h[u])
	{
		swap(h[u / 2], h[u]);
		u /= 2;//迭代 
	}
 } 

int main()
{
	scanf("%d%d", &n, &m);
	//堆的根节点为1（完全二叉树） 
	for(int i = 1; i <= n; i ++) scanf("%d", &h[i]);
	size = n;
	
	//将数组 变为 堆 
	for(int i = n / 2; i; i --) down(i);
	
	while(m --)
	{
		printf("%d", h[1]);
		h[1] = h[size];
		size --;
		down(1);
	 } 
	return 0;
}

---

---

二、例题2：模拟堆

---

---

模拟堆：维护一个集合，初始时，集合为空，支持如下几种操作：
（1）插入一个数x
（2）给出当前集合的最小值
（3）删除当前集合中的最小值（当最小值不唯一时，删除最早插入的最小值）
（4）删除第k个插入的数
（5）修改第k个插入的数

---

#include <iostream> 
#include <algorithm>
#include <string>

using namespace std;

const int N = 1e5 + 10;

int n, m;
int h[N], ph[N], hp[N], size;// ph：指向堆， hp： 指向下标
//ph索引：第i个点  hp：堆中的第i个点 
//ph[j] = k：第j个插入的点，在堆里面的下标是k
//hp[k] = j：堆里面下标为k的点，对应的ph数组的下标是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]); 
}

void down(int u)
{
	int t = u;
	//判断 u 是不是比它的左右孩子小。
	if(u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
	if(u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
	if(u != t)
	{
		heap_swap(u, t);
		down(t);//递归 
	}
}

void up(int u)
{
	//判断 u的父节点 是不是比u小 
	while(u / 2 && h[u / 2] > h[u])
	{
		heap_swap(u / 2, u);
		u /= 2;//迭代 
	}
 } 

int main()
{
	int n, m = 0;
	scanf("%d", &n);
	while(n --)
	{
		char op[10];
		int k, x;
		
		scanf("%s", op);
		if(!strcmp(op, "I"))
		{
			// 插入一个数x
			scanf("%d", &x);
			size ++;
			m ++;
			ph[m] = size, hp[size] = m;
			h[size] = x;
			up(size);
		}
		else if(!strcmp(op, "PM")) 
		//给出当前集合的最小值
		printf("%d\n", h[1]);
		else if(!strcmp(op, "DM")) 
		{
			//删除当前集合中的最小值
			heap_swap(1, size);
			size --;
			down(1);
		}
		else if(!strcmp(op, "D"))
		{
			//删除第k个插入的数
			scanf("%d", &k);
			k = ph[k];
			heap_swap(k, size);
			size --;
			down(k), up(k);//有三种情况，最多执行一个函数 
		}
		else
		{
			//修改第k个插入的数
			scanf("%d", &k);
			k = ph[k];
			h[k] = x;
			down(k), up(k);
		}
	}
	return 0;
}

---

总结

提示：这里对文章进行总结：

💕💕💕