DS：堆的结构与实现

已于 2024-06-09 22:24:31 修改
阅读量1.3k 收藏 34
点赞数 55
分类专栏： 数据结构 文章标签： 数据结构 算法 笔记 开发语言 c++ c语言
于 2024-06-09 22:09:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lusanjiu/article/details/139566873
版权

欢迎来到Harper.Lee的学习世界！
博主主页传送门：Harper.Lee的博客主页
想要一起进步的uu可以来后台找我哦！

一、堆的概念与结构

1.1 堆的概念

堆（Heap）是完全二叉树中的一种，分为大根堆和小根堆。
特点：1.每个节点的值都大于或等于其左右孩子节点的值，称为大根堆；或是每个节点的值都小于或等于其左右孩子的值，称为小根堆。2.从堆的概念不难看出，大根堆堆顶为集合的最大值，小根堆堆顶为集合的最小值。（注意：父亲与孩子之间有大小关系，但是兄弟之间没有大小关系，因此堆并不是有序的！！！）

1.2 堆的结构

根据上一节（DS：树与二叉树的相关概念）可知，完全二叉树以数组的形式存储，因此堆采用数组的形式进行数据的存储。
父子的下标特点：(1)父亲找孩子：leftchild=parent2+1，rightchild=parent2+2；(2)孩子找父亲：parent=（child-1）/2。
image.png

二、堆的实现

2.0 分析过程

插入数据部分分析过程：
image.png

2.1 堆的相关结构体的创建

堆的底层是数组，因此结构体就以数组的形式创建。这一步和之前顺序表的创建基本一样。

//结构体的创建
typedef int HPDataType;
typedef struct Heap
{
    //以数组为背景
    HPDataType* a;
    int size;//表示存储的数据个数
    int capacity;//表示空间容量，因为我么虽然操作的是二叉树
}HP;

2.2 堆的初始化

//初始化
void HPInit(HP* php)
{
	//Q：这里需要断言吗？？?  A：php需要断言,避免传入空堆
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;//可以给值，也可以不给值（前面有讲过）
	//如果capacity和size不给值的话，在插入数据的时候就需要动态申请开辟空间
	//如果capacity和size赋值的话，就是另外的一种操作。
}

2.3 堆的插入

push就有建立堆的功能。一边插入数据，一边调整出堆的结构。

//push堆的操作
void HPPush(HP* php,HPDataType x)//传入堆，插入一个数据x
{
	assert(php);

	//1. 先判断空间是否足够
	//1. 若空间不够（说明之前有空间的，即使没有空间，capacity也等于size），则进行增容操作
	if (php->capacity == php->size)//if (php->capacity == php->size == 0)，而不是判断是否为空
	{

		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("malloc fail");
			exit(1);//return;//直接返回也可
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	//2. 开始插入数据
	php->a[php->size] = x;//
	php->size++;

	//3. 调用向上调整函数
	AdjustUp(php->a, php->size-1);//为什么第2个参数是size-1而不是size?----要弄清楚size的位置：最后一个数据位置的下标+1
}

2.4 向上调整算法

//向上调整函数的定义
void AdjustUp(HPDataType* a, int child)//从child的位置开始调整，现在child就是数组末尾了
{
	//虽然控制的十足，但是要把它想象成实在控制二叉树（堆）
	//1.第一次插入的数据在数组的末尾child位置
	int parent = (child - 1) / 2;//父节点的位置找到了
	//2.开始比较父节点和子节点--小根堆：谁小谁当爹
	//循环三要素：a.初始条件b.中间过程c.结束条件
	/*while (a[parent] >= 0)//为什么循环结构是>=0?因为实际上最初始的child从末尾开始就需要和她的所有祖先（一条线上的）全部进行比较，比较完循环才会结束）*/
	//如果用parent>=0来判断，那么由于（0-1）/2是-1/2，取整后还是0，就会再次进入循环，一般情况来说这是错误的，但是这里出现了一个巧合：parent==child==0，break跳出循环了，程序歪打正着的正确了。

	while (a[child] > 0)//上面的循环条件写成下面这种会更好
	{  
		if (a[child] < a[parent])
		{
			//3.开始进行交换操作（Swap函数的调用）
			Swap(&a[child], &a[parent]);
			child = parent;//调整身份继续向上进行下一次（循环可能出现）可能出现的比较
			parent = (child - 1) / 2;//原来的父亲变成孩子（父亲赋值给孩子），然后原来的父亲变成了前一个祖先。
		}
		else
		{
			break;// 满足小根堆的结构
		}
	}
}

2.5 交换函数

//Swap函数的调用
void Swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

2.6 堆的删除

删除堆的末尾数据是没意义的，因为这个操作很简单，封装成函数就是小题大做了。因此，我们一般删除的是堆顶数据即根位置的数据。但是，如果直接删除/挪动/覆盖了堆顶数据，可能父子关系、叔侄关系、兄弟关系会乱套，倒反天罡了。
所以我么选择一种新的解决办法：根节点的数据和尾节点的数据进行交换，然后再删除尾节点的数据，然后进行向下调整算法重新调整堆的结构，这样就实现了堆顶元素的删除。

分析过程如下：image.png
代码实现：

//Pop删除数据——要求删除堆顶即根位置的数据，删除末尾数据没有意义
void HPPop(HP* php)
{
	assert(php);
	//1.将堆顶元素和最后一个元素进行交换
	Swap(&php->a[php->size-1], &php->a[0]);//尾元素：a[size-1]
	//2.删除堆中的最后一个元素的数据---怎么删啊?---删除数组中最后一个元素的数据
	//free(php->a[php->size-1]);//不能使用free，因为内存申请的空间必须一块儿释放，而不是一部分一部分地释放的
	php->size--;//php->size -= 1;
	//3.向下调整算法的运用
	AdjustDown(php->a, php->size, 0);
}

Q1：删除堆顶数据有什么意义或者作用呢？

删除掉了目前堆里最小的元素，相当于取出来堆中的最小的元素。如果连续使用HPPop函数，那么就可以从小到大依次取出堆中的数据，这就是简单模式的TOP-K。

Q2：HPPop的时间复杂度是多少？

pop的时间复杂度为logN（最坏情况），O(1)（最好情况）。而满二叉树/完全二叉树的树高就是logN。

应用：可以一边HPTop获取堆中目前的最小的数据，然后HPPop删除掉这个数据，这样就可以进行排序打印了。

2.7 向下调整算法

//向下调整算法
void AdjustDown(HPDataType* a, int n, int parent)//从parent根节点开始调整
{
	//1.先确定（假设法）用哪个孩子与父亲做比较
	//假设左孩子比右孩子小
	int child = parent * 2 + 1;//根据父节点找到子节点
	while (child < n)//child>=n时，说明该孩子已经不存在了 
	{
		//找出小的孩子
		//if (a[child + 1] < a[child])//此写法存在风险：左孩子<n没有风险，但是右孩子+1就可能存在风险
		if (child + 1 < n && a[child + 1] < a[child])
		{
			//如果右孩子比左孩子小：假设不成立，修改假设的内容：
			++child;//child右移变成右孩子
		}
		//2.小孩子与父亲做比较
		if (a[child] < a[parent])
		{
			Swap(&a[parent], &a[child]);
			//3.交换后进行父亲与孩子的调整
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

2.8 获取堆顶的数据

//获取堆顶的数据（返回堆顶元素）
HPDataType HPTop(HP* php)//top-k问题
{
	//断言：
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}

2.9 判空

//判空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

2.10 堆的销毁

//销毁
void HPDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->capacity = php->size = 0;
	php->a == NULL;
}

2.11 前k个元素的打印

main函数中堆的建立过程以及打印实现过程：

//
int main()
{
   int a[] = { 4,2,8,1,5,6,9,7 };//这个数组现在还不是堆，需要将其变成一个堆（一个个地去插入）
	HP hp;//1.创建一个堆hp
	//2.初始化
	HPInit(&hp);
	//3.建堆（需要插入多个数据，因此，需要多次调用HPPush函数，使用循环结构）
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);//建堆的同时 调整了堆的结构
	}
	//4.打印堆中的所有数据
	//while (!HPEmpty(&hp))
	//{
	//	printf("%d ", HPTop(&hp));//获取到堆顶的数据
	//	HPPop(&hp);
	//}
	//5.如果是找堆里的最大的前k个数据
	int k = 0;
	scanf("%d", &k);
	while (k--)
	{
		printf("%d ", HPTop(&hp));
		HPPop(&hp);
	}
	printf("\n");
    HPDestroy(&hp); 
    return 0;
}

这里是实现了打印上的有序，但是数组本身并不有序。我们可以将每次HPTop操作获得的堆顶数据放在a数组中，就可以使得数组有序了。也就是上一段代码中注释掉的第 4. 点

	//4.打印堆中的所有数据
	//while (!HPEmpty(&hp))
	//{
	//	printf("%d ", HPTop(&hp));//获取到堆顶的数据
	//	HPPop(&hp);
	//}
    //6. 数组a有序的改变
    int i = 0;
	while (!HPEmpty(&hp))
	{
		//printf("%d ", HPTop(&hp));//获取到堆顶的数据
		a[i++] = HPTop(&hp);
		HPPop(&hp);
	}

三、堆的实现-全部代码

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>



//本次-----堆的实现过程 —— 框架

//1. 结构体的创建
typedef int HPDataType;
typedef struct Heap
{
	//以数组为背景
	HPDataType* a;
	int size;//表示存储的数据个数
	int capacity;//表示空间容量，因为我么虽然操作的是二叉树
}HP;

//2. 初始化和销毁
void HPInit(HP* php);//php是结构体指针变量
void HPDestroy(HP* php);
//3. 插入HPDataType类型数据x（节点），注意保持堆的完整结构
void HPPush(HP* php, HPDataType x);
//4. Pop删除数据——要求删除堆顶即根位置的数据
void HPPop(HP* php); 
//5. 向下调整法
void AdjustUp(HPDataType* a,int child);
//6. 向上调整法
void AdjustDown(HPDataType* a, int n, int parent);
//7. 判断堆结构是否为空
bool HPEmpty(HP* php);
//8. 交换函数
void Swap(HPDataType* a, HPDataType* b);
//9. 获取堆顶数据
HPDataType HPTop(HP* php);


#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

//（1） 初始化
void HPInit(HP* php)//传入堆（php是堆的名称）
{
	//Q：这里需要断言吗？？?  A：php需要断言,避免传入空堆
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;//可以给值，也可以不给值（前面有讲过）
	//如果capacity和size不给值的话，在插入数据的时候就需要动态申请开辟空间
	//如果capacity和size赋值的话，就…………？？？两种玩法一样
}

//（2） 销毁（free释放掉动态申请的空间）
void HPDestroy(HP* php)
{
	assert(php);
	free(php);//释放掉空间后记得善后
	php->capacity = php->size = 0;
	php->a = NULL;
}

//（5）Swap函数的调用
void Swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

//（4） 向上调整函数的定义
void AdjustUp(HPDataType* a, int child)//从child的位置开始调整，现在child就是数组末尾了
{
	//虽然控制的十足，但是要把它想象成实在控制二叉树（堆）
	//1.第一次插入的数据在数组的末尾child位置
	int parent = (child - 1) / 2;//父节点的位置找到了
	//2.开始比较父节点和子节点--小根堆：谁小谁当爹
	//循环三要素：a.初始条件b.中间过程c.结束条件
	/*while (a[parent] >= 0)//为什么循环结构是>=0?因为实际上最初始的child从末尾开始就需要和她的所有祖先（一条线上的）全部进行比较，比较完循环才会结束）*/
	//如果用parent>=0来判断，那么由于（0-1）/2是-1/2，取整后还是0，就会再次进入循环，一般情况来说这是错误的，但是这里出现了一个巧合：parent==child==0，break跳出循环了，程序歪打正着的正确了。

	while (a[child] > 0)//上面的循环条件写成下面这种会更好
	{  
		if (a[child] < a[parent])
		{
			//3.开始进行交换操作（Swap函数的调用）
			Swap(&a[child], &a[parent]);
			child = parent;//调整身份继续向上进行下一次（循环可能出现）可能出现的比较
			parent = (child - 1) / 2;//原来的父亲变成孩子（父亲赋值给孩子），然后原来的父亲变成了前一个祖先。
		}
		else
		{
			break;// 满足小根堆的结构
		}
	}
}

//（3） push堆的操作
void HPPush(HP* php,HPDataType x)//传入堆，插入一个数据x
{
	assert(php);

	//1. 先判断空间是否足够
	//1. 若空间不够（说明之前有空间的，即使没有空间，capacity也等于size），则进行增容操作
	if (php->capacity == php->size)//if (php->capacity == php->size == 0)，而不是判断是否为空
	{

		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("malloc fail");
			exit(1);//return;//直接返回也可
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	//2. 开始插入数据
	php->a[php->size] = x;//
	php->size++;

	//3. 调用向上调整函数
	AdjustUp(php->a, php->size-1);//为什么第2个参数是size-1而不是size?----要弄清楚size的位置：最后一个数据位置的下标+1
}

//（7）向下调整算法
void AdjustDown(HPDataType* a, int n, int parent)//从parent根节点开始调整
{
	//1.先确定（假设法）用哪个孩子与父亲做比较
	//假设左孩子比右孩子小
	int child = parent * 2 + 1;//根据父节点找到子节点
	while (child < n)//child>=n时，说明该孩子已经不存在了 
	{
		//找出小的孩子
		//if (a[child + 1] < a[child])//此写法存在风险：左孩子<n没有风险，但是右孩子+1就可能存在风险
		if (child + 1 < n && a[child + 1] < a[child])
		{
			//如果右孩子比左孩子小：假设不成立，修改假设的内容：
			++child;//child右移变成右孩子
		}
		//2.小孩子与父亲做比较
		if (a[child] < a[parent])
		{
			Swap(&a[parent], &a[child]);
			//3.交换后进行父亲与孩子的调整
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//（6）Pop删除数据——要求删除堆顶即根位置的数据，删除末尾数据没有意义
void HPPop(HP* php)//logN
{
	assert(php);
	assert(php->size > 0);
	//1.将堆顶元素和最后一个元素进行交换
	Swap(&php->a[php->size-1], &php->a[0]);//尾元素：a[size-1]
	//2.删除堆中的最后一个元素的数据---怎么删啊?---删除数组中最后一个元素的数据
	//free(php->a[php->size-1]);//不能使用free，因为内存申请的空间必须一块儿释放，而不是一部分一部分地释放的
	php->size--;//php->size -= 1;
	//3.向下调整算法的运用
	AdjustDown(php->a, php->size, 0);
}

//（7）获取堆顶的数据（返回堆顶元素）
HPDataType HPTop(HP* php)//top-k问题
{
	//断言：
	assert(php);
	assert(php->size > 0);//作用？？
	return php->a[0];
}
//（8）判空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}



#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

int main()
{ 
	int a[] = { 4,2,8,1,5,6,9,7 };//这个数组现在还不是堆，需要将其变成一个堆（一个个地去插入）
	HP hp;//1.创建一个堆hp
	//2.初始化
	HPInit(&hp);
	//3.建堆（需要插入多个数据，因此，需要多次调用HPPush函数）
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);//建堆的同时 调整了堆的结构
	}
	//1. 打印堆中的所有数据
	//while (!HPEmpty(&hp))
	//{
	//	printf("%d ", HPTop(&hp));//获取到堆顶的数据
	//	HPPop(&hp);
	//}
	//如果是找堆里的最大的前k个数据
	int k = 0;
	scanf("%d", &k);
	while (k--)
	{
		printf("%d ", HPTop(&hp));
		HPPop(&hp);
	}
	printf("\n");

	return 0;
}

喜欢的uu记得三连支持哦！
在这里插入图片描述

Harper·Lee
关注
  • 55
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 25
    评论
专栏目录
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值