devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构：堆_非完全二叉树

作者：AllinToyou | 2024-06-12 09:42:41

赞

踩

非完全二叉树

目录

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(这个别名起什么都可以，只要不是关键字就行)。这样使用时会方便很多。

  1. typedef struct Heap {
  2. 	//定义DataType类型的指针
  3. 	//用来指向一段连续的数组空间
  4. 	DataType* array;
  5.  
  6. 	//array指向的数组空间的容量
  7. 	int capacity;
  8.  
  9. 	//array指向的数组空间内存储的元素个数
  10. 	int size;
  11. }Heap;

    [2]堆的交换函数

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

  1. //交换堆中两个结点保存的值
  2. void Swap(DataType* left, DataType* right) {
  3. 	DataType temp = *left;
  4. 	*left = *right;
  5. 	*right = temp;
  6. }

    [3]堆的向下调整函数

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

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

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

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

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

  1. //堆的向下调整
  2. //parent是双亲结点下标
  3. //这里的child parent都是下标
  4. void AdjustDown(Heap* hp, int parent) {
  5. 	//标记左孩子的下标，因为可能只有左孩子没有右孩子
  6. 	int child = parent * 2 + 1;
  7.  
  8. 	int size = hp->size;
  9.  
  10. 	//只要孩子结点的下标小于总结点的个数
  11. 	//说明并没有越界
  12. 	while (child < size) {
  13. 		//找出两个孩子中最小的那个
  14. 		//child+1<size 成立时说明右孩子结点存在
  15. 		//hp->array[child + 1] < hp->array[child] 这个表达式成立说明右孩子比左孩子小
  16. 		//那么child下标就要转移到右孩子
  17. 		if (child + 1 < size && hp->array[child + 1] < hp->array[child])
  18. 			child += 1;
  19.  
  20. 		//判断双亲结点是否比最小的孩子结点小
  21. 		if (hp->array[child] < hp->array[parent]) {
  22. 			Swap(&hp->array[parent], &hp->array[child]);
  23. 			parent = child;
  24. 			child = parent * 2 + 1;
  25. 		}
  26. 		else {
  27. 			return;
  28. 		}
  29. 	}
  30. }

    [4]堆的向上调整函数

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

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

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

  1. //堆的向上调整
  2. void AdjustUp(Heap* hp, int child) {
  3. 	//parent是child结点的双亲结点的下标
  4. 	int parent = (child - 1) / 2;
  5.  
  6. 	//循环是为了一直向上调整
  7. 	//child下标不等于0说明还没有调整到根节点
  8. 	while (child) {
  9. 		//如果孩子结点的值小于双亲结点的值
  10. 		//说明不满足小堆
  11. 		if (hp->array[child] < hp->array[parent]) {
  12. 			//交换孩子与双亲的值
  13. 			//并且把孩子的下标和双亲的下标更新使得满足循环条件继续向上调整
  14. 			Swap(&hp->array[parent], &hp->array[child]);
  15. 			child = parent;
  16. 			parent = (child - 1) / 2;
  17. 		}
  18. 		//满足小堆就可以退出了
  19. 		else {
  20. 			return;
  21. 		}
  22. 	}
  23. }

    [5]堆结构创建函数

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

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

8b3b0ac843bd47a3bbe1a3dcdb5afb55.png

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

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

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

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

d7241e0d724d40db8edd1319fe999784.png

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

cff9a567143149ff8a725fdcfddaf8b4.png

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

 cd08c532c8b441da811d71f12ee51890.png

  1. //堆的创建
  2. void HeapCreate(Heap* hp, DataType _array[], int _size) {
  3. 	//assert检查指针hp是否存在
  4. 	//当指针hp指向空，就会报错
  5. 	assert(hp);
  6.  
  7. 	//根据传递的参数_size来为hp开辟指向的空间
  8. 	//如果开辟失败，malloc函数会返回NULL，hp就会指向NULL
  9. 	hp->array = (DataType*)malloc(_size * sizeof(DataType));
  10.  
  11. 	//判断空间是否开辟成功
  12. 	if (hp->array == NULL) {
  13. 		assert(0);
  14. 		return;
  15. 	}
  16.  
  17. 	//空间开辟成功，修改堆中的容量
  18. 	hp->capacity = _size;
  19.  
  20. 	//空间开辟成功，开始存入元素
  21. 	for (int i = 0; i < _size; i++) {
  22. 		hp->array[i] = _array[i];
  23. 	}
  24.  
  25. 	//修改堆中元素个数
  26. 	hp->size = _size;
  27.  
  28. 	//开始从最后一个非叶子结点进行向下调整
  29. 	//(hp->size - 2)/2 这是最后一个非叶子结点的下标
  30. 	for (int i = (hp->size - 2) / 2; i >= 0; i--) {
  31. 		AdjustDown(hp,i);
  32. 	}
  33. }

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

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

  1. //检查堆中空间是否足够，不够要扩容
  2. void HeapCheckCapacity(Heap* hp) {
  3. 	assert(hp);
  4. 	//当容量和元素个数相同说明空间满了
  5. 	if (hp->capacity == hp->size) {
  6. 		//newCapacity就是准备新申请的空间大小
  7. 		int newCapacity = hp->capacity * 2;
  8. 		//申请新空间
  9. 		DataType* temp = (DataType*)malloc(sizeof(DataType) * newCapacity);
  10.  
  11. 		//判断空间是否成功申请
  12. 		//申请失败的话malloc函数会返回NULL
  13. 		if (temp == NULL) {
  14. 			assert(0);
  15. 			return;
  16. 		}
  17. 		//将原空间的元素复制到新空间
  18. 		for (int i = 0; i < hp->size; i++) {
  19. 			temp[i] = hp->array[i];
  20. 		}
  21. 		//释放原空间
  22. 		free(hp->array);
  23. 		//将指针指向新空间
  24. 		hp->array = temp;
  25. 		//更新容量
  26. 		hp->capacity = newCapacity;
  27. 	}
  28. }

    [7]堆中插入结点

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

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

    [8]堆顶元素的删除

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

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

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

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

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

5853956fbb1e49e1af0a36a41f8becdf.png

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

26939c7f8ce3492aa15ea50d70fda07c.png

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

4ff8b5169daa4b66b2ca0249f2885950.png

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

    [9]获取堆顶元素

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

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

    [10]获取堆的元素个数 

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

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

    [11]判断堆是否是空

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

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

    [12]删除整个堆

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

  1. //销毁整个堆
  2. void HeapDestroy(Heap* hp) {
  3. 	assert(hp);
  4. 	//只有指针不指向空才可以进行释放
  5. 	if (hp->array) {
  6. 		//释放堆上申请的空间
  7. 		free(hp->array);
  8. 		//将指针指向空，防止无意间被使用
  9. 		hp->array = NULL;
  10. 		hp->size = 0;
  11. 		hp->capacity = 0;
  12. 	}
  13. }

4.堆的整体实现代码

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

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <assert.h>
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6.  
  7. //小堆
  8. typedef int DataType;
  9.  
  10. typedef struct Heap {
  11. 	//定义DataType类型的指针
  12. 	//用来指向一段连续的数组空间
  13. 	DataType* array;
  14.  
  15. 	//array指向的数组空间的容量
  16. 	int capacity;
  17.  
  18. 	//array指向的数组空间内存储的元素个数
  19. 	int size;
  20. }Heap;
  21.  
  22. //堆的创建
  23. void HeapCreate(Heap* hp, DataType _array[], int _size);
  24. //堆中插入元素
  25. void HeapPush(Heap* hp, DataType data);
  26. //删除堆顶元素
  27. void HeapPop(Heap* hp);
  28. //返回堆顶元素的引用
  29. DataType HeapTop(Heap* hp);
  30. //获取堆中元素的个数
  31. int HeapSize(Heap* hp);
  32. //判断堆是否是空堆
  33. int HeapEmpty(Heap* hp);
  34. //销毁整个堆
  35. void HeapDestroy(Heap* hp);
  36. //堆的向下调整函数
  37. void AdjustDown(Heap* hp, int parent);
  38. //交换两个结点的元素
  39. void Swap(DataType* left, DataType* right);
  40. //检查堆的空间是否足够，不够会扩容
  41. void HeapCheckCapacity(Heap* hp);
  42. //堆的向上调整
  43. void AdjustUp(Heap* hp, int child);
  44.  
  45.  
  46. //交换堆中两个结点保存的值
  47. void Swap(DataType* left, DataType* right) {
  48. 	DataType temp = *left;
  49. 	*left = *right;
  50. 	*right = temp;
  51. }
  52.  
  53.  
  54. //堆的向下调整
  55. //parent是双亲结点下标
  56. //这里的child parent都是下标
  57. void AdjustDown(Heap* hp, int parent) {
  58. 	//标记左孩子的下标，因为可能只有左孩子没有右孩子
  59. 	int child = parent * 2 + 1;
  60.  
  61. 	int size = hp->size;
  62.  
  63. 	//只要孩子结点的下标小于总结点的个数
  64. 	//说明并没有越界
  65. 	while (child < size) {
  66. 		//找出两个孩子中最小的那个
  67. 		//child+1<size 成立时说明右孩子结点存在
  68. 		//hp->array[child + 1] < hp->array[child] 这个表达式成立说明右孩子比左孩子小
  69. 		//那么child下标就要转移到右孩子
  70. 		if (child + 1 < size && hp->array[child + 1] < hp->array[child])
  71. 			child += 1;
  72.  
  73. 		//判断双亲结点是否比最小的孩子结点小
  74. 		if (hp->array[child] < hp->array[parent]) {
  75. 			Swap(&hp->array[parent], &hp->array[child]);
  76. 			parent = child;
  77. 			child = parent * 2 + 1;
  78. 		}
  79. 		else {
  80. 			return;
  81. 		}
  82. 	}
  83. }
  84.  
  85. //堆的向上调整
  86. void AdjustUp(Heap* hp, int child) {
  87. 	//parent是child结点的双亲结点的下标
  88. 	int parent = (child - 1) / 2;
  89.  
  90. 	//循环是为了一直向上调整
  91. 	//child下标不等于0说明还没有调整到根节点
  92. 	while (child) {
  93. 		//如果孩子结点的值小于双亲结点的值
  94. 		//说明不满足小堆
  95. 		if (hp->array[child] < hp->array[parent]) {
  96. 			//交换孩子与双亲的值
  97. 			//并且把孩子的下标和双亲的下标更新使得满足循环条件继续向上调整
  98. 			Swap(&hp->array[parent], &hp->array[child]);
  99. 			child = parent;
  100. 			parent = (child - 1) / 2;
  101. 		}
  102. 		//满足小堆就可以退出了
  103. 		else {
  104. 			return;
  105. 		}
  106. 	}
  107. }
  108.  
  109.  
  110. //堆的创建
  111. void HeapCreate(Heap* hp, DataType _array[], int _size) {
  112. 	//assert检查指针hp是否存在
  113. 	//当指针hp指向空，就会报错
  114. 	assert(hp);
  115.  
  116. 	//根据传递的参数_size来为hp开辟指向的空间
  117. 	//如果开辟失败，malloc函数会返回NULL，hp就会指向NULL
  118. 	hp->array = (DataType*)malloc(_size * sizeof(DataType));
  119.  
  120. 	//判断空间是否开辟成功
  121. 	if (hp->array == NULL) {
  122. 		assert(0);
  123. 		return;
  124. 	}
  125.  
  126. 	//空间开辟成功，修改堆中的容量
  127. 	hp->capacity = _size;
  128.  
  129. 	//空间开辟成功，开始存入元素
  130. 	for (int i = 0; i < _size; i++) {
  131. 		hp->array[i] = _array[i];
  132. 	}
  133.  
  134. 	//修改堆中元素个数
  135. 	hp->size = _size;
  136.  
  137. 	//开始从最后一个非叶子结点进行向下调整
  138. 	//(hp->size - 2)/2 这是最后一个非叶子结点的下标
  139. 	for (int i = (hp->size - 2) / 2; i >= 0; i--) {
  140. 		AdjustDown(hp,i);
  141. 	}
  142. }
  143.  
  144. //检查堆中空间是否足够，不够要扩容
  145. void HeapCheckCapacity(Heap* hp) {
  146. 	assert(hp);
  147. 	//当容量和元素个数相同说明空间满了
  148. 	if (hp->capacity == hp->size) {
  149. 		//newCapacity就是准备新申请的空间大小
  150. 		int newCapacity = hp->capacity * 2;
  151. 		//申请新空间
  152. 		DataType* temp = (DataType*)malloc(sizeof(DataType) * newCapacity);
  153.  
  154. 		//判断空间是否成功申请
  155. 		//申请失败的话malloc函数会返回NULL
  156. 		if (temp == NULL) {
  157. 			assert(0);
  158. 			return;
  159. 		}
  160. 		//将原空间的元素复制到新空间
  161. 		for (int i = 0; i < hp->size; i++) {
  162. 			temp[i] = hp->array[i];
  163. 		}
  164. 		//释放原空间
  165. 		free(hp->array);
  166. 		//将指针指向新空间
  167. 		hp->array = temp;
  168. 		//更新容量
  169. 		hp->capacity = newCapacity;
  170. 	}
  171. }
  172.  
  173. //给堆中插入元素
  174. void HeapPush(Heap* hp, DataType data) {
  175. 	//首先要检测容量
  176. 	HeapCheckCapacity(hp);
  177. 	hp->array[hp->size] = data;
  178. 	hp->size++;
  179. 	//这里就需要向上调整了，因为插入元素后可能会破坏堆的结构
  180. 	AdjustUp(hp, hp->size - 1);
  181. }
  182.  
  183. //删除堆顶元素
  184. void HeapPop(Heap* hp) {
  185. 	//判断hp指针是否指向空，指向空就不能进行删除操作
  186. 	if (HeapEmpty(hp)) {
  187. 		return;
  188. 	}
  189. 	//交换堆顶元素和最后一个结点的元素
  190. 	Swap(&hp->array[0], &hp->array[hp->size-1]);
  191. 	hp->size--;
  192. 	//从堆顶进行向下调整
  193. 	AdjustDown(hp,0);
  194. }
  195. //返回堆顶元素
  196. DataType HeapTop(Heap* hp) {
  197. 	assert(hp);
  198. 	return hp->array[0];
  199. }
  200. //获取堆中元素的个数
  201. int HeapSize(Heap* hp) {
  202. 	assert(hp);
  203. 	return hp->size;
  204. }
  205. //判断堆是否是空
  206. int HeapEmpty(Heap* hp) {
  207. 	assert(hp);
  208. 	return hp->size == 0;
  209. }
  210. //销毁整个堆
  211. void HeapDestroy(Heap* hp) {
  212. 	assert(hp);
  213. 	//只有指针不指向空才可以进行释放
  214. 	if (hp->array) {
  215. 		//释放堆上申请的空间
  216. 		free(hp->array);
  217. 		//将指针指向空，防止无意间被使用
  218. 		hp->array = NULL;
  219. 		hp->size = 0;
  220. 		hp->capacity = 0;
  221. 	}
  222. }
  223.  
  224. int main() {
  225. 	DataType arr[] = { 100,99,88,77,66,55,44,33,22,11,10,9,8,7,6,5,4,3,2,1};
  226. 	Heap Hp;
  227. 	HeapCreate(&Hp,arr,sizeof(arr)/sizeof(arr[0]));
  228. 	//HeapPush(&Hp, 2);
  229. 	//HeapPop(&Hp);
  230.  
  231. 	for (int i = 0; i < Hp.size; i++) {
  232. 		printf("%d ", Hp.array[i]);
  233. 	}
  234. 	printf("\n");
  235.  
  236. 	printf("%d\n", HeapEmpty(&Hp));
  237. 	printf("%d\n", HeapTop(&Hp));
  238. 	printf("%d\n", HeapSize(&Hp));
  239. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/707587
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号