数据结构之堆

已于 2022-11-17 14:27:47 修改
阅读量274 收藏
点赞数
文章标签： 数据结构 开发语言 c语言 算法
于 2022-11-17 00:15:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73592835/article/details/127857567
版权

堆(Heap)是计算机科学中一类特殊的数据结构，是最高效的优先级队列。堆通常是一个可以被看做一棵完全二叉树的数组对象。

一、堆是什么？

堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：

  • 堆中某个结点的值总是不大于或不小于其父结点的值；

  • 堆总是一棵完全二叉树。

将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。

大堆：树中一个数及其子树中，任何一个父亲都大于等于孩子

大堆：树中一个数及其子树中，任何一个父亲都大于等于孩子

二、大小堆的代码实现

1.大堆的代码实现

大堆的头文件   heap.h

#define _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#define MAX 10
typedef int ElemType;
typedef struct heap{
	ElemType* data;
	int size;
	int max;
}He;
void heapInit(He *p);  //初始化
void heapPushBig(He *p, ElemType x);  //插入
void heapPopBig(He *p);   //删除
void heapPrintf(He *p);  //打印
void heapDestroy(He *p);  //销毁
bool heapEmpty(He *p);    //判空

大堆的函数程序文件   heap.c

#define _CRT_SECURE_NO_WARNINGS  1
#include"heap.h"
void heapInit(He *p){          //初始化
	p->data = (ElemType *)malloc(MAX*sizeof(ElemType));
	p->size = 0;
	p->max = MAX;
}
void Swap(ElemType *ps, ElemType *py){   //交换值函数
	ElemType tem = *ps;
	*ps = *py;
	*py = tem;
}
void heapPushBig(He *p, ElemType x){  //大堆插入
	assert(p);
	if (p->size == p->max){
		ElemType *tem = realloc(p->data, p->max * 2 * sizeof(ElemType));
		if (tem == NULL){
			printf("realloc fail\n");
			exit(-1);
		}
		p->data = tem;
		p->max *= 2;
	}
	p->data[p->size] = x;
	p->size++;
	AdjustUpBig(p->data, p->size - 1);   //上调
}
void AdjustUpBig(ElemType *a,int child){       //大堆中的向上调整，child为新插入元素下标
	assert(a);
	int parent = (child - 1) / 2;    //父节点下标
	while (child>0){
		if (a[child] > a[parent]){   //交换值
			Swap(&a[child], &a[parent]);
			child = parent;          //孩子结点下标变为父节点下标
			parent = (child - 1) / 2;     //父节点下标变为其父节点下标
		}
		else{
			break;
		}
	}
}
oid heapPopBig(He *p){     //大堆删除，删除根节点
	assert(p);
	assert(!heapEmpty(p));
	Swap(&p->data[0], &p->data[p->size - 1]);  //交换堆顶堆低元素
	p->size--;
	AdjustDownBig(p->data, p->size, 0);      //向下调整
}
void AdjustDownBig(ElemType *a, int n, int parent){  //大堆向下调整
	int child = parent * 2 + 1;
	while (child<n){
		if (child + 1<n && a[child + 1]>a[child]){   //选出左右孩子大的那个，注意防止孩子下标越界
			child++;
		}
		if (a[child] > a[parent]){      //在大堆中，如果孩子比父亲大，交换值
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else{     //当父亲比孩子大，退出函数
			break;
		}
	}
}
void heapPrintf(He *p){   //打印
	for (int i = 0; i < p->size; i++){
		printf("%d ", p->data[i]);
	}
	printf("\n");
}
bool heapEmpty(He *p){   //判空
	assert(p);
	return p->size == 0;
}
void heapDestroy(He *p){       //销毁
	assert(p);
	free(p->data);
	p->max = p->size = 0;
}

 大堆的测试程序文件 test.c

#define _CRT_SECURE_NO_WARNINGS  1
#include"heap.h"
int main(){
	int a[] = { 70, 56, 30, 25, 15, 10, 75 };
	He ps;
	heapInit(&ps);
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++){
		heapPushBig(&ps, a[i]);
	}
	heapPrintf(&ps);
	heapPopBig(&ps);
	heapPrintf(&ps);
	heapPopBig(&ps);
	heapPrintf(&ps);
	heapDestroy(&ps);
	return 0;
}

程序运行得到的结果如下 

2.小堆的代码实现

小堆的头文件   heap.h

#define _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#define MAX 10
typedef int ElemType;
typedef struct heap{
	ElemType* data;
	int size;
	int max;
}He;
void heapInit(He *p);  //初始化
void heapPushSmall(He *p, ElemType x);  //插入
void heapPopSmall(He *p);   //删除
void heapPrintf(He *p);  //打印
void heapDestroy(He *p);  //销毁
bool heapEmpty(He *p);    //判空

 小堆的函数程序文件   heap.c

#define _CRT_SECURE_NO_WARNINGS  1
#include"heap.h"
void heapInit(He *p){          //初始化
	p->data = (ElemType *)malloc(MAX*sizeof(ElemType));
	p->size = 0;
	p->max = MAX;
}
void Swap(ElemType *ps, ElemType *py){   //交换值函数
	ElemType tem = *ps;
	*ps = *py;
	*py = tem;
}
void heapPushSmall(He *p, ElemType x){  //小堆插入
	assert(p);
	if (p->size == p->max){
		ElemType *tem = realloc(p->data, p->max * 2 * sizeof(ElemType));
		if (tem == NULL){
			printf("realloc fail\n");
			exit(-1);
		}
		p->data = tem;
		p->max *= 2;
	}
	p->data[p->size] = x;
	p->size++;
	AdjustUpSmall(p->data, p->size - 1);
}
void AdjustUpSmall(ElemType *a, int child){       //小堆中的向上调整，child为新插入元素下标
	assert(a);
	int parent = (child - 1) / 2;    //父节点下标
	while (child>0){
		if (a[child] < a[parent]){   //交换值
			Swap(&a[child], &a[parent]);
			child = parent;          //孩子结点下标变为父节点下标
			parent = (child - 1) / 2;     //父节点下标变为其父节点下标
		}
		else{
			break;
		}
	}
}
void heapPopSmall(He *p){     //小堆删除，删除根节点
	assert(p);
	assert(!heapEmpty(p));
	Swap(&p->data[0], &p->data[p->size - 1]);  //交换堆顶堆低元素
	p->size--;
	AdjustDownSmall(p->data, p->size, 0);      //向下调整
}
void AdjustDownSmall(ElemType *a,int n,int parent){  //小堆向下调整
	int child = parent * 2 + 1;
	while (child<n){
		if (child + 1<n && a[child + 1]<a[child]){   //选出左右孩子小的那个，注意防止孩子下标越界
			child++;
		}                        
		if ( a[child] < a[parent]){      //在小堆中，如果孩子比父亲小，交换值
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent*2+1;
		}
		else{     //当父亲比孩子小，退出函数
			break;
		}
	}
}

 小堆的测试程序文件 test.c

#define _CRT_SECURE_NO_WARNINGS  1
#include"heap.h"
int main(){
int a[] = { 70, 56, 30, 25, 15, 10, 75 };
	He ps;
	heapInit(&ps);
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++){
		heapPushSmall(&ps, a[i]);
	}
	heapPrintf(&ps);
	heapPopSmall(&ps);
	heapPrintf(&ps);
	heapPopSmall(&ps);
	heapPrintf(&ps);
	heapDestroy(&ps);
	return 0;
}

小堆的运行结果截图 

三、代码细节分析

堆的逻辑结构是完全二叉树，可用顺序表储存，而在完全二叉树的顺序存储中，设父亲下标是parent，则左右孩子下标就是parent*2+1，parent*2+2，假如知道孩子下标child，不论左右孩子，其父亲下标parent=(child-1)/2.

以大堆为例，插入就是在顺序表末尾插入一个元素，而在逻辑结构中，就是完全二叉树新增一个叶子节点，因为是大堆，所以要保持大堆的性质(任何一个父节点的值都大于等于孩子的值），所以要进行调整，插入的之后调整称之为向上调整

 代码基本思路就是新插入的节点与父亲比较，假如孩子的值大于父亲，父亲孩子值就互换，往上依次这样比较，直到父亲大于孩子或者根节点比较完

void AdjustUpBig(ElemType *a,int child){       //大堆中的向上调整，child为新插入元素下标
	assert(a);
	int parent = (child - 1) / 2;    //父节点下标
	while (child>0){
		if (a[child] > a[parent]){   //交换值
			Swap(&a[child], &a[parent]);
			child = parent;          //孩子结点下标变为父节点下标
			parent = (child - 1) / 2;     //父节点下标变为其父节点下标
		}
		else{
			break;
		}
	}
}

删除堆是删除堆顶数据，将堆顶的数据和最后的数据一换，然后删除最后的元素，再进行向下调整的算法

代码基本思路就是交换完之后依然要保证堆的性质，所以换完之后的根节点与孩子相比较，假如孩子比父亲大，就互换，往下依次这样比较，直到某一个孩子小于父亲或者直到下面的都调整完

n为元素个数

void AdjustDownBig(ElemType *a, int n, int parent){  //大堆向下调整
	int child = parent * 2 + 1;
	while (child<n){
		if (child + 1<n && a[child + 1]>a[child]){   //选出左右孩子大的那个，注意防止孩子下标越界
			child++;
		}
		if (a[child] > a[parent]){      //在大堆中，如果孩子比父亲大，交换值
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else{     //当父亲比孩子大，退出函数
			break;
		}
	}
}

四、堆的应用

1.堆排序

因为可把数组看做完全二叉树，所以不用再写堆的数据结构，把数组直接构建成堆，以把数组建成大堆为例，主要有两种方法

1.把数组第一个元素直接看做堆，然后插入，进行向上调整，依次类推，直到数组输入完所有元素

代码实现

int a[] = { 70, 56, 30, 25, 15, 10, 75 };
int n = sizeof(a) / sizeof(a[0]);
for (int i = 1; i < n; ++i){   //输入元素并进行调整
	AdjustUpBig(a, i);  
}

2.把整个数组看成一个堆，不过这个堆现在是无序的（并不能称为堆，为了方便大家理解），我们现在要做的就是把这个堆调整为大堆，从各个子树调整起，从最下面的子树开始调整，各个子树依次调整成大堆，因为叶子节点不用调整，所以就是最后叶子节点的父亲开始调整，因为顺序存储中左右节点的下标相差一，所以4调整完之后就是3，依次类推

 代码实现

int a[] = { 70, 56, 30, 25, 15, 10, 75 };
int n = sizeof(a) / sizeof(a[0]);
for (int i = (n - 1 - 1) / 2; i >= 0; --i){   //i为最后叶子节点的父亲
	AdjustDownBig(a,n,i);
}
for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i){
	printf("%d ", a[i]);
}

这个快速构造堆讲完后，就可以直接用数组快速构造了，不用写那么多函数了，掌握这个技能是很重要的。

3.堆排序的实现

如果是升序的话，我们脑子里第一想法肯定是用小堆，首先返回小堆的根节点，然后删除堆，依次类推。不过这样每次删除完根节点之后又要构造堆，时间复杂度比较高，没有充分体现出堆的优势，所以我们可以考虑用大堆，我们可以将根节点与最后元素互换，然后从新的根节点开始，开始调整（因为此时最后的那个元素值最大，不用考虑它，所以调整的范围减一），以此类推。操作类似于堆删除

代码实现如下

for (int end = n - 1; end > 0;--end){
	Swap(&a[0], &a[end]);
	AdjustDownBig(a, end, 0);
}

此代码段运行结果如下

for (int i = (n - 1 - 1) / 2; i >= 0; --i){   //i为最后叶子节点的父亲
	AdjustDownBig(a,n,i);
}
for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i){
	printf("%d ", a[i]);
}
printf("\n");
for (int end = n - 1; end > 0;--end){
	Swap(&a[0], &a[end]);
	AdjustDownBig(a, end, 0);
}
for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i){
	printf("%d ", a[i]);
}

 降序的话建小堆，跟上面思想一样的

2.TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
1. 用数据集合中前K个元素来建堆
前k个最大的元素，则建小堆,因为在小堆中，越大的元素一般都在下面，最后剩下的元素就是前k个最大的元素
前k个最小的元素，则建大堆，因为在大堆中，越小的元素一般在下面，最后剩下的元素就是前k个最小的元素
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

代码实现举例

void DealTopK(int* a, int n, int k){
		for (int i = (k - 1 - 1) / 2; i >= 0; i--){   //快速建造一个堆
				AdjustDownSmall(a, k, i);
			}
	for (int i = k; i < n; ++i){
		if (a[i]>a[0]){     //符合条件的交换值，然后向下调整
			a[0] = a[i];                  
			AdjustDownSmall(a, k, 0);
		}
	}
}
void TestTopk()
{
	int k = 10;
	int n = 10000;
	int* a = (int*)malloc(sizeof(int)*n);
	srand((unsigned int)time(0));
	for (int i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;   //把不小于100000的数保存到数组
	}
	a[8] = 1000000 + 1;
	a[1265] = 1000000 + 2;
	a[988] = 1000000 + 3;
	a[635] = 1000000 + 4;
	a[985] = 1000000 + 5;
	a[2003] = 1000000 + 6;
	a[11] = 1000000 + 7;
	a[99] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;
	DealTopK(a, n, 10);
	for (int i = 0; i < k; i++){
		printf("%d ", a[i]);
	}
}

运行结果如下

叫我小可爱就好
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构之堆1
08-03
【数据结构之堆1】是关于数据结构中堆的详细解析，主要涵盖了堆的概念、分类、常见操作以及在LeetCode等刷题平台上的应用。堆作为一种特殊的完全二叉树，通常用于实现优先队列，以高效地进行最大值或最小值的查找、...
【数据结构】堆
CNF的博客
03-29 58
快速上手堆
堆(Head)
qq_42646178的博客
08-15 99
简介 堆是一种特殊的数据结构，满足以下两个性质： 堆中结点的值总是小于或者大于父节点的值 堆总是一颗完全二叉树 堆是一颗完全二叉树，在这棵树中，所有的父节点都满足大于等于其子节点的堆叫大根堆，所有的父节点都小于子节点的叫小根堆 堆虽然是一棵树但是一般存值存在数组中，父节点和子节点的关系通常通过下标来确定 实现 思路：如下图所示，当编号从零开始的时候：左孩子：（i + 1) * 2 - 1 右孩子： (i - 1) * 2 父节点：(i - 1) / 2。本次创建的是小根堆。 public cla
堆实现，堆排序和TopK问题
qq_53893431的博客
04-08 1136
文章目录@[toc]一.二叉树的存储结构1.顺序存储2.链式存储二、堆的概念和结构三、堆的实现堆的头文件四、测试堆和二叉树堆的实现堆的应用image-20220408150923880 一.二叉树的存储结构 二叉树一般可以使用两种结构存储，一种顺序结构，一种是链式结构 1.顺序存储 顺序结构存储就是使用数组来存储，一般只适用于完全二叉树，因为不是完全二叉树会有空间上的浪费。而现实中使用中只有堆才使用数组来存储。二叉树的顺序存储在物理上是一个数组，在逻辑上是一棵二叉树。 顺序结构适用于完全二叉树 2..
【C++】STL之heap（堆）
qq_36367326的博客
03-27 2345
转自：https://www.cnblogs.com/MrLiuZF/p/13498631.html 1、误区！ 1、堆排序排完后的堆和大顶堆、小顶堆不是一个概念！ 2、堆分为大顶堆和小顶堆，即要么大顶堆（大根堆/最大堆），要么小顶堆。 3、对于堆，堆的根节点一定是堆中所有节点的最大值或者最小值。 4、大顶堆只是说这个堆总每一个节点满足：每一个节点大于或者等于其左右娃。并非这个堆一定是从大到小的序列。 5、所以才必须要有堆排序呀！堆排序排完了之后的，才一定是一个有序的序列。 6、堆实际上是用数组或者vect
【数据结构】堆（Heap）
最新发布
Elena's Blog
08-14 2966
就可以建成一个 (大 / 小) 堆。我们把数组中的第一个元素看作是一个堆剩余的元素依次插入到这个堆中。这跟堆的插入接口原理相同，就是向上调整。如果堆的创建过程使用向上调整算法，那么每次插入一个新元素时都需要进行一次向上调整操作，以确保新插入的元素能够满足堆的性质。【时间复杂度】假设堆中已经有 n 个元素，那么堆的高度 h = log₂(n+1)，在插入一个新元素的过程中，需要进行的向上调整操作次数为 h-1，则 h = log₂(n+1) - 1，
数据结构之堆详解
09-04
堆，作为一种特殊的数据结构，是实现优先队列的典型数据结构。它通常表现为一棵完全二叉树，且具有以下特性：对于大顶堆，每个父节点的值都大于或等于其子节点的值；对于小顶堆，父节点的值小于或等于子节点的值。...
C语言数据结构之堆排序源代码
12-25
本文实例为大家分享了C语言堆排序源代码，供大家参考，具体内容如下 1. 堆排序 堆排序的定义及思想可以参考百度百科： 用一句概括，堆排序就是一种改进的选择排序，改进的地方在于，每次做选择的时候，不单单把最大...
数据结构 堆
08-17
堆的实现，能够进行插入建堆，插入，删除，判空等操作
C++最小堆和最大堆实现
weixin_54720578的博客
03-15 824
最大最小堆在c++中相关的函数是：它们包含在头文件中1）make_heap（建堆）在容器范围内，就地建堆，保证最大(小)值在所给范围的最前面，其他值的位置不确定。可以有两个参数，也可以有三个参数，前两个参数是指向开始元素的迭代器和指向结束元素的下一个元素的迭代器。第三个参数（谓词）是可选的，不选默认大顶堆。我们可以自定义比较函数来设定小顶堆2）pop_heap（取出）将堆顶(所给范围的最前面)元素移动到所给范围的最后，并且将新的最大(小)值置于所给范围的最前面。
链表实现堆栈（头文件）
05-18
这个头文件里面定义了一个栈的头文件，包括入栈、退栈、访问栈底栈顶、输出栈等成员函数
C++ 二叉堆头文件
Silence的程序实验室
04-13 931
// binaryHeap.h -- 2011-08-28-22.57 // Purpose: // Define a class "binaryHeap". // Declare methods of the class, and define element member. #include class binaryHeap { public: typedef struct node
12.2 - 每日一题 - 408
yanlei233的博客
12-02 561
每日一句：真正的坚韧，应该是哭的时候要彻底，笑的时候要开怀，说的时候要淋漓尽致，做的时候要毫不犹豫。 数据结构 1.以下序列是堆的是 。（南京航空航天大学 2011年） A．{75,65,30,15,25,45,20,10} B．{75,65,45,10,30,25,20,15} C．{75,45,65,30,15,25,20,10} D．{75,45,65,10,25,30,20,15} 答案：C 解析：先把每个序列写成完全二叉树的样子，即序列的第一个元素作为完全二叉树的根节点，序列的第二
认真学习数据结构之堆
小小默：进无止境
10-10 2364
# 【1】什么是堆？ 堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质： * 堆中某个结点的值总是不大于(大顶堆)或不小于其父结点的值(小顶堆)； * 堆总是一棵完全二叉树。 将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。 堆是非线性数据结构，相当于一维数组，有两个直接后继。 堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。 ![在这里插入图片
【数据结构】堆-C语言版
局部变量和全局变量
03-03 1589
堆的性质： （1）堆中某个结点的值总是不大于或不小于其父结点的值； （2）堆总是一棵完全二叉树。
STL之heap相关操作算法
JXH_123的专栏
06-26 2366
堆（heap）是一种非常重要的数据结构（这里我们讨论的是二叉堆），它是一棵满足特定条件的完全二叉树，堆的定义如下： 堆是一棵树完全二叉树，对于该完全二叉树中的每一个结点x，其关键字大于等于(或小于等于）其左右孩子结点，而其左右子树均为一个二叉堆。
二叉堆头文件C++
让阳光照进心里
08-29 1124
很久不写这东西了,昨天要写PRIM算法,于是就写了下.STL还不会写二叉堆,很悲哀啊,未来会学会的.现在,就先拿这个用咯.   贴,不多说了.刘翔就快开始了,特意来看他的. // binaryHeap.h -- 2011-08-28-22.57 // Purpose:
最常用标准库函数
ACM！荣耀之路！
01-10 3387
最常用标准库函数 标准头文件包括：                                                                          标准定义（） 文件里包含了标准库的一些常用定义，无论我们包含哪个标准头文件，都会被自动包含进来。这个文件里定义：          类型size_t（sizeof运算符的结果类型，是某个无符号整
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值