• 数据结构：二叉树的顺序结构--堆

    朋友们、伙计们，我们又见面了，本期来给大家解读一下二叉树--堆的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

    C 语 言 专 栏：C语言：从入门到精通

    数据结构专栏：数据结构

    个  人  主  页 ：stackY、

    目录

    前言：

    1.堆的概念及结构

    2.堆的实现

    2.1创建堆

    2.2初始化堆

    2.3向堆中插入数据

    2.4向上调整算法 

    2.5判断堆是否为空

    2.6删除堆中的数据

    2.7向下调整算法

    2.8有效元素个数、堆顶元素

    2.9代码测试 

    2.10完整代码

    前言：

    普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结 构存储。
    现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统 虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

    1.堆的概念及结构

    如果有一个关键码的集合K = {k_{0},k_{1},k_{2},k_{3}, ... ,k_{n-1}}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：K_{i}<=K_{2*i+1}且K_{i}<=K_{2*i+2}(i = 0,1,2,3,4,......n-1)被称为小堆或K_{i}>=K_{2*i+1}且K_{i}>=K_{2*i+2} (i = 0,1,2,3,4,......n-1)被称为大堆，将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
    图示：

    简单的来讲：

    1.大堆就是每一个孩子节点都要比它的父亲节点小，这只是规定了父亲节点和孩子节点之间的大小关系，并没有规定兄弟节点之间的关系，两个兄弟节点的大小不确定。

    2. 小堆就是每一个孩子节点都要比它的父亲节点大，这只是规定了父亲节点和孩子节点之间的大小关系，并没有规定兄弟节点之间的关系，两个兄弟节点的大小不确定。

    因此堆并不一定是有序的。

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

    2.堆的实现

    堆是一种特殊的完全二叉树，因此实现堆的思路就是使用顺序表，同样的我们也是分模块来写，创建头文件：Heap.h、源文件：Heap.c和Test.c，堆在这里主要实现的接口是：初始化、插入，删除（删除堆顶元素）、判空、有效元素个数、堆顶元素、销毁。话不多说我们直接开始：

    注意：这里实现的是以小堆为例

    2.1创建堆

    堆的创建就是创建一个顺序表，然后再进行堆的一系列操作：

    头文件：Heap.h

    1. //创建堆
    2. //顺序表
    3. typedef int HPDataType;
    4.  
    5. typedef struct Heap
    6. {
    7. 	HPDataType* a;
    8. 	int size = 0;  //有效元素个数
    9. 	int capacity;  //容量
    10. }Heap;

    2.2初始化堆

    这些接口实现都比较简单，直接上手即可：

    头文件：Heap.h

    1. //初始化
    2. void HeapInit(Heap* php);

    源文件：Heap.c

    1. //初始化
    2. void HeapInit(Heap* php)
    3. {
    4. 	php->a = NULL;  
    5. 	php->size = 0;
    6. 	php->capacity = 0;
    7. }

    2.3向堆中插入数据

    插入堆在这里插入的是堆的最后面，对应的也就是顺序表的最后一个位置，当插入进去之后还面临一个问题：我们创建的就是小堆，那么插入的数据如果小于它的父亲，就需要向上调整，如果调整之后还小于它新的父亲的，那么还是得继续向上调整，直到符合小根堆的逻辑

    因此插入过程可以分为这么几步：

    1. 先为堆开辟一块空间。

    2. 检测容量，不够还需扩容。

    3. 插入，判断是否需要进行向上调整。

    头文件：Heap.h

    1. //插入
    2. void HeapPush(Heap* php, HPDataType x);

    源文件：Heap.c

    1. //插入
    2. void HeapPush(Heap* php, HPDataType x)
    3. {
    4. 	assert(php);
    5. 	//插入数据的过程
    6. 	//容量不够则需要扩容
    7. 	//判断空间是否不足
    8. 	if (php->size == php->capacity)
    9. 	{
    10. 		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
    11. 		//为堆开辟空间
    12. 		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
    13. 		if (tmp == NULL)
    14. 		{
    15. 			perror("realloc fail");
    16. 			return;
    17. 		}
    18. 		php->capacity = newcapacity;
    19. 		php->a = tmp;
    20. 	}
    21. 	//插入数据
    22. 	php->a[php->size] = x;
    23. 	php->size++;
    24. 	//向上调整
    25. 	AdjustUp(php->a, php->size - 1);
    26. }

    向上调整算法我们再来分装一个函数

    2.4向上调整算法 

    向上调整我们的第一步首先要找它的父亲节点（在顺序表的逻辑下：如果它是左孩子，那么它的父亲节点的下标就是它的下标-1然后除2，如果它是右孩子，那么它的父亲节点的下标就是它的下标-2然后除2，但是呢？我们进行的是整数除法，没有余数，因此无论是左孩子还是右孩子都是使用-1除2的方法进行计算）。第二步判断孩子是否小于父亲，小于的话孩子和父亲就要交换位置，大于的话表示符合小堆逻辑，直接跳出即可，然后再让交换后的父亲节点变为新的孩子节点，然后再求新的父亲节点，依次类推，直到调整到堆顶，堆顶元素的下标为0，那么就表示孩子节点的下标为0时就不需要再调整了，退出即可：

     因此孩子与父亲之间的关系可以总结为：

    1. int Child = Parent*2+1;   //左孩子
    2. int Child = Parent*2+2;  //右孩子
    3. int Parent = (Child-1)/2;  //父亲

    源文件：Heap.c

    1. //交换函数
    2. void Swap(HPDataType* p1, HPDataType* p2)
    3. {
    4. 	HPDataType tmp = *p1;
    5. 	*p1 = *p2;
    6. 	*p2 = tmp;
    7. }
    8. //向上调整算法
    9. void AdjustUp(HPDataType* a, int child)
    10. {
    11. 	//父节点
    12. 	int parent = (child - 1) / 2;
    13. 	//向上交换
    14. 	while (child > 0)
    15. 	{
    16. 		//判断父子大小关系
    17. 		if (a[child] < a[parent])
    18. 		{		
    19. 			//交换
    20. 			Swap(&a[child], &a[parent]);
    21. 			//更新父子关系
    22. 			child = parent;
    23. 			parent = (child - 1) / 2;
    24. 		}
    25. 		else
    26. 		{
    27. 			break;
    28. 		}
    29. 	}
    30. }

    2.5判断堆是否为空

    堆为空的条件就是堆中的有效元素个数为0。

    头文件：Heap.h

    1. //判空
    2. bool HeapEmpty(Heap* php);

    源文件：Heap.c

    1. //判空
    2. bool HeapEmpty(Heap* php)
    3. {
    4. 	assert(php);
    5. 	return php->size == 0;
    6. }

    2.6删除堆中的数据

    删除堆元素时并不是删除最后一个元素，这样删除并没有什么意义，因此删除堆中的元素时删除的是堆顶的元素，那么这里就有两种方法：

    1. 和顺序表的头删一样，直接挪动数据进行覆盖，但是这样做时间复杂度高，而且挪动数据本来就是一件代价比较大的事情，再加上如果挪动数据进行覆盖的话就会将原本的父子关系打乱，父子关系打乱就有点扯淡了。

    2. 将堆顶的数据和最后一个数据交换，然后删除掉最后一个数据，这时将剩下的元素进行向下调整。

    所以删除数据可以分为这几步：

    1. 先判断堆是否为空，为空就不能再删除。

    2. 再交换顶部和最后的数据。

    3. 再将最后一个元素删除。

    4. 再判断是否需要向下调整。

    头文件：Heap.h

    1. //删除
    2. void HeapPop(Heap* php);

    源文件：Heap.c

    1. void HeapPop(Heap* php)
    2. {
    3. 	assert(php);
    4. 	//判断堆是否为空
    5. 	assert(!HeapEmpty(php));
    6. 	//交换堆顶的数据和最后的数据
    7. 	Swap(&php->a[0], &php->a[php->size - 1]);
    8. 	//删除最后的数据
    9. 	php->size--;
    10. 	//向下调整
    11. 	AdjustDown(php->a, php->size, 0);
    12. }

    向下调整算法我们再来分装一个函数

    2.7向下调整算法

    向下调整算法首先我们需要根据孩子与父亲的下标关系找到堆顶元素的左右孩子，然后找出左右孩子中最小的孩子，然后将其交换，然后再将孩子的位置更新为父节点，再继续找新的父亲节点的左右孩子的最小的节点，再进行交换，依次类推，直到交换到最后一个孩子节点（孩子节点小于等于总结点个数）。

    找左右孩子中的最小的我们可以使用假设法，假设左孩子为最小的，然后进行判断，如果不合适，就给左孩子加1，从而得到右孩子，这里还需要注意，如果没有右孩子呢？那就只能和左孩子比较，也就不需要进行比较了（左孩子加一小于等于总结点个数）。

    所以我们在设置向下调整算法的时候需要传堆、元素个数、堆顶的下标。

     源文件：Heap.c

    1. //向下调整
    2. void AdjustDown(HPDataType* a, int n, int parent)
    3. {
    4. 	//假设左孩子为左右孩子中最小的节点
    5. 	int child = parent * 2 + 1;
    6. 	
    7. 	while (child < n)  //当交换到最后一个孩子节点就停止
    8. 	{
    9. 		if (	child + 1 < n  //判断是否存在右孩子
    10. 			&& a[child + 1] < a[child]) //判断假设的左孩子是否为最小的孩子
    11. 		{
    12. 			child++;   //若不符合就转化为右孩子
    13. 		}
    14. 		//判断孩子和父亲的大小关系
    15. 		if (a[child] < a[parent])
    16. 		{
    17. 			Swap(&a[child], &a[parent]);
    18. 			//更新父亲和孩子节点
    19. 			parent = child;
    20. 			child = parent * 2 + 1;
    21. 		}
    22. 		else
    23. 		{
    24. 			break;
    25. 		}
    26. 	}
    27. }

    注意：

    1. 这里的向上调整算法和向下调整算法只适用于堆的操作。

    2. 向上调整算法和向下调整算法的时间复杂度是O(logN)。

    向上调整和向下调整的最好情况是一次都不调整，最坏的情况是调整一个完全二叉树的高度次，又因为完全二叉树的结点个数为一个范围[ 2^(h-1), 2^h-1]。所以将高度于h于结点个数N结合在一起可以算出高度为[ logN+1,log(N+1)]，因此算法的时间复杂度为O(logN)。

    2.8有效元素个数、堆顶元素

    1. 返回堆顶元素时先要判断堆是否为空，堆顶元素的下标就是0，因此直接返回下标为0的元素。

    2. 有效元素的个数就是顺序表中的size，直接返回即可。

    头文件：Heap.h

    1. //有效元素个数
    2. int HeapSize(Heap* php);
    3.  
    4. //获取堆顶元素
    5. HPDataType HeapTop(Heap* php);

    源文件：Heap.c

    1. //有效元素个数
    2. int HeapSize(Heap* php)
    3. {
    4. 	assert(php);
    5. 	return php->size;
    6. }
    7.  
    8. //获取堆顶元素
    9. HPDataType HeapTop(Heap* php)
    10. {
    11. 	assert(php);
    12. 	//判断堆是否为空
    13. 	assert(!HeapEmpty(php));
    14. 	return php->a[0];
    15. }

    2.9代码测试 

    插入测试：

    写完了堆的基本接口之后我们可以调试通过监视窗口来观察一下，我们将一个数据依次插入到堆中，观察他们的变化：

    源文件：Test.c

    1. #include "Heap.h"
    2.  
    3. void HeapTest()
    4. {
    5. 	Heap hp;
    6.  
    7. 	//初始化
    8. 	HeapInit(&hp);
    9.  
    10. 	//插入
    11. 	int arr[] = { 8,5,6,2,1,0,3,4,7,9 };
    12. 	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
    13. 	{
    14. 		HeapPush(&hp, arr[i]);
    15. 	}
    16.  
    17. }
    18.  
    19. int main()
    20. {
    21. 	HeapTest();
    22. 	return 0;
    23. }

    删除测试： 

    1. #include "Heap.h"
    2.  
    3. void HeapTest()
    4. {
    5. 	Heap hp;
    6.  
    7. 	//初始化
    8. 	HeapInit(&hp);
    9.  
    10. 	//插入
    11. 	int arr[] = { 8,5,6,2,1,0,3,4,7,9 };
    12. 	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
    13. 	{
    14. 		HeapPush(&hp, arr[i]);
    15. 	}
    16.  
    17. 	//删除
    18. 	HeapPop(&hp);
    19.  
    20. }
    21.  
    22. int main()
    23. {
    24. 	HeapTest();
    25. 	return 0;
    26. }

    2.10完整代码

    头文件：Heap.h

    1. #pragma once
    2.  
    3. //    堆
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. //创建堆
    11. //顺序表
    12. typedef int HPDataType;
    13.  
    14. typedef struct Heap
    15. {
    16. 	HPDataType* a;
    17. 	int size;  //有效元素个数
    18. 	int capacity;  //容量
    19. }Heap;
    20.  
    21. //初始化
    22. void HeapInit(Heap* php);
    23.  
    24. //销毁
    25. void HeapDestroy(Heap* php);
    26.  
    27. //插入
    28. void HeapPush(Heap* php, HPDataType x);
    29.  
    30. //删除
    31. void HeapPop(Heap* php);
    32.  
    33. //判空
    34. bool HeapEmpty(Heap* php);
    35.  
    36. //有效元素个数
    37. int HeapSize(Heap* php);
    38.  
    39. //获取堆顶元素
    40. HPDataType HeapTop(Heap* php);

    源文件：Heap.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "Heap.h"
    4.  
    5. //初始化
    6. void HeapInit(Heap* php)
    7. {
    8. 	php->a = NULL;  
    9. 	php->size = 0;
    10. 	php->capacity = 0;
    11. }
    12.  
    13. //销毁
    14. void HeapDestroy(Heap* php)
    15. {
    16. 	free(php->a);
    17. 	php->a = NULL;
    18. 	php->size = php->capacity = 0;
    19. }
    20.  
    21. //交换函数
    22. void Swap(HPDataType* p1, HPDataType* p2)
    23. {
    24. 	HPDataType tmp = *p1;
    25. 	*p1 = *p2;
    26. 	*p2 = tmp;
    27. }
    28. //向上调整算法
    29. void AdjustUp(HPDataType* a, int child)
    30. {
    31. 	//父节点
    32. 	int parent = (child - 1) / 2;
    33. 	//向上交换
    34. 	while (child > 0)
    35. 	{
    36. 		//判断父子大小关系
    37. 		if (a[child] < a[parent])
    38. 		{		
    39. 			//交换
    40. 			Swap(&a[child], &a[parent]);
    41. 			//更新父子关系
    42. 			child = parent;
    43. 			parent = (child - 1) / 2;
    44. 		}
    45. 		else
    46. 		{
    47. 			break;
    48. 		}
    49. 	}
    50. }
    51.  
    52. //插入
    53. void HeapPush(Heap* php, HPDataType x)
    54. {
    55. 	assert(php);
    56. 	//插入数据的过程
    57. 	//容量不够则需要扩容
    58. 	//判断空间是否不足
    59. 	if (php->size == php->capacity)
    60. 	{
    61. 		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
    62. 		//为堆开辟空间
    63. 		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
    64. 		if (tmp == NULL)
    65. 		{
    66. 			perror("realloc fail");
    67. 			return;
    68. 		}
    69. 		php->capacity = newcapacity;
    70. 		php->a = tmp;
    71. 	}
    72. 	//插入数据
    73. 	php->a[php->size] = x;
    74. 	php->size++;
    75. 	//向上调整
    76. 	AdjustUp(php->a, php->size - 1);
    77. }
    78.  
    79. //向下调整
    80. void AdjustDown(HPDataType* a, int n, int parent)
    81. {
    82. 	//假设左孩子为左右孩子中最小的节点
    83. 	int child = parent * 2 + 1;
    84. 	
    85. 	while (child < n)  //当交换到最后一个孩子节点就停止
    86. 	{
    87. 		if (	child + 1 < n  //判断是否存在右孩子
    88. 			&& a[child + 1] < a[child]) //判断假设的左孩子是否为最小的孩子
    89. 		{
    90. 			child++;   //若不符合就转化为右孩子
    91. 		}
    92. 		//判断孩子和父亲的大小关系
    93. 		if (a[child] < a[parent])
    94. 		{
    95. 			Swap(&a[child], &a[parent]);
    96. 			//更新父亲和孩子节点
    97. 			parent = child;
    98. 			child = parent * 2 + 1;
    99. 		}
    100. 		else
    101. 		{
    102. 			break;
    103. 		}
    104. 	}
    105. }
    106.  
    107. //删除
    108. void HeapPop(Heap* php)
    109. {
    110. 	assert(php);
    111. 	//判断堆是否为空
    112. 	assert(!HeapEmpty(php));
    113. 	//交换堆顶的数据和最后的数据
    114. 	Swap(&php->a[0], &php->a[php->size - 1]);
    115. 	//删除最后的数据
    116. 	php->size--;
    117. 	//向下调整
    118. 	AdjustDown(php->a, php->size, 0);
    119. }
    120.  
    121.  
    122. //判空
    123. bool HeapEmpty(Heap* php)
    124. {
    125. 	assert(php);
    126. 	return php->size == 0;
    127. }
    128.  
    129. //有效元素个数
    130. int HeapSize(Heap* php)
    131. {
    132. 	assert(php);
    133. 	return php->size;
    134. }
    135.  
    136. //获取堆顶元素
    137. HPDataType HeapTop(Heap* php)
    138. {
    139. 	assert(php);
    140. 	//判断堆是否为空
    141. 	assert(!HeapEmpty(php));
    142. 	return php->a[0];
    143. }
    144.  
    145.

    源文件：Test.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include "Heap.h"
    4.  
    5. void HeapTest()
    6. {
    7. 	Heap hp;
    8.  
    9. 	//初始化
    10. 	HeapInit(&hp);
    11.  
    12. 	//插入
    13. 	int arr[] = { 8,5,6,2,1,0,3,4,7,9 };
    14. 	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
    15. 	{
    16. 		HeapPush(&hp, arr[i]);
    17. 	}
    18.  
    19. 	//删除
    20. 	//HeapPop(&hp);
    21.  
    22. }
    23.  
    24. int main()
    25. {
    26. 	HeapTest();
    27. 	return 0;
    28. }

    朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！

  • 相关阅读:
    队列题目：设计循环双端队列
    Python 使用Scapy构造特殊数据包
    JMeter接口测试工具基础— 取样器sampler（二）
    搭建好自己的PyPi服务器后怎么使用
    【精选】发布应用到应用商店的基本介绍
    计算机网络-----ICMP
    【Git企业开发】第一节.Git 的分支管理
    【JavaScript高级】02-深入JS执行原理：AO、VO及作用域链
    JavaWeb-三大核心组件（Servlet、Filter、Listener）
    Vue知识点：生命周期
  • 原文地址：https://blog.csdn.net/Yikefore/article/details/130819002