• 排序算法：堆排序

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

    数据结构与算法专栏：数据结构与算法

    个  人  主  页 ：stackY、

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

    目录

     

    前言：

    1.堆的应用：堆排序

    1.1直接使用堆进行插入

    1.2向上调整算法建堆

    1.3向下调整算法建堆

    2.算法时间复杂度

    2.1向下调整建堆算法时间复杂度

    2.2向上调整建堆的时间复杂度 

    3.堆排序的时间复杂度 

    4.完整堆排序代码

    前言：

    通过前面的学习和了解我们了解到了二叉树使用顺序结构实现的方式为堆，并且对堆的实现都做了详细的介绍，那么本期我们来看看堆到底都有哪些应用场景呢？

    堆这个数据结构我们经常使用它来进行堆排序和解决Top-K的问题，本期我们先来重点的了解堆是怎么进行排序的呢？

     1.堆的应用：堆排序

    前面我们讲到过冒泡排序和qsort排序，那么本期再来一种新的排序算法，它的效率也是蛮高的。它所要用到的相关知识点就是数据结构：堆

    实现堆排序这里有三种思路：

    1. 直接将数组插入到堆中，然后再将堆中的数据插入到数组中。

    2. 向上调整算法建堆，然后使用堆删除的思想来排序。

    3. 向下调整算法建堆，然后使用堆删除的思想来排序。 

    1.1直接使用堆进行插入

    先创建一个堆，然后将数组中的元素依次插入到堆中，如果是大堆在插入完之后就排序成了降序，然后将堆中的数据依次拷贝到数组中，这样子就完成了排序。

    代码演示：

    1. //    堆
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. //创建堆
    9. //顺序表
    10. typedef int HPDataType;
    11.  
    12. typedef struct Heap
    13. {
    14. 	HPDataType* a;
    15. 	int size;  //有效元素个数
    16. 	int capacity;  //容量
    17. }Heap;
    18.  
    19. //初始化
    20. void HeapInit(Heap* php);
    21.  
    22. //销毁
    23. void HeapDestroy(Heap* php);
    24.  
    25. //插入
    26. void HeapPush(Heap* php, HPDataType x);
    27.  
    28. //删除
    29. void HeapPop(Heap* php);
    30.  
    31. //判空
    32. bool HeapEmpty(Heap* php);
    33.  
    34. //获取堆顶元素
    35. HPDataType HeapTop(Heap* php);
    36.  
    37. //初始化
    38. void HeapInit(Heap* php)
    39. {
    40. 	php->a = NULL;
    41. 	php->size = 0;
    42. 	php->capacity = 0;
    43. }
    44.  
    45. //销毁
    46. void HeapDestroy(Heap* php)
    47. {
    48. 	free(php->a);
    49. 	php->a = NULL;
    50. 	php->size = php->capacity = 0;
    51. }
    52.  
    53. //交换函数
    54. void Swap(HPDataType* p1, HPDataType* p2)
    55. {
    56. 	HPDataType tmp = *p1;
    57. 	*p1 = *p2;
    58. 	*p2 = tmp;
    59. }
    60. //向上调整算法
    61. void AdjustUp(HPDataType* a, int child)
    62. {
    63. 	//父节点
    64. 	int parent = (child - 1) / 2;
    65. 	//向上交换
    66. 	while (child > 0)
    67. 	{
    68. 		//判断父子大小关系
    69. 		if (a[child] < a[parent])
    70. 		{
    71. 			//交换
    72. 			Swap(&a[child], &a[parent]);
    73. 			//更新父子关系
    74. 			child = parent;
    75. 			parent = (child - 1) / 2;
    76. 		}
    77. 		else
    78. 		{
    79. 			break;
    80. 		}
    81. 	}
    82. }
    83.  
    84. //插入
    85. void HeapPush(Heap* php, HPDataType x)
    86. {
    87. 	assert(php);
    88. 	//插入数据的过程
    89. 	//容量不够则需要扩容
    90. 	//判断空间是否不足
    91. 	if (php->size == php->capacity)
    92. 	{
    93. 		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
    94. 		//为堆开辟空间
    95. 		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
    96. 		if (tmp == NULL)
    97. 		{
    98. 			perror("realloc fail");
    99. 			return;
    100. 		}
    101. 		php->capacity = newcapacity;
    102. 		php->a = tmp;
    103. 	}
    104. 	//插入数据
    105. 	php->a[php->size] = x;
    106. 	php->size++;
    107. 	//向上调整
    108. 	AdjustUp(php->a, php->size - 1);
    109. }
    110.  
    111. //向下调整
    112. void AdjustDown(HPDataType* a, int n, int parent)
    113. {
    114. 	//假设左孩子为左右孩子中最小的节点
    115. 	int child = parent * 2 + 1;
    116.  
    117. 	while (child < n)  //当交换到最后一个孩子节点就停止
    118. 	{
    119. 		if (child + 1 < n  //判断是否存在右孩子
    120. 			&& a[child + 1] < a[child]) //判断假设的左孩子是否为最小的孩子
    121. 		{
    122. 			child++;   //若不符合就转化为右孩子
    123. 		}
    124. 		//判断孩子和父亲的大小关系
    125. 		if (a[child] < a[parent])
    126. 		{
    127. 			Swap(&a[child], &a[parent]);
    128. 			//更新父亲和孩子节点
    129. 			parent = child;
    130. 			child = parent * 2 + 1;
    131. 		}
    132. 		else
    133. 		{
    134. 			break;
    135. 		}
    136. 	}
    137. }
    138.  
    139. //删除
    140. void HeapPop(Heap* php)
    141. {
    142. 	assert(php);
    143. 	//判断堆是否为空
    144. 	assert(!HeapEmpty(php));
    145. 	//交换堆顶的数据和最后的数据
    146. 	Swap(&php->a[0], &php->a[php->size - 1]);
    147. 	//删除最后的数据
    148. 	php->size--;
    149. 	//向下调整
    150. 	AdjustDown(php->a, php->size, 0);
    151. }
    152.  
    153. //判空
    154. bool HeapEmpty(Heap* php)
    155. {
    156. 	assert(php);
    157. 	return php->size == 0;
    158. }
    159.  
    160. //获取堆顶元素
    161. HPDataType HeapTop(Heap* php)
    162. {
    163. 	assert(php);
    164. 	//判断堆是否为空
    165. 	assert(!HeapEmpty(php));
    166. 	return php->a[0];
    167. }
    168.  
    169. //堆排序
    170. void HeapSort(int* a, int n)
    171. {
    172. 	//建堆
    173. 	Heap hp;
    174. 	HeapInit(&hp);
    175. 	//将数组先插入到堆中实现堆中的大小堆排序
    176. 	for (int i = 0; i < n; i++)
    177. 	{
    178. 		HeapPush(&hp, a[i]);
    179. 	}
    180. 	//再将堆中的数据拷贝到数组中
    181. 	int i = 0;
    182. 	while (!HeapEmpty(&hp))
    183. 	{
    184. 		//保存堆顶元素
    185. 		int top = HeapTop(&hp);
    186. 		//拷贝
    187. 		a[i++] = top;
    188. 		HeapPop(&hp);
    189. 	}
    190. 	HeapDestroy(&hp);
    191. }
    192.  
    193. int main()
    194. {
    195. 	int a[] = { 5,6,8,9,7,4,5,2,3,6 };
    196. 	int sz = sizeof(a) / sizeof(int);
    197. 	HeapSort(a, sz);
    198. 	return 0;
    199. }

    我们在这里建的是小堆，所以是排成了升序的状态，建大堆只要将向上调整和向下调整的小于号换成大于号即可。

    这种算法有点弊端：

    1. 必须先要有一个堆，太麻烦。

    2. 将数组的数据拷贝至堆，又将堆的数据拷贝至数组，空间复杂度上面代价有点大。

    但是这种算法的时间复杂度也是不错的，在前面我们讲堆的时候提到过向上调整算法和向下调整算法，这两种算法的时间复杂度都是O(logN)，那么在这个堆排序的算法中的时间复杂度加上遍历数组的时间复杂度合起来为O(N*logN)。

    1.2向上调整算法建堆

    在使用向上调整算法和向下调整算法的时候如果要达到降序的目的应该建大堆还是小堆？如果要达到升序的目的应该建大堆还是小堆？

    我们在这里来思考一下：

    按照以往的思路：要排成降序需要建大堆，这样就保证了最大的一个在堆顶，然后将除了堆顶剩下的数据看作一个堆，再找到次大的，这时就面临两个问题：

    1. 将剩下的数据看作一个堆时又需要重新建堆，代价有点大。

    2. 如果将剩下的数据重新建堆，那么它们原来的父子关系就乱套了，从之前的兄弟变成父子或许有点扯淡。

    那么我们就来换一种思路，这种思路和删除数据时的思路一样，我们要排成降序我们就建小堆，那么这时堆顶的数据就是最小的，然后将堆顶的数据和最后一个数据交换，这时堆的最后一个数据就是最小的，此时，就不需要将最后一个数据看作堆中的数据，然后再对剩余数据进行向下调整，再找出次小的，再交换至倒数第二个位置......这样子依次类推，直到全部找出来。同样的，要排成升序就建大堆，找出最大的交换，再找次大的，再交换......依次类推同样也可以完成升序。

    这里还有需要注意的一个点，我们要从哪里开始进行向上调整建堆？之前说过向上调整算法调整的节点的上面必须是一个堆，因此我们需要从第一个结点开始进行向上调整建堆，因为第一个结点就是一个堆，所以我们将第一个结点看作堆，然后从第二个位置开始插入，前面的结点是堆，符合。

    代码演示：

    1. //交换函数
    2. void Swap(int* p1, int* p2)
    3. {
    4. 	int tmp = *p1;
    5. 	*p1 = *p2;
    6. 	*p2 = tmp;
    7. }
    8.  
    9. //向上调整算法
    10. void AdjustUp(int* a, int child)
    11. {
    12. 	//父节点
    13. 	int parent = (child - 1) / 2;
    14. 	//向上交换
    15. 	while (child > 0)
    16. 	{
    17. 		//判断父子大小关系
    18. 		if (a[child] < a[parent])
    19. 		{
    20. 			//交换
    21. 			Swap(&a[child], &a[parent]);
    22. 			//更新父子关系
    23. 			child = parent;
    24. 			parent = (child - 1) / 2;
    25. 		}
    26. 		else
    27. 		{
    28. 			break;
    29. 		}
    30. 	}
    31. }
    32.  
    33. //向下调整
    34. void AdjustDown(int* a, int n, int parent)
    35. {
    36. 	//假设左孩子为左右孩子中最小的节点
    37. 	int child = parent * 2 + 1;
    38.  
    39. 	while (child < n)  //当交换到最后一个孩子节点就停止
    40. 	{
    41. 		if (child + 1 < n  //判断是否存在右孩子
    42. 			&& a[child + 1] < a[child]) //判断假设的左孩子是否为最小的孩子
    43. 		{
    44. 			child++;   //若不符合就转化为右孩子
    45. 		}
    46. 		//判断孩子和父亲的大小关系
    47. 		if (a[child] < a[parent])
    48. 		{
    49. 			Swap(&a[child], &a[parent]);
    50. 			//更新父亲和孩子节点
    51. 			parent = child;
    52. 			child = parent * 2 + 1;
    53. 		}
    54. 		else
    55. 		{
    56. 			break;
    57. 		}
    58. 	}
    59. }
    60.  
    61. void HeapSort(int* a, int n)
    62. {
    63. 	//建堆--向上调整算法建堆
    64. 	//模拟的是一个插入堆的过程
    65. 	for (int i = 1; i < n; i++)
    66. 	{
    67. 		AdjustUp(a, i);
    68. 	}
    69.  
    70. 	int end = n - 1;
    71. 	while (end > 0)
    72. 	{
    73. 		//交换堆顶和最后一个数据的位置
    74. 		Swap(&a[0], &a[end]);
    75. 		//向下调整，找次小的
    76. 		AdjustDown(a, end, 0);
    77. 		end--;
    78. 	}
    79. }
    80.  
    81. int main()
    82. {
    83. 	int a[] = { 5,6,8,9,7,4,5,2,3,6 };
    84. 	int sz = sizeof(a) / sizeof(int);
    85. 	HeapSort(a, sz);
    86. 	return 0;
    87. }

    我们在这里建的是小堆，所以是排成了降序的状态，建大堆只要将向上调整和向下调整的小于号换成大于号即可。

    1.3向下调整算法建堆

    排降序建小堆，排升序建大堆，当我们使用向上调整算法来建堆实现堆排序时，需要用到向上调整算法和向下调整算法，这个有点太麻烦，那既然在交换数据之后要进行向下调整，那不妨直接使用向下调整算法来直接建堆。

    向下调整算法使用的前提是向下调整的结点的下面必须是堆，我们不妨画图来观察一下：

    我们知道一个叶子节点本身就是大堆或者小堆，因此我们可以在叶子节点上面下下功夫。

    向下调整算法的下面必须是堆：
    而叶子节点恰好又是堆，那么叶子节点就可以不用处理，那么我们就可以倒着来进行建堆，从最后一个非叶子节点开始调整（倒数第一个叶子节点的父亲开始调整）。根据孩子与父亲的关系找到父亲然后调整建堆，由于叶子节点本身就是堆，从它的父亲开始调整也符合向下调整算法的逻辑。

    代码演示：

    1. //交换函数
    2. void Swap(int* p1, int* p2)
    3. {
    4. 	int tmp = *p1;
    5. 	*p1 = *p2;
    6. 	*p2 = tmp;
    7. }
    8.  
    9. //向下调整
    10. void AdjustDown(int* a, int n, int parent)
    11. {
    12. 	//假设左孩子为左右孩子中最小的节点
    13. 	int child = parent * 2 + 1;
    14.  
    15. 	while (child < n)  //当交换到最后一个孩子节点就停止
    16. 	{
    17. 		if (child + 1 < n  //判断是否存在右孩子
    18. 			&& a[child + 1] < a[child]) //判断假设的左孩子是否为最小的孩子
    19. 		{
    20. 			child++;   //若不符合就转化为右孩子
    21. 		}
    22. 		//判断孩子和父亲的大小关系
    23. 		if (a[child] < a[parent])
    24. 		{
    25. 			Swap(&a[child], &a[parent]);
    26. 			//更新父亲和孩子节点
    27. 			parent = child;
    28. 			child = parent * 2 + 1;
    29. 		}
    30. 		else
    31. 		{
    32. 			break;
    33. 		}
    34. 	}
    35. }
    36.  
    37. void HeapSort(int* a, int n)
    38. {
    39. 	//建堆--向下调整算法建堆
    40.  
    41. 	for (int i = ((n - 1) - 1) / 2; i >= 0; --i)
    42. 	{//       这里的n-1表示最后一个叶子节点
    43. 		//       最后一个叶子节点的父亲就是：
    44. 		//           （n-1）-1 /2；
    45. 		AdjustDown(a, n, i);
    46. 	}
    47.  
    48. 	int end = n - 1;
    49. 	while (end > 0)
    50. 	{
    51. 		//交换堆顶和最后一个数据的位置
    52. 		Swap(&a[0], &a[end]);
    53. 		//向下调整，找次小的
    54. 		AdjustDown(a, end, 0);
    55. 		end--;
    56. 	}
    57. }
    58.  
    59. int main()
    60. {
    61. 	int a[] = { 5,6,8,9,7,4,5,2,3,6 };
    62. 	int sz = sizeof(a) / sizeof(int);
    63. 	HeapSort(a, sz);
    64. 	return 0;
    65. }

    2.算法时间复杂度

    一个算法的好与坏取决与它的时间和空间，那么对于向上调整建堆和向下调整建堆哪种方法的时间复杂度更优呢？我们可以一一来计算一下。

     2.1向下调整建堆算法时间复杂度

    假设二叉树的高度为h，总结点个数为N

    第1层: 有2^0个节点，需要向下挪动h-1次
    第2层: 有2^1个节点，需要向下挪动h-2次
    第3层: 有2^2个节点，需要向下挪动h-3次
    ......
    第h-1层: 有2^(h-2)个节点，需要向下挪动1次
    第h层: 有2^(h-1)个节点，需要向下挪动0次

    总共合计需要挪动：

    F(h) = 2^(h-2) * 1 + 2^(h-3) * 2 + ...... + 2^1 * (h-2) + 2^0 * (h-1)

    使用错位相减法：

    2F(h) = 2^(h-1) * 1 + 2^(h-2) * 2 + 2^(h-3) * 2 + ...... + 2^2 * (h-2) + 2^1 * (h-1)

     -

      F(h) =                      2^(h-2) * 1 + 2^(h-3) * 2 + ...... + 2^1 * (h-2) + 2^0 * (h-1)

           

    F(h)  = 2^h - 1 - h

    这棵树的中的节点的个数为N = 2^h-1 ==>  h = log(N+1)

    F(N) = N - log(N+1)

    因此向下调整算法的时间复杂度为O(N)

    2.2向上调整建堆的时间复杂度 

     向上调整很明显就是一个多乘多的问题，单单只看最后一层，节点越多，调整的次数越多，那这就完蛋了，向下调整算法最后一层的节点时不需要调整的，那这就很明显了，向下调整算法明显优势于向上调整算法，那么到底能快多少呢？我们一起来计算一下：

    假设二叉树的高度为h，总结点个数为N

    第1层: 有2^0个节点，需要向下挪动0次
    第2层: 有2^1个节点，需要向下挪动1次
    第3层: 有2^2个节点，需要向下挪动2次
    ......
    第h-1层: 有2^(h-2)个节点，需要向下挪动h-2次
    第h层: 有2^(h-1)个节点，需要向下挪动h-1次

    总共合计需要挪动：

    F(h) = 2^1 * 1 + 2^2 * 2 + ...... + 2^(h-2) * (h-2) + 2^(h-1) * (h-1)

    使用错位相减法：

    2F(h) =                  2^2 * 1 + 2^3 * 2 + ...... + 2^(h-1) * (h-2) + 2^h * (h-1)
     - 
     F(h) =   2^1 * 1 + 2^2 * 2 + ...... + 2^(h-2) * (h-2) + 2^(h-1) * (h-1)

    F(h) = 2^1 * 1 + 2^2 * 2 + ...... + 2^(h-2) * (h-2) + 2^(h-1) * (h-1)
           = - 2^1 - 2^2 - 2^3 - ...... - 2^(h-2) - 2^(h-1) + 2^h * (h-1)
           = - 2^h + 2 - 2^h + 2^h * h
           = 2^h * (h-2) + 2

    这棵树的中的节点的个数为N = 2^h-1 ==>  h = log(N+1)

    F(N) = (N + 1) * (log(N + 1) - 2) + 2

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

    3.堆排序的时间复杂度 

    计算出了向下调整建堆的时间复杂度，我们再来看看堆排序算法的整体的时间复杂度。

    这时我们就要计算筛选数据操作时的交换数据和向下调整的时间复杂度：

    这里为什么最上面的反而不用向下调整那么多次了，是因为在调整上面的数据时，下面的数据已经是一个堆了，所以筛选数据的过程就和向上调整建堆的时间复杂度一样。

    时间复杂度是O(N * logN )

    那么再加上向下调整建堆的时间复杂度就是O(N) + O(N * logN)

    所以整个堆排序算法的时间复杂度为O（N * logN）

    4.完整堆排序代码

    1. //交换函数
    2. void Swap(int* p1, int* p2)
    3. {
    4. 	int tmp = *p1;
    5. 	*p1 = *p2;
    6. 	*p2 = tmp;
    7. }
    8.  
    9. //向下调整
    10. void AdjustDown(int* a, int n, int parent)
    11. {
    12. 	//假设左孩子为左右孩子中最小的节点
    13. 	int child = parent * 2 + 1;
    14.  
    15. 	while (child < n)  //当交换到最后一个孩子节点就停止
    16. 	{
    17. 		if (child + 1 < n  //判断是否存在右孩子
    18. 			&& a[child + 1] < a[child]) //判断假设的左孩子是否为最小的孩子
    19. 		{
    20. 			child++;   //若不符合就转化为右孩子
    21. 		}
    22. 		//判断孩子和父亲的大小关系
    23. 		if (a[child] < a[parent])
    24. 		{
    25. 			Swap(&a[child], &a[parent]);
    26. 			//更新父亲和孩子节点
    27. 			parent = child;
    28. 			child = parent * 2 + 1;
    29. 		}
    30. 		else
    31. 		{
    32. 			break;
    33. 		}
    34. 	}
    35. }
    36.  
    37. //O(N * logN)
    38. void HeapSort(int* a, int n)
    39. {
    40. 	//建堆--向下调整算法建堆
    41. 	//时间复杂度为O(N)
    42. 	for (int i = ((n - 1) - 1) / 2; i >= 0; --i)
    43. 	{//       这里的n-1表示最后一个叶子节点
    44. 		//       最后一个叶子节点的父亲就是：
    45. 		//           （n-1）-1/2；
    46. 		AdjustDown(a, n, i);
    47. 	}
    48.  
    49. 	//O(N * logN)
    50. 	int end = n - 1;
    51. 	while (end > 0)
    52. 	{
    53. 		//交换堆顶和最后一个数据的位置
    54. 		Swap(&a[0], &a[end]);
    55. 		//向下调整，找次小的
    56. 		AdjustDown(a, end, 0);
    57. 		end--;
    58. 	}
    59. }
    60.  
    61. int main()
    62. {
    63. 	int a[] = { 5,6,8,9,7,4,5,2,3,6 };
    64. 	int sz = sizeof(a) / sizeof(int);
    65. 	HeapSort(a, sz);
    66. 	return 0;
    67. }

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

  • 相关阅读:
    linux查看外网ip的5种方法
    餐饮+KTV融合消费模式，会受消费者喜欢吗？
    RAW RGB YUV数据差异
    【workaround】可执行文件（编译时）glibc版本小于运行环境（运行时）glibc版本
    ELK整合springboot(第二课)
    JavaScript：预解析
    array 数组相关方法
    怎么重构数据库表结构
    ubuntu18.04安装docker
    nginx 反向代理 负载均衡 动静分离
  • 原文地址：https://blog.csdn.net/Yikefore/article/details/130898929