数据结构第十一弹---堆

最新推荐文章于 2024-07-25 11:43:17 发布
最新推荐文章于 2024-07-25 11:43:17 发布
阅读量1.5k 收藏 52
点赞数 60
分类专栏： 数据结构初阶详解 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75584283/article/details/135325855
版权
本文详细介绍了堆的数据结构、性质，包括向下调整和向上调整算法，以及在C语言中的实现步骤，涉及初始化、销毁、插入、删除堆顶等操作。
摘要由CSDN通过智能技术生成

堆

1、堆的概念及结构

堆就是以二叉树的顺序存储方式来存储元素，同时又要满足父亲结点存储数据都要大于等于儿子结点存储数据（也可以是父亲结点数据都要小于等于儿子结点数据）的一种数据结构。堆只有两种即大堆和小堆，大堆就是父亲结点数据大于等于儿子结点数据，小堆则反之。

在这里插入图片描述

2、堆的性质

堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

3、堆的调整算法

3.1、向下调整算法

现在我们给出一个数组，逻辑上看作一棵完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。

在这里插入图片描述
但是，使用向下调整算法需要满足一个前提：
 若想将其调整为小堆，那么根结点的左右子树必须都为小堆。
 若想将其调整为大堆，那么根结点的左右子树必须都为大堆。
 
 在这里插入图片描述

向下调整算法的基本思想（小堆）：
 1.从根结点处开始，选出左右孩子中值较小的孩子。
 2.让小的孩子与其父亲进行比较。
 若小的孩子比父亲还小，则该孩子与其父亲的位置进行交换。并将原来小的孩子的位置当成父亲继续向下进行调整，直到调整到叶子结点为止。
 若小的孩子比父亲大，则不需处理了，调整完成，整个树已经是小堆了。

代码实现

void Swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp = *a;
	*a = *b;
	*b = tmp;
}
void AdjustDown(HPDataType* a, int size, int parent)
{
	//1.假设左孩子为小的数据
	int child = parent * 2 + 1;
	while (child < size)
	{
	//2.如果左孩子>右孩子 则将右孩子赋值
	//有可能只有左孩子 所以加条件
	//以下未有左右孩子且左孩子>右孩子情况，则将child++
		if (child + 1 < size && a[child] > a[child + 1])
		{
			child++;
		}
		//3.将孩子与父亲进行比较 如果孩子小则交换
		//然后将父亲和孩子移动到下一个位置
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

交换数值函数注意
在这里插入图片描述
使用堆的向下调整算法需要满足其根结点的左右子树均为大堆或是小堆才行，那么如何才能将一个任意树调整为堆呢？
 答案很简单，我们只需要从倒数第一个非叶子结点开始，从后往前，按下标，依次作为根去向下调整即可。
 在这里插入图片描述

向下调整算法的时间复杂度：
在这里插入图片描述

根据计算可知，向下调整算法的时间复杂度为O(N)。

3.2、向上调整算法

当我们在一个堆的末尾插入一个数据后，需要对堆进行调整，使其仍然是一个堆，这时需要用到堆的向上调整算法。

在这里插入图片描述

向上调整算法的基本思想（小堆）：
 1.将目标结点与其父结点比较。
 2.若目标结点的值比其父结点的值小，则交换目标结点与其父结点的位置，并将原目标结点的父结点当作新的目标结点继续进行向上调整。若目标结点的值比其父结点的值大，则停止向上调整，此时该树已经是小堆了。

在这里插入图片描述

但是，使用向上调整算法需要满足一个前提：
 若想将其调整为小堆，那么原来的数据为小堆。
 若想将其调整为大堆，那么原来的数据为大堆。
 
 代码实现

void Swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp = *a;
	*a = *b;
	*b = tmp;
}
void AdjustUp(HPDataType* p, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (p[parent] > p[child])
		{
			Swap(&p[parent], &p[child]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

向上调整算法时间复杂度
在这里插入图片描述

因此向上调整算法的时间复杂度为O(N*logN)。

4、堆的实现

实现一个数据结构的第一步需要创建一个工程。(下图为vs 2022)
在这里插入图片描述
Heap.h（堆的类型定义、接口函数声明、引用的头文件）
Heap.c（堆接口函数的实现）
test.c （主函数、测试顺序表各个接口功能）

4.1、头文件包含和结构定义

以下是实现堆可能用到的头文件。

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

堆的结构定义

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;//存放数据的动态数组
	int size;     //有效数据个数
	int capacity; //数组容量
}HP;

4.2、初始化

void HeapInit(HP* php)
{
	assert(php);//断言避免出现空指针
	php->a = NULL;
	php->capacity = php->size = 0;
}

4.3、销毁

void HeapDestory(HP* php)
{
	assert(php);
	free(php->a);//释放动态数组
	php->size = php->capacity = 0;
}

4.4、插入数据

插入数据的同时需要保证插入之后的数据依然是堆，由于插入数据之前的所有数据是堆，可以使用向上调整数据进行调整。
在这里插入图片描述

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//1.检查容量
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType)*newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	//2.插入数据
	php->a[php->size] = x;
	php->size++;

	//3.调整数据
	AdjustUp(php->a, php->size-1);
}

测试
在这里插入图片描述

4.5、删除数据 删除堆顶

删除堆顶元素，首先需要有数据，通过断言判断，有数据的情况下先将堆顶元素和数组尾的数据进行交换，然后将size–，因为除了堆顶元素不满足堆结构之外，其他都满足，所以使用向下调整数据算法。

void HeapPop(HP* php)
{
	assert(php);
	//有数据才删除
	assert(php->size > 0);
	//1.将首位数据交换
	Swap(&php->a[0], &php->a[php->size - 1]);
	//2.删除尾数据
	php->size--;
	//3.向下调整
	AdjustDown(php->a, php->size, 0);
}

测试
在这里插入图片描述

4.6、获取堆顶元素

根据堆的定义可知，堆顶元素就是数组首元素，返回首元素即可。

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}

测试
在这里插入图片描述

4.7、获取有效数据个数

根据堆的结构设计，size就是堆的有效数据个数，返回size即可。

size_t HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

测试
在这里插入图片描述

4.8、判断是否为空

根据堆结构的设计，size代表堆的有效数据个数，size等于0则为空，不等于0则不为空。

bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

在这里插入图片描述

5、代码汇总

5.1、Heap.h

#pragma once     //防止头文件重复包含
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;//存放数据的数组
	int size;     //有效数据个数
	int capacity; //数组容量
}HP;

//初始化
void HeapInit(HP* php);
//销毁
void HeapDestory(HP* php);
//插入数据
void HeapPush(HP* php, HPDataType x);
//删除数据 删除堆顶数据
void HeapPop(HP* php);
//取堆顶元素
HPDataType HeapTop(HP* php);
//获取有效数据个数
size_t HeapSize(HP* php);
//判断是否为空
bool HeapEmpty(HP* php);
//两个元素交换
void Swap(HPDataType* a, HPDataType* b);

//向上调整数据 小堆
void AdjustUp(HPDataType* p, int child);
//向下调整算法 小堆
void AdjustDown(HPDataType* a, int size, int parent);

5.2、Heap.c

#define _CRT_SECURE_NO_WARNINGS
#include "Heap.h"
//初始化 小堆
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}
//销毁
void HeapDestory(HP* php)
{
	assert(php);
	free(php->a);
	php->size = php->capacity = 0;
}
void Swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp = *a;
	*a = *b;
	*b = tmp;
}
log N
//向上调整数据 小堆
void AdjustUp(HPDataType* p, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (p[parent] > p[child])
		{
			Swap(&p[parent], &p[child]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}


//插入数据
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//1.检查容量
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType)*newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	//2.插入数据
	php->a[php->size] = x;
	php->size++;

	//3.调整数据
	AdjustUp(php->a, php->size-1);
}

//向下调整算法 小堆
void AdjustDown(HPDataType* a, int size, int parent)
{
	//1.假设左孩子为小的数据
	int child = parent * 2 + 1;
	while (child < size)
	{
	//2.如果左孩子>右孩子 则将右孩子赋值
	//有可能只有左孩子 所以加条件
	//以下未有左右孩子且左孩子>右孩子情况，则将child++
		if (child + 1 < size && a[child] > a[child + 1])
		{
			child++;
		}
		//3.将孩子与父亲进行比较 如果孩子小则交换
		//然后将父亲和孩子移动到下一个位置
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}


//删除数据 删除堆顶数据
void HeapPop(HP* php)
{
	assert(php);
	//有数据才删除
	assert(php->size > 0);
	//1.将首位数据交换
	Swap(&php->a[0], &php->a[php->size - 1]);
	//2.删除尾数据
	php->size--;
	//3.向下调整
	AdjustDown(php->a, php->size, 0);
}
//取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}
size_t HeapSize(HP* php)
{
	assert(php);
	return php->size;
}
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

总结

本篇博客就结束啦，谢谢大家的观看，如果公主少年们有好的建议可以留言喔，谢谢大家啦！

小林熬夜学编程
关注
  • 60
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 25
    评论
专栏目录
【愚公系列】2023年10月 数据结构(十三)-堆
时光隧道
10-01 4万+
数据结构是计算机科学中的一个重要概念，它描述了数据之间的组织方式和关系，以及对这些数据的访问和操作。常见的数据结构有：数组、链表、栈、队列、哈希表、树、堆和图。数组（Array）：是一种线性数据结构，它将一组具有相同类型的数据元素存储在一起，并为每个元素分配一个唯一的索引。数组的特点是具有随机访问的能力。链表（Linked List）：也是一种线性数据结构，它由一系列的节点组成，每个节点包含数据和指向下一个节点的引用。链表的特点是可以动态地插入或删除节点，但访问某个节点时需要从头开始遍历。
2005-数据结构与算法-期末试题1
08-03
5. **堆排序**：堆是一种特殊的树形数据结构，用于实现优先队列。调整分支结点的时间复杂度为O(logn)，整个堆排序过程的时间复杂度为O(nlogn)。 6. **有向图的邻接矩阵**：邻接矩阵用于表示图中顶点之间的连接关系...
【数据结构】第十八弹---C语言实现堆排序
熬夜学习编程的小林的博客
06-20 1424
堆排序基本思想，向下向上调整算法，堆排序代码实现及时空复杂度
数据结构第十二弹---堆的应用
熬夜学习编程的小林的博客
01-10 2394
要学习堆排序，首先要学习堆的向下调整算法，因为要用堆排序，你首先得建堆，而建堆需要执行多次堆的向下调整算法。 但是，使用向下调整算法需要满足一个前提：  若想将其调整为小堆，那么根结点的左右子树必须都为小堆。  若想将其调整为大堆，那么根结点的左右子树必须都为大堆。   使用堆的向下调整算法需要满足其根结点的左右子树均为大堆或是小堆才行，那么如何才能将一个任意树调整为堆呢？ 建堆代码 根据上一弹堆的向下调整算法时间复杂度计算可知，建堆的时间复杂度为O(N)。 那么堆建好后，如何进行堆排序呢？ 步骤如下：为什
数据结构十弹---二叉树
熬夜学习编程的小林的博客
01-08 1416
1.有一个特殊的结点，称为根结点，根节点没有前驱结点。 2.除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。 因此，树是递归定义的。 注意： 1.树形结构中，子树之间不能有交集，否则就不是树形结构。 2.除了根结点外，每个结点有且仅有一个父结点。 3.一颗N个结点的树有N-1条边。1.节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为
数据结构-第4节-二叉树
qq_45113223的博客
04-19 1400
1.树概念及结构 1.1.树的概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 ·有一个特殊的结点，称为根结点，根节点没有前驱结点 ·除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继 ·因此，树是...
【数据结构篇C++实现】- 树
陈七的博客，学习知识分享，期待与大家的交流
03-27 3155
数据结构图的相关概念，知识点归纳
【Java---数据结构】优先级队列 PriorityQueue（堆）
.很冷的博客
04-17 2080
一、二叉树的顺序存储 1、存储方式 使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。 一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。 这种方式的主要用法就是堆的表示。 ...
数据结构实验——实验三--栈实验
qq_65814357的博客
06-10 2815
一、 实验任务1.1 顺序栈实验任务(1)利用顺序栈实现将10进制数转换为x进制数，2
常用数据结构代码--C语言版（笔记）
热门推荐
BLAZAR'
10-19 3万+
代码目录： 第3章、线性表 01线性表顺序存储_List 02线性表链式存储_LinkList 03静态链表_StaticLinkList 第4章、栈与队列 01顺序栈_Stack 02两栈共享空间_DoubleStack 03链栈_LinkStack 04斐波那契函数_Fibonacci 05顺序队列_Queue 06链队列_LinkQueue 第5章、串 0...
数据结构第六次课-栈和队列B.ppt
12-05
栈是一种“后进先出”（LIFO，Last In First Out）的数据结构，类似于现实生活中堆叠物品的方式，最后放入的物品最先被取出。栈的主要运算是压栈（将元素添加到栈顶）和弹栈（移除并返回栈顶的元素）。栈在编程中常...
自考数据结构导论试题2006-10
05-05
19. 栈是后进先出（LIFO）的数据结构，只能在栈顶进行插入（压栈）和删除（弹栈）操作。 20. 循环队列队空的标志是front==rear。 21. 三个结点可以构成5种不同的形态的二叉树，包括一棵空树、一棵只有一个根节点的...
数据结构-Python语言描述试卷(一)附答案.docx
06-13
栈是一种“后进先出”（LIFO）的数据结构，只允许在一端（称为栈顶）进行插入（压栈）和删除（弹栈）操作。队列则是“先进先出”（FIFO）的数据结构，数据的插入（入队）在队尾，删除（出队）在队头。两者都限制了...
软考-软件设计师精华知识点笔记【第三章 数据结构】
05-31
【第三章 数据结构】是软件设计师考试中的一个重要章节，涵盖了计算机科学中关于组织和操作数据的核心概念。在这一章的学习中，考生需要深入理解数据结构的类型、特性以及它们在实际编程中的应用。以下是该章节的...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 162
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 213
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 292
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 412
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小林熬夜学编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值