【初阶数据结构】树——二叉树——堆（中）

已于 2025-05-06 20:00:10 修改
阅读量1.1k 收藏 18
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构 c语言 算法 学习 java
于 2025-05-06 08:21:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_86630696/article/details/147050791
版权

文章目录

前言

上篇了解树和二叉树相关的概念，这篇学习一种特殊的二叉树--堆，通过认识堆来实现堆和堆的应用。

一、堆的概念与结构

如果有一个关键码的集合 K = { k0 , k1 , k2 , ...， k n−1 } ，把它的所有元素按完全二叉树的顺序存储方式存储，在一个一维数组中，并满足： K i <= K2∗ i+1 （ K i >= K2∗ i+1 且 K i <= K2∗ i+2 ）， i = 0、1、2... ，则称为小堆(或大堆)。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。
小根堆：

大根堆：

堆的特点：

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

从二叉树的性质讨论出：

对于具有 n 个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有结点从
0 开始编号，则对于序号为 i 的结点有：
1. 若 i>0 ， i 位置结点的双亲序号： (i-1)/2 ； i=0 ， i 为根结点编号，无双亲结点
2. 若 2i+1<n ，左孩子序号： 2i+1 ， 2i+1>=n 否则无左孩子
3. 若 2i+2<n ，右孩子序号： 2i+2 ， 2i+2>=n 否则无右孩子

二、堆的实现

堆的定义

由此，我们可知堆的底层是数组来实现的，则堆的结构是顺序结构，可写出堆的结构定义

typedef int HPDatatype;
//堆的结构
typedef struct Heap
{
	HPDatatype* arr;
	int size;      //有效数据个数
	int capacity; //容量
}HP;

1.初始化堆

代码解析：

先对未开辟空间的数组指针置为空，再对有效个数和容量大小都置为0.

//初始化
void HPIint(HP* php)
{
	assert(php);
	php->arr = NULL;
	php->size = php->capacity = 0;
}

2.堆的销毁

代码解析：

先判断堆是否为空，不为空先对数组进行释放再置为NULL，再对有效个数和容量大小都置为0

注：对堆开辟空间使用完后就要对堆进行销毁，避免造成空间浪费，因此要对堆进行销毁

//销毁
void HPDesTroy(HP* php)
{
	//判断堆是否为空，不为空就直接free再置空
    assert(php);
	if (php->arr)
		free(php->arr);
	php->arr = NULL;
	php->size = php->capacity = 0;
}

3.堆的插入

代码解析：

堆的插入就是在尾部进行数据插入。先判断堆是否已满，堆已满就进行 realloc 增容并更新capacity。增容后，把插入进来的数据进行重新调整，用 AdjustUp 函数对堆进行调整

//往堆中插入数据(以建小堆为例)
void HPPush(HP* php, HPDatatype x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		//增容
		int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDatatype* tmp = (HPDatatype*)realloc(php->arr, sizeof(HPDatatype) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail!\n");
			exit(1);
		}
		php->arr = tmp;
		php->capacity = newCapacity;
	}
	//插入数据
	php->arr[php->size] = x;
	//插入数据后用向上调整方法来调整成小堆或者大堆
	AdjustUp(php->arr, php->size);
	++php->size;
}

3.1向上调整算法

接下来给大家介绍AdjustUp 函数 

代码解析：

先将元素插入到堆的末尾,即最后一个孩子之后
插入之后如果堆的性质遭到破坏，将新插入结点顺着其双双亲往上调整到合适位置即可

由二叉树的性质，我们可知已知孩子结点可求父结点：Parent =(child-1)/2。在这里我们建小堆，要求孩子结点大于父结点，如果不满足就对进行交换，在让child 走到parent ，parent 走到parent 的父结点；如果满足不用交换直接跳出循环。

//向上调整算法：
void AdjustUp(HPDatatype* arr, int child)
{
	//已知子节点下标，来求父节点下标
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (arr[child] > arr[parent])//建大堆就大于
		{
			Swap(&arr[child], &arr[parent]);
			//交换后，子节点会跑到旧位置的父节点，则再求新位置的父节点
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;//如果子节点大于父节点，则不需要变化直接跳出循环
		}
	}
}

时间复杂度：

因为堆是完全⼆叉树，⽽满⼆叉树也是完全⼆叉树，此处为了简化使⽤满⼆叉树来证明(时间复杂度本来看的就是近似值，多⼏个结点不影响最终结果)
分析：
第1层， 2 0 个结点，需要向上移动0层

第2层， 2 1 个结点，需要向上移动1层
第3层， 2 2 个结点，需要向上移动2层
第4层， 2 3 个结点，需要向上移动3层
......
第h层， 2 h −1 个结点，需要向上移动h-1层
则需要移动结点总的移动步数为：每层结点个数 * 向上调整次数（第⼀层调整次数为0）

4.堆的判空

代码解析：用bool函数来判断堆是否为空

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

5.求有效个数

代码解析：直接返回有效个数即可

int HPSize(HP* php)
{
	assert(php);
	return php->size;
}

6.删除堆顶数据

代码解析：

先判断堆是否为空堆，是就返回0，不是返回有效数据；让根结点和最后一个元素进行交换，把交换后的最后一个元素删除后，再进行向下调整算法

//删除堆顶数据(以建小堆为例)
void HPPop(HP* php)
{
	assert(!HPEmpty(php));
	//交换根节点和最后一个节点，再对新的最后一个节点进行删除
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	--php->size;
	//使用向下调整算法
	AdjustDown(php->arr, 0, php->size);

}

6.1向下调整算法

代码解析：

将堆顶元素与堆中最后一个元素进行交换
删除堆中最后一个元素
将堆顶元素向下调整到满足堆特性为止

由二叉树的性质，我们可知，已知parent 结点的下标，就可求左，右孩子结点的下标，左下标：2(parent )+1=child, 右下标：2parent +2=child 。把最后一个元素删除后，这里需要建小堆，先找到孩子结点中较小的结点，把父结点和较小的孩子结点进行交换，再让父结点走到较小的孩子结点的交换前的位置，再更新孩子结点的下标；如果父结点小于孩子结点就不用交换，直接跳出循环。

//向下调整算法
void AdjustDown(HPDatatype* arr, int parent, int n)
{
	//已知父节点，求子节点又可求左右子节点
	int child = parent * 2 + 1;//左子节点
	while (child<n)
	{
		//找到最小的节点，让其与父节点进行交换，谁小谁往上调(如果是大堆，谁大谁往上调)
		if (child + 1 <n && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			//父节点走到旧的字节点下标，再求新子节点下标
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			break;
		}
	}
}

时间复杂度：

第1层， 2 0 个结点，需要向下移动h-1层
第2层， 2 1 个结点，需要向下移动h-2层
第3层， 2 2 个结点，需要向下移动h-3层
第4层， 2 3 个结点，需要向下移动h-4层
......
第h-1层， 2 h −2 个结点，需要向下移动1层

则需要移动结点总的移动步数为：每层结点个数 * 向下调整次数

注：堆的向上调整算法和向下调整算法都可以建大堆和小堆。向上调整算法主要用于堆插入，向下调整算法主要用于堆应用和堆排序。通过两者得出的时间复杂度，可知向下调整算法时间复杂度比向上调整算法复杂度好。

7.获取栈顶数据

代码解析：直接返回栈顶的数据

HPDatatype HPTop(HP* php)
{
	assert(!HPEmpty(php));
	return php->arr[0];
}

三、完整源码

Heap,h：

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

//一、用顺序结构实现完全二叉树，底层是数组
typedef int HPDatatype;
//堆的结构
typedef struct Heap
{
	HPDatatype* arr;
	int size;      //有效数据个数
	int capacity; //容量
}HP;

//初始化
void HPIint(HP* php);
//销毁
void HPDesTroy(HP* php);
//往堆中插入数据
void HPPush(HP* php, HPDatatype x);
//删除堆顶数据
void HPPop(HP* php);
//判空
bool HPEmpty(HP* php);
//求size
int HPSize(HP* php);
//获取栈顶数据
HPDatatype HPTop(HP* php);

//向上调整算法：
void AdjustUp(HPDatatype* arr, int child);
//向下调整算法
void AdjustDown(HPDatatype* arr, int parent, int n);

Heap,c：

#include"Heap.h"

//初始化
void HPIint(HP* php)
{
	assert(php);
	php->arr = NULL;
	php->size = php->capacity = 0;
}
//销毁
void HPDesTroy(HP* php)
{
	assert(php);
	//判断堆是否为空，不为空就直接free再置空
	if (php->arr)
		free(php->arr);
	php->arr = NULL;
	php->size = php->capacity = 0;
}


//交换：父节点与子节点比较，谁小谁往上调(谁大谁往上调)
void Swap(int* x, int* y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}

//向上调整算法：
void AdjustUp(HPDatatype* arr, int child)
{
	//已知子节点下标，来求父节点下标
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (arr[child] > arr[parent])//建大堆就大于
		{
			Swap(&arr[child], &arr[parent]);
			//交换后，子节点会跑到旧位置的父节点，则再求新位置的父节点
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;//如果子节点大于父节点，则不需要变化直接跳出循环
		}
	}
}

//往堆中插入数据(以建小堆为例)
void HPPush(HP* php, HPDatatype x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		//增容
		int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDatatype* tmp = (HPDatatype*)realloc(php->arr, sizeof(HPDatatype) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail!\n");
			exit(1);
		}
		php->arr = tmp;
		php->capacity = newCapacity;
	}
	//插入数据
	php->arr[php->size] = x;
	//插入数据后用向上调整方法来调整成小堆或者大堆
	AdjustUp(php->arr, php->size);
	++php->size;
}

///
//对堆进行判断是否为空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
//求size
int HPSize(HP* php)
{
	assert(php);
	return php->size;
}

//向下调整算法
void AdjustDown(HPDatatype* arr, int parent, int n)
{
	//已知父节点，求子节点又可求左右子节点
	int child = parent * 2 + 1;//左子节点
	while (child<n)
	{
		//找到最小的节点，让其与父节点进行交换，谁小谁往上调(如果是大堆，谁大谁往上调)
		if (child + 1 <n && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			//父节点走到旧的字节点下标，再求新子节点下标
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			break;
		}
	}
}

//删除堆顶数据(以建小堆为例)
void HPPop(HP* php)
{
	assert(!HPEmpty(php));
	//交换根节点和最后一个节点，再对新的最后一个节点进行删除
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	--php->size;
	//使用向下调整算法
	AdjustDown(php->arr, 0, php->size);

}

//获取栈顶数据
HPDatatype HPTop(HP* php)
{
	assert(!HPEmpty(php));
	return php->arr[0];
}

test,c：

#include"Heap.h"

void test()
{
	HP hp;
	HPIint(&hp);
	HPPush(&hp, 6);
	HPPush(&hp, 4);
	HPPush(&hp, 8);
	HPPush(&hp, 10);
	
	//HPPop(&hp);
	//HPPop(&hp);
	//HPPop(&hp);
	//HPPop(&hp);

    while (!HPEmpty(&hp))
	{
		printf("%d ", HPTop(&hp));
		HPPop(&hp);//取栈顶就要删除栈顶，不然会一直循环
	}
	HPDesTroy(&hp);
}

总结

非常感谢大家阅读完这篇博客。希望这篇文章能够为您带来一些有价值的信息和启示。如果您发现有问题或者有建议，欢迎在评论区留言，我们一起交流学习。

初阶数据结构（C语言实现）——5.5 二叉树的链式结构的实现
graceyun的博客
03-17 581
学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为。根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。
C语言初阶DS——二叉树的实现(简单易懂)
shuidaoqingyi520的博客
10-21 354
二叉树在数据结构（即DS）当中有很重要的意义，在整个初阶DS当中二叉树的难度和占比都是很大一部分的，二叉树的单独基础概念我会单独开一篇文章去讲述，同时这样也方便大家不用往下划找的头疼，废话不多说我们立刻开始。最后我们完成所有二叉树的内容实现，我们把所有的二叉树的内容都在下面assert(a);assert(pi);(*pi)++;else");exit(-1);//赋值(*pi)++;//下标+1if (root!return 0;
【初阶数据结构】树——二叉树（上）
2402_86630696的博客
04-21 736
本篇带大家学习一种非线性数据结构——树，简单认识树和二叉数以及了解二叉树的存储结构。一、树希望这篇文章能够为您带来一些有价值的信息和启示。如果您发现有问题或者有建议，欢迎在评论区留言，我们一起交流学习。
【初阶数据结构】——二叉树OJ练习
m0_70980326的博客
01-17 2319
二叉树常见OJ练习
数据结构初阶——树和二叉树/堆
weixin_73870552的博客
04-26 1036
int size;// 当前数据个数// 容量}HP;数据类型是inta记录一段连续的地址空间，就是数组。普通二叉树的增删查改没有意义，真正有意义的是搜索树，平衡树，红黑树这些复杂的二叉树。但是学习控制普通二叉树的结构，是有意义的。在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。
【数据结构初阶】树与二叉树——堆
m0_70811813的博客
12-25 1544
本期博客主要讲述数和二叉树的概念，详细对特殊的完全二叉树（堆）进行了阐述与实现。
初阶数据结构——初识二叉树及其应用——堆——及其向下向上调整算法
dtxew love c++
11-05 2634
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 前言 二叉树算是初阶数据结构的一个新坑吧，不仅仅是因为难度比前面的数据结构提升了一个档次，而且这也是我们学的第一种非线性结构 我们在前面学的数据结构，无论是顺序表还是链表，不管它们在物理中的存储方式如何，它们的逻辑一定是串在一起的。 但是
数据结构初阶（4）——二叉树
2301_80065652的博客
08-23 1003
的。
初阶数据结构——二叉树大汇总
yyy_3yu的博客
07-24 1329
这篇博客将会讲到二叉树的部分内容及堆的相关知识~ 这里将会涉及到大量的递归
初阶数据结构——二叉树
dtxew love c++
11-10 3191
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 前言 我们在上篇文章中已经介绍了二叉树的相关性质及其应用，点我直达上一篇文章 然而，在实际应用中，单纯地讲二叉树的增删查改是没有意义的 因为存储和访问数据，将会变得特别的困难，因为二叉树是一种层次结构，需要递归来定义，在哪一点添加删除？这
数据结构初阶——二叉树
m0_64607843的博客
07-08 9484
简单二叉树的超详细讲解来了，点进来的你绝对不会后悔，也不会让你失望。
初阶数据结构——时间复杂度
yycwhks的博客
04-23 772
2+2N+10，当N取不同值时执行次数也不同，各项对次数的影响各不相同，随着N的不断增大（不用考略N值很小的情况，计算机的cpu主频单位时间内计算次数上亿次），后两项对函数的大小影响微乎其微，所以就可忽略掉，只取最高次数项--N……到这，通过一些简单概念和例子的介绍大概知道的时间复杂度是用来度量算法程序执行次数的量，在后续解决一个实际的问题的时候，可以先从多个思路分析这个这个问题，计算出算法的时间复杂度，对比，找出时间复杂度的最低算法来实现（但是时间复杂度不一定是越低越好）。O（m),反之为O（n)。
《数据结构初阶》二叉树之堆的实现和堆排序
m0_62171658的博客
04-04 1783
本章重点介绍堆概念、堆的相关接口、堆排序（含有动态图）
数据结构初阶——排序
qq_59392324的博客
12-19 1246
1.排序的概念 排序就是使一串数据按照特定的规律比较，进行排列出来的操作。 常见的排序算法 //排序实现的接口 void InsertSort(int* a,int n); //插入排序 void ShellSort(int* a,int n); //希尔排序 void SelectSort(int* a, int n); // 选择排序 void AdjustDwon(int* a, int n, int root); void HeapSort(int* a, in.
在多线程环境下如何设计共享数据结构保证原子操作与数据一致性
windowshht的博客
05-03 552
在现代软件开发中，多线程编程是提升程序性能和响应速度的重要手段。然而，多线程环境下的。，不会出现并发冲突。但在多线程环境中，多个线程可能同时访问和修改共享数据，导致。在多线程环境下，共享数据一致性至关重要。极具挑战性，若处理不当，可能引发。Python 提供多种方法确保。在单线程环境中，数据操作。
《数据结构初阶》【顺序栈 + 链式队列 + 循环队列】
序属秋秋秋的博客
05-05 1701
博客的内容主要划分为：数据结构的介绍+数据结构的实现+数据结构的OJ练习。主要涉及的数据结构有：顺序栈、链式队列表、循环队列。
数据结构 - 10（ B- 树 && B+ 树 && B* 树 4000 字详解 ）
最新发布
weixin_73232539的博客
05-08 820
数据结构第十篇，B- 树 && B+ 树 && B* 树 4000 字详解
day23-集合（泛型&Set&数据结构）
2301_80368429的博客
05-08 723
泛型的介绍 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制泛型的好处把运行时期的问题提前到了编译期间避免了强制类型转换泛型的定义格式<类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如:<类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>不可以存储重复元素没有索引,不能使用普通for循环遍历不可以存储重复元素没有索引可以将元素按照规则进行排序。
【数据结构】——顺序表刷题
2302_81083101的博客
04-30 845
前面我们学习了顺序表，下面我们通过几道练习来巩固其知识点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值