数据结构：堆

最新推荐文章于 2024-09-27 19:55:04 发布
最新推荐文章于 2024-09-27 19:55:04 发布
阅读量2.3k 收藏 25
点赞数 26
分类专栏： 数据结构(C语言) 文章标签： 数据结构 C语言 二叉树 堆 堆的向下调整算法和向上调整算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57761086/article/details/127132808
版权

目录

1.堆的引入

  (1)完全二叉树概念

  (2)堆的概念

  (3)堆的示意图

    [1]小堆示意图

    [2]大堆示意图

2.堆的特殊情况

  (1)堆的向下调整算法

  (2)堆的向上调整算法

3.堆的局部实现

  (1)堆的功能分析

  (2)堆的具体实现

    [1]堆结点创建

    [2]堆的交换函数

    [3]堆的向下调整函数

    [4]堆的向上调整函数

    [5]堆结构创建函数

    [6]堆的容量检测扩容函数

    [7]堆中插入结点

    [8]堆顶元素的删除

    [9]获取堆顶元素

    [10]获取堆的元素个数 

    [11]判断堆是否是空

    [12]删除整个堆

4.堆的整体实现代码

        堆在数据结构中很常用，本文将用大量的图片来帮助读者理解堆，特别是理解堆的调整算法。(本文代码均使用C语言，在win10系统下的vs2019验证)

1.堆的引入

  (1)完全二叉树概念

        满二叉树：二叉树中每个非叶子结点都有两个非空的孩子结点。

        完全二叉树：和满二叉树相比，完全二叉树从上往下数，第一层至倒数第二层和满二叉树一样都是满的。完全二叉树的最下层可以不满，但是从左到右必须是连续的，中间不可以间断。(看第二行第二幅图)

        非完全二叉树：不满足完全二叉树性质的均是非完全二叉树。

        如图：

b33794add7384285a181795aeb71e9f5.png

  (2)堆的概念

        堆是完全二叉树的一种，在完全二叉树的基础上加以条件限制，就成为了堆。

        那么给完全二叉树增加什么限制就会成为堆？

        限制分两种：[1]保证每个结点的值不比它的双亲结点小，称为大根堆（最大堆或大堆）；[2]保证每个结点不比它的双亲结点大，称为小根堆（最小堆或小堆）。

        本文总体代码是实现小堆，只要理解了小堆，大堆的实现也是轻而易举的。(只需要将和比较结点大小的代码修改一下，即可从小堆转换为大堆)。

  (3)堆的示意图

    [1]小堆示意图

        小堆：每个结点的值不大于它的双亲结点。

        如下图：

26eaa6f2c61e44a08abc0ce1058e7bf7.png

    [2]大堆示意图

        大堆：每个结点的值不小于它的双亲结点。

        如下图：

374837287e8140a4b1a4b1392ad79ce2.png

2.堆的特殊情况

        为什么要先看堆的特殊情况？

        因为堆的整体实现需要在特殊情况的基础上进行。在这里理解了特殊情况后，在堆的实现中就会更容易理解。

  (1)堆的向下调整算法

        堆的向下调整算法应用于创建堆结构和删除堆顶元素中。什么情况下需要用到向下调整算法？

        如下图一这种情况。可以看到图一中，根结点27的左右子树均是小堆结构，可是以27为根结点的树整体却不是小堆结构，这就是特殊情况：

eaf763d764db41308d110431f406bb21.png

        如何解决特殊情况？当然是调整根结点位置。

        如何调整根结点位置？只能把根结点向下调整。这也是向下调整算法名字的由来。

        如何向下调整？找出待调整结点(27)最小的孩子结点，并与待调整结点进行交换。如图二所示：

4f83c1909cb841e7a88de63a6d9b200e.png

        将两个结点交换后发现，目前以27为根的这棵子树又遇到上面这种特殊情况：以27为双亲结点的两棵子树均是小堆，但以27为根的这棵子树却不是小堆结构。也就是说，子树的小堆结构可能被破坏。那么就只能继续进行向下调整，如图三图四所示：

749ba5fc7d4d40e6a468425249a40a87.png

        经过图四的调整后，得到的结果如下图五：

f33d87fbc85240c18ea3aeaf14e5e803.png

        观察图五发现，目前以27为根结点的这棵子树依旧不满足小堆结构，那么继续向下调整呗。继续调整后满足小堆结构，如图六图七：

f230125a79b24846b4a4c2bc39c9b2dc.png

        在这个算法中可以发现，首次向下调整后很可能破坏根结点子树的小堆结构，所以需要不断地向下比较，不满足性质就要调整。说明在代码实现中，我们需要使用循环结构，通过循环结构，让这个调整过程不断向下进行下去，直到让整棵树满足小堆结构。

  (2)堆的向上调整算法

        堆的向上调整算法用于堆的插入函数中。小堆中插入一个元素后破坏了堆的结构，使用向上调整算法来使得二叉树又形成小堆结构。

        如下图一是小堆：

c454055dc82a4bc0bc884aa7668010a7.png

        在小堆中插入一个元素10，注意，只能将新结点插到最后一个位置。如图二：

68a534799f2a4de0823cc800e64d2f9e.png

        可以看到图二中插入后目前的二叉树显然不满足小堆结构。因为新结点做为28的子结点，却比28小，显然不满足小堆。因此需要调整新结点的位置。

        那么新结点的位置往哪里调整？自然只能向上调整了。这也是向上调整算法名字的由来。

        这里要强调，图一中是小堆，所以每个结点的值都不大于它的双亲结点。

        调整新结点时，比较新结点和新结点的双亲结点的大小。如果新结点大于双亲结点，说明满足小堆，自然不需要改变了。但目前新结点(10)小于双亲结点(28)，因此需要交换新结点和双亲结点。如图三：

0cab0055cf304e7fb0901d261f0fe4fc.png

        将新结点和它的双亲结点交换后，经过比较后发现此时的新结点(10)仍旧小于它的双亲结点(18)，因此继续向上调整。如图四：

8590811a2f264236a9d80ccd2e7c62ff.png

        图四交换后发现结果仍旧不满足小堆结构，因此继续向上调整，如图五六七：

0319f7cb1c554aa886a2ab948d076550.png

        可以发现向上调整算法中，第一次调整后，并不一定会满足小堆结构，因此需要一直向上比较并调整，所以在函数的具体实现中也需要使用循环结构使得新结点不断向上调整。

3.堆的局部实现

  (1)堆的功能分析

        堆中都需要实现什么功能？

1.创建堆结构的函数。

2.堆的向上调整算法

3.堆的向下调整算法

4.堆顶元素的删除

5.堆的销毁

6.给堆中新插入结点

7.交换两个结点值的函数

8.获取堆中结点个数的函数

9.堆的容量检测与扩容函数。(因为我们用数组存储堆的元素，而数组空间有限，所以当空间不足时就需要进行扩容)

  (2)堆的具体实现

    [1]堆结点创建

        堆是一种数据结构，而堆结点则是该结构中存储元素的东西。C语言中，我们应该将堆结点设置为结构体类型。

        结构体中可能存放多种类型的数据，所以我们可以用typedef关键字给数据类型取个别名，这样如果需要修改存储的元素类型就只需要在这里修改就可以了。

typedef int DataType;

        堆结点结构体中，我们需要定义的元素有：DataType类型的指针，用来指向一段DataType类型的数组空间；int 类型的capacity变量，用来保存数组空间的容量；int 类型的size变量，用来保存这段数组空间中存储的元素的个数。

        同时为了使用方便，我们也用typedef关键字给结构体类型起别名Heap(这个别名起什么都可以，只要不是关键字就行)。这样使用时会方便很多。

typedef struct Heap {
	//定义DataType类型的指针
	//用来指向一段连续的数组空间
	DataType* array;

	//array指向的数组空间的容量
	int capacity;

	//array指向的数组空间内存储的元素个数
	int size;
}Heap;

    [2]堆的交换函数

        在堆的调整算法中提到过需要交换两个结点的元素，因此需要定义交换函数。这里需要传递指针，用指针来实现交换。

//交换堆中两个结点保存的值
void Swap(DataType* left, DataType* right) {
	DataType temp = *left;
	*left = *right;
	*right = temp;
}

    [3]堆的向下调整函数

        向下调整函数的工作流程在上面已经用图片了解了，现在来看一下实现原理。

        这里传递的参数是双亲结点的下标，根据这个下标求出左孩子的下标。只要左孩子的下标比结点的个数小，说明孩子下标并没有越界。

        在循环体中，我们先要找出左孩子与右孩子中的最小值。首先判断右孩子是否存在，存在的话与左孩子比较大小。找出最小的孩子结点。

        找出最小的孩子结点后，将孩子结点和双亲结点进行比较。如果孩子结点小于双亲结点，说明不满足小堆，需要调整。

        调整时需要先交换双亲结点和孩子结点的值，然后更新双亲结点和孩子结点的下标，让循环体继续向下调整修复在交换过程中被破坏的下层结构。

//堆的向下调整
//parent是双亲结点下标
//这里的child parent都是下标
void AdjustDown(Heap* hp, int parent) {
	//标记左孩子的下标，因为可能只有左孩子没有右孩子
	int child = parent * 2 + 1;

	int size = hp->size;

	//只要孩子结点的下标小于总结点的个数
	//说明并没有越界
	while (child < size) {
		//找出两个孩子中最小的那个
		//child+1<size 成立时说明右孩子结点存在
		//hp->array[child + 1] < hp->array[child] 这个表达式成立说明右孩子比左孩子小
		//那么child下标就要转移到右孩子
		if (child + 1 < size && hp->array[child + 1] < hp->array[child])
			child += 1;

		//判断双亲结点是否比最小的孩子结点小
		if (hp->array[child] < hp->array[parent]) {
			Swap(&hp->array[parent], &hp->array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			return;
		}
	}
}

    [4]堆的向上调整函数

        向上调整函数其实和向下调整函数差不多。

        向上调整函数的参数是孩子结点的下标，通过孩子结点的下标找出它的双亲结点下标。只要双亲结点下标不是0，说明还没有调整到根结点。

        循环体中，比较孩子结点和双亲结点的大小，如果孩子结点小于双亲结点，说明不满足小堆结构，需要交换孩子结点和双亲结点的值，然后更新下标，让循环体继续向上调整。

//堆的向上调整
void AdjustUp(Heap* hp, int child) {
	//parent是child结点的双亲结点的下标
	int parent = (child - 1) / 2;

	//循环是为了一直向上调整
	//child下标不等于0说明还没有调整到根节点
	while (child) {
		//如果孩子结点的值小于双亲结点的值
		//说明不满足小堆
		if (hp->array[child] < hp->array[parent]) {
			//交换孩子与双亲的值
			//并且把孩子的下标和双亲的下标更新使得满足循环条件继续向上调整
			Swap(&hp->array[parent], &hp->array[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		//满足小堆就可以退出了
		else {
			return;
		}
	}
}

    [5]堆结构创建函数

        这里举的例子是用数组元素构成大堆。

        创建堆结构时，我们首先要先把传入的数组中的元素都存储在二叉树中。如图一：

8b3b0ac843bd47a3bbe1a3dcdb5afb55.png

        但这样的二叉树显然不满足大堆的性质。如何解决？用向下调整。

        可是这个二叉树完全是混乱无序的，根节点的两个子树都不是大堆结构。我们在上面只看了特殊情况的向下调整，那么如何应对混乱无序的二叉树？

        对于混乱无序的二叉树其实很简单，咱们先看最后一个非叶子结点(3)。如果只看以它为根的这棵子树，这是不是就成了大堆的特殊情况？子节点(6)大于双亲结点(3)，以3为根的这棵子树不满足大堆。而以子节点(6)为根的二叉树只有一个元素，那么我们就可以认为以子结点(6)为根的这棵二叉树是大堆，这样是不是就成了特殊情况？

        所以解决混乱无序的方法是：从最后一个非叶子结点开始，依次把以非叶子结点为根的二叉树看作特殊情况去解决。如图二三四：

d7241e0d724d40db8edd1319fe999784.png

        但是根据上面的方法遇到了问题，虽然已经调整到根节点，却发现仍旧不满足大堆结构，如图五：

cff9a567143149ff8a725fdcfddaf8b4.png

         这是因为在向上调整的过程中，如果一旦和上层的结点发生交换，可能会破坏下层的堆结构。这个在讲解向下调整算法的时候在结尾提到了。如何解决？在每一次调用向下调整算法后，在调整算法中不断通过循环向下去修复被破坏的堆结构。如图六七：

 cd08c532c8b441da811d71f12ee51890.png

//堆的创建
void HeapCreate(Heap* hp, DataType _array[], int _size) {
	//assert检查指针hp是否存在
	//当指针hp指向空，就会报错
	assert(hp);

	//根据传递的参数_size来为hp开辟指向的空间
	//如果开辟失败，malloc函数会返回NULL，hp就会指向NULL
	hp->array = (DataType*)malloc(_size * sizeof(DataType));

	//判断空间是否开辟成功
	if (hp->array == NULL) {
		assert(0);
		return;
	}

	//空间开辟成功，修改堆中的容量
	hp->capacity = _size;

	//空间开辟成功，开始存入元素
	for (int i = 0; i < _size; i++) {
		hp->array[i] = _array[i];
	}

	//修改堆中元素个数
	hp->size = _size;

	//开始从最后一个非叶子结点进行向下调整
	//(hp->size - 2)/2 这是最后一个非叶子结点的下标
	for (int i = (hp->size - 2) / 2; i >= 0; i--) {
		AdjustDown(hp,i);
	}
}

    [6]堆的容量检测扩容函数

        这个函数的作用是：在往堆结构中插入元素时，需要判断存储堆元素的数组容量是否足够，如果不够就需要先扩容再插入元素。

//检查堆中空间是否足够，不够要扩容
void HeapCheckCapacity(Heap* hp) {
	assert(hp);
	//当容量和元素个数相同说明空间满了
	if (hp->capacity == hp->size) {
		//newCapacity就是准备新申请的空间大小
		int newCapacity = hp->capacity * 2;
		//申请新空间
		DataType* temp = (DataType*)malloc(sizeof(DataType) * newCapacity);

		//判断空间是否成功申请
		//申请失败的话malloc函数会返回NULL
		if (temp == NULL) {
			assert(0);
			return;
		}
		//将原空间的元素复制到新空间
		for (int i = 0; i < hp->size; i++) {
			temp[i] = hp->array[i];
		}
		//释放原空间
		free(hp->array);
		//将指针指向新空间
		hp->array = temp;
		//更新容量
		hp->capacity = newCapacity;
	}
}

    [7]堆中插入结点

        这个函数就是往堆中插入新结点，需要调用容量检测扩容函数，当容量不足就要扩容。插入完成后，就需要将新结点向上调整，使整棵树满足堆结构。

//给堆中插入元素
void HeapPush(Heap* hp, DataType data) {
	//首先要检测容量
	HeapCheckCapacity(hp);
	hp->array[hp->size] = data;
	hp->size++;
	//这里就需要向上调整了，因为插入元素后可能会破坏堆的结构
    //hp->size - 1 是新结点的下标
	AdjustUp(hp, hp->size - 1);
}

    [8]堆顶元素的删除

        堆中的删除操作只有两种，删除堆顶元素，删除整个堆。不可以单独删除除堆顶外的元素。

        堆顶元素的删除如何实现？

        自然不可以直接删除，不然就变成了两颗子树。我们需要把堆顶元素和堆最末尾的结点值交换。然后将堆的元素减一，这样是不是使用或访问时，就会少一个元素。

        可是这样有一个问题，会出现根结点的两个子树满足性质，但整棵树不满足，也就是特殊情况中介绍的第一种，这里就要用到向下调整了。

        如图一是小堆，需要删除堆顶结点：

5853956fbb1e49e1af0a36a41f8becdf.png

        首先交换堆顶元素和最后一个元素，然后将size变量个数减一(因为size中存储结点个数，减1后最后一个结点就访问不到了，相当于删除了)，如图二三四：

26939c7f8ce3492aa15ea50d70fda07c.png

        经过上面的步骤虽然删除了堆顶结点，但是破坏了小堆结构，造成了特殊情况，因此需要使用向下调整算法修复堆结构。在向下调整的过程中，我们发现会破坏下层的堆结构，所以需要在调整算法中循环修复下层堆结构。如图五六七：

4ff8b5169daa4b66b2ca0249f2885950.png

//删除堆顶元素
void HeapPop(Heap* hp) {
	//判断hp指针是否指向空，指向空就不能进行删除操作
	if (HeapEmpty(hp)) {
		return;
	}
	//交换堆顶元素和最后一个结点的元素
	Swap(&hp->array[0], &hp->array[hp->size-1]);
	hp->size--;
	//从堆顶进行向下调整
	AdjustDown(hp,0);
}

    [9]获取堆顶元素

        这个函数非常简单，堆顶元素就在数组0下标处存储，因此只需要返回0下标的元素即可。

//返回堆顶元素
DataType HeapTop(Heap* hp) {
	assert(hp);
	return hp->array[0];
}

    [10]获取堆的元素个数 

        堆的元素个数被size变量记录，因此直接返回size变量即可。

//获取堆中元素的个数
int HeapSize(Heap* hp) {
	assert(hp);
	return hp->size;
}

    [11]判断堆是否是空

         当元素个数为0，堆自然是空的。

//判断堆是否是空
int HeapEmpty(Heap* hp) {
	assert(hp);
	return hp->size == 0;
}

    [12]删除整个堆

        释放空间，指针置空，元素置0即可。

//销毁整个堆
void HeapDestroy(Heap* hp) {
	assert(hp);
	//只有指针不指向空才可以进行释放
	if (hp->array) {
		//释放堆上申请的空间
		free(hp->array);
		//将指针指向空，防止无意间被使用
		hp->array = NULL;
		hp->size = 0;
		hp->capacity = 0;
	}
}

4.堆的整体实现代码

        此代码是创建小堆，如果需要创建大堆，只需要在向上调整和向下调整函数中对比较大小的部分进行修改即可。

#define _CRT_SECURE_NO_WARNINGS
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

//小堆
typedef int DataType;

typedef struct Heap {
	//定义DataType类型的指针
	//用来指向一段连续的数组空间
	DataType* array;

	//array指向的数组空间的容量
	int capacity;

	//array指向的数组空间内存储的元素个数
	int size;
}Heap;

//堆的创建
void HeapCreate(Heap* hp, DataType _array[], int _size);
//堆中插入元素
void HeapPush(Heap* hp, DataType data);
//删除堆顶元素
void HeapPop(Heap* hp);
//返回堆顶元素的引用
DataType HeapTop(Heap* hp);
//获取堆中元素的个数
int HeapSize(Heap* hp);
//判断堆是否是空堆
int HeapEmpty(Heap* hp);
//销毁整个堆
void HeapDestroy(Heap* hp);
//堆的向下调整函数
void AdjustDown(Heap* hp, int parent);
//交换两个结点的元素
void Swap(DataType* left, DataType* right);
//检查堆的空间是否足够，不够会扩容
void HeapCheckCapacity(Heap* hp);
//堆的向上调整
void AdjustUp(Heap* hp, int child);


//交换堆中两个结点保存的值
void Swap(DataType* left, DataType* right) {
	DataType temp = *left;
	*left = *right;
	*right = temp;
}


//堆的向下调整
//parent是双亲结点下标
//这里的child parent都是下标
void AdjustDown(Heap* hp, int parent) {
	//标记左孩子的下标，因为可能只有左孩子没有右孩子
	int child = parent * 2 + 1;

	int size = hp->size;

	//只要孩子结点的下标小于总结点的个数
	//说明并没有越界
	while (child < size) {
		//找出两个孩子中最小的那个
		//child+1<size 成立时说明右孩子结点存在
		//hp->array[child + 1] < hp->array[child] 这个表达式成立说明右孩子比左孩子小
		//那么child下标就要转移到右孩子
		if (child + 1 < size && hp->array[child + 1] < hp->array[child])
			child += 1;

		//判断双亲结点是否比最小的孩子结点小
		if (hp->array[child] < hp->array[parent]) {
			Swap(&hp->array[parent], &hp->array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			return;
		}
	}
}

//堆的向上调整
void AdjustUp(Heap* hp, int child) {
	//parent是child结点的双亲结点的下标
	int parent = (child - 1) / 2;

	//循环是为了一直向上调整
	//child下标不等于0说明还没有调整到根节点
	while (child) {
		//如果孩子结点的值小于双亲结点的值
		//说明不满足小堆
		if (hp->array[child] < hp->array[parent]) {
			//交换孩子与双亲的值
			//并且把孩子的下标和双亲的下标更新使得满足循环条件继续向上调整
			Swap(&hp->array[parent], &hp->array[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		//满足小堆就可以退出了
		else {
			return;
		}
	}
}


//堆的创建
void HeapCreate(Heap* hp, DataType _array[], int _size) {
	//assert检查指针hp是否存在
	//当指针hp指向空，就会报错
	assert(hp);

	//根据传递的参数_size来为hp开辟指向的空间
	//如果开辟失败，malloc函数会返回NULL，hp就会指向NULL
	hp->array = (DataType*)malloc(_size * sizeof(DataType));

	//判断空间是否开辟成功
	if (hp->array == NULL) {
		assert(0);
		return;
	}

	//空间开辟成功，修改堆中的容量
	hp->capacity = _size;

	//空间开辟成功，开始存入元素
	for (int i = 0; i < _size; i++) {
		hp->array[i] = _array[i];
	}

	//修改堆中元素个数
	hp->size = _size;

	//开始从最后一个非叶子结点进行向下调整
	//(hp->size - 2)/2 这是最后一个非叶子结点的下标
	for (int i = (hp->size - 2) / 2; i >= 0; i--) {
		AdjustDown(hp,i);
	}
}

//检查堆中空间是否足够，不够要扩容
void HeapCheckCapacity(Heap* hp) {
	assert(hp);
	//当容量和元素个数相同说明空间满了
	if (hp->capacity == hp->size) {
		//newCapacity就是准备新申请的空间大小
		int newCapacity = hp->capacity * 2;
		//申请新空间
		DataType* temp = (DataType*)malloc(sizeof(DataType) * newCapacity);

		//判断空间是否成功申请
		//申请失败的话malloc函数会返回NULL
		if (temp == NULL) {
			assert(0);
			return;
		}
		//将原空间的元素复制到新空间
		for (int i = 0; i < hp->size; i++) {
			temp[i] = hp->array[i];
		}
		//释放原空间
		free(hp->array);
		//将指针指向新空间
		hp->array = temp;
		//更新容量
		hp->capacity = newCapacity;
	}
}

//给堆中插入元素
void HeapPush(Heap* hp, DataType data) {
	//首先要检测容量
	HeapCheckCapacity(hp);
	hp->array[hp->size] = data;
	hp->size++;
	//这里就需要向上调整了，因为插入元素后可能会破坏堆的结构
	AdjustUp(hp, hp->size - 1);
}

//删除堆顶元素
void HeapPop(Heap* hp) {
	//判断hp指针是否指向空，指向空就不能进行删除操作
	if (HeapEmpty(hp)) {
		return;
	}
	//交换堆顶元素和最后一个结点的元素
	Swap(&hp->array[0], &hp->array[hp->size-1]);
	hp->size--;
	//从堆顶进行向下调整
	AdjustDown(hp,0);
}
//返回堆顶元素
DataType HeapTop(Heap* hp) {
	assert(hp);
	return hp->array[0];
}
//获取堆中元素的个数
int HeapSize(Heap* hp) {
	assert(hp);
	return hp->size;
}
//判断堆是否是空
int HeapEmpty(Heap* hp) {
	assert(hp);
	return hp->size == 0;
}
//销毁整个堆
void HeapDestroy(Heap* hp) {
	assert(hp);
	//只有指针不指向空才可以进行释放
	if (hp->array) {
		//释放堆上申请的空间
		free(hp->array);
		//将指针指向空，防止无意间被使用
		hp->array = NULL;
		hp->size = 0;
		hp->capacity = 0;
	}
}

int main() {
	DataType arr[] = { 100,99,88,77,66,55,44,33,22,11,10,9,8,7,6,5,4,3,2,1};
	Heap Hp;
	HeapCreate(&Hp,arr,sizeof(arr)/sizeof(arr[0]));
	//HeapPush(&Hp, 2);
	//HeapPop(&Hp);

	for (int i = 0; i < Hp.size; i++) {
		printf("%d ", Hp.array[i]);
	}
	printf("\n");

	printf("%d\n", HeapEmpty(&Hp));
	printf("%d\n", HeapTop(&Hp));
	printf("%d\n", HeapSize(&Hp));
}
爱喝酸奶！
关注
专栏目录
数据结构之堆详解
09-04
堆，作为一种特殊的数据结构，是实现优先队列的典型数据结构。它通常表现为一棵完全二叉树，且具有以下特性：对于大顶堆，每个父节点的值都大于或等于其子节点的值；对于小顶堆，父节点的值小于或等于子节点的值。...
数据结构——【堆】
m0_69323023的博客
09-12 7199
堆
数据结构：满二叉树，完全二叉树，非完全二叉树 的区别
水光涵月的博客
07-14 1万+
数据结构：满二叉树，完全二叉树，非完全二叉树 的区别前言一、满二叉树二、完全二叉树三、非完全二叉树总结 前言 记录下满二叉树，完全二叉树，非完全二叉树的区别 一、满二叉树 如上图所示，这就是一个满二叉树的示例图，从字面上也很好理解，叶子节点外，所有节点都有两个子节点。 二、完全二叉树 完全二叉树就和名字有点不太一样了，除最后一层节点外，其他层节点都必须要有两个子节点，并且最后一层节点都要左排列。 要满足两个条件： 1.除最后一层节点外，其他层节点都必须要有两个子节点 2.最后一层节点都要左排列 像
【数据结构】堆（Heap）详解
最新发布
A Charmer 的博客
09-27 1588
堆是一种非常重要的数据结构，具有独特的性质和高效的操作。它在堆排序、优先队列等算法和应用中有着广泛的应用。通过对堆的深入理解和掌握，我们可以更好地设计和实现高效的算法，解决各种实际问题。
堆（数据结构）
热门推荐
zgdlxs的博客
01-24 2万+
1.堆的概念 如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<=K2i+2 ，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。除了最后一层以外上面的节点但是非空的，最后一层节点是从左到右依次排布的。如图： ...
【数据结构入门】堆（Heap）
codewinter的博客
02-27 4217
文章目录一、堆的结构及实现（重要）1.1 二叉树的顺序结构1.2 堆的概念及结构1.3 堆的实现1.3.1 堆的向下调整算法1.3.2 **向下调整算法的时间复杂度**1.3.3 堆的创建（向下调整）1.3.4 堆排序1.3.5 建堆的时间复杂度二、堆的相关接口实现（以大堆为例）2.1 堆的初始化2.2 堆的销毁2.3 堆的插入2.4 堆的删除2.5 获取堆顶元素2.6 堆的判空2.7 拓展1：找出堆中前k个最大元素2.8 拓展2：堆的创建（向上调整） 一、堆的结构及实现（重要） 1.1 二叉树的顺序结构
数据结构—堆
Flashing-C的博客
08-26 2011
堆是一种特殊的数据结构，它是一棵完全二叉树。把所有的元素按照完全二叉树的结构，按照层序遍历的顺序储存在一维数组中，如果该二叉树满足父节点小于等于子节点，叫做最小堆（小根堆）；如果该二叉树满足父节点大于等于子节点，叫做最大堆（大根堆）。​。
数据结构：堆箱子问题
04-17
问题描述：有n(1)个箱子，要求把这些箱子按要求堆成几堆。 对箱子的操作只有两种： （1）D x y：把含x 的那一叠箱子按照原来的顺序全部堆到含y 的那一叠箱子的最上面。 （2）C x：计算含x 的箱子下面有几个箱子，并...
数据结构——堆排序.h
09-11
数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序
数据结构 堆的实现
08-13
堆是一种特殊的数据结构，通常被用作优先队列的底层实现。在本主题中，我们将深入探讨堆的实现，特别是标准大学课程中教授的方法。 堆通常是一个完全二叉树，分为两种类型：最大堆和最小堆。在最大堆中，每个节点的...
数据结构之堆的详解
qq_45726327的博客
06-12 2421
堆是一种特殊的完全二叉树堆分为小根堆和大根堆,大根堆的根节点值最大,小根堆的根节点值最小最小堆大根堆。
数据结构——【堆】详解
Lucky_mzc的博客
03-08 7377
一. 堆🌲 1. 堆的概念 堆（heap）：一种有特殊用途的数据结构——用来在一组变化频繁（发生增删查改的频率较高）的数据集中查找最值。 堆在物理层面上，表现为一组连续的数组区间：long[] array ；将整个数组看作是堆。 堆在逻辑结构上，一般被视为是一颗完全二叉树。 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆；反之，则是小堆，或者小根堆，或者最小堆。当一个堆为大堆时，它的每一棵子树都是大堆。 2. 堆的存储方式 从堆的概念可知，堆是一棵完全二叉树，
数据结构——堆和堆排序(python)
IT荻的博客
02-13 5776
本文通过堆的实现、最小堆（最大堆）、堆的时间复杂度、优先队列的实现、堆排序来介绍「 堆 」。 堆的实现 堆的一个经典的实现是完全二叉树(complete binary tree)，这样实现的堆称为二叉堆(binary heap)。 这里来说明一下满二叉树的概念与完全二叉树的概念。 满二叉树：除了叶子节点，所有的节点的左右孩子都不为空，就是一棵满二叉树，如下图。 可以看出：满二叉树所有的节点都拥有...
数据结构——堆
漫漫无期的博客
10-10 5736
一、概念及其介绍 堆(Heap)是计算机科学中一类特殊的数据结构的统称。 堆通常是一个可以被看做一棵完全二叉树的数组对象。 堆满足下列性质： 堆中某个节点的值总是不大于或不小于其父节点的值。 堆总是一棵完全二叉树。 二、适用说明 堆是利用完全二叉树的结构来维护一组数据，然后进行相关操作，一般的操作进行一次的时间复杂度在O(1)~O(logn)之间，堆通常用于动态分配和释放程序所使用的对象。 若为优先队列的使用场景，普通数组或者顺序数组，最差情况为O(n^2)，堆这种数据结构也可以提高入队...
数据结构 —— 堆（超详细图解 & 接口函数实现）
十里坡小白的博客
08-23 1502
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构是一种十分优秀的解决实际问题的模板，博主将会用代码结合大量图解，对数据结构进行深度剖析。
【数据结构】堆
m0_73067372的博客
03-25 999
常见的几种构造方法构造器功能介绍创建一个空的优先级队列，默认容量是11创建一个初始容量为initialCapacity的优先级队列，注意：initialCapacity不能小于1，否则会抛IllegalArgumentException异常用一个集合来创建优先级队列1、PriorityQueue()构造方法来看一下带两个参数的构造方法2、PriorityQueue(int initialCapacity)构造方法extends E> c)构造方法。
【NOI】二叉树的定义与基本性质
明月别枝惊鹊的博客
04-08 2506
在计算机科学与算法领域中，二叉树作为一种基础且重要的数据结构，以其独特的组织方式和丰富的特性，广泛应用于诸多实际问题的解决方案。尤其在信息学奥林匹克竞赛（NOI）等高级别编程竞赛中，深入理解和熟练掌握二叉树的相关知识，是提升解题能力和应对复杂问题的关键一环。本篇文章旨在系统地阐述二叉树的定义、分类以及其基本性质，为读者搭建起扎实的理论基础，并通过实例解析与练习题，加深对二叉树特性的直观感知与运用能力。C++从入门到NOI学习路线C++全国青少年信息学奥林匹克竞赛（NOI）入门级-大纲。
【二叉树的分类】
尘归尘 码归码
03-09 883
什么是二叉树？ 二叉树(Binary tree)是N个有限元素的集合，是一种树中节点的度不大于2的有序树（只能是0 1 2） 1根下有2 3 ，2根下有4 5 只能小于等于2个子节点 1 2 3 4 5 6 7 什么是满二叉树？ 如果二叉树中最后一层无任务子节点，且其他每一层上的所有节点都有两个子节点，即每个节点的度都为2，则此二叉树可以称为满二叉树。 1 2 3 4 5 6 7 什么是完全二叉树？ 如果二叉树中除了最后一层外，其他各层的节点都达到最大个数2个，且最后一层的所有节点依次从
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值