• 【初阶数据结构】堆排序和TopK问题

    综述：

    1. 堆排序：排序算法，时间复杂度O(NlogN)
    2. TopK问题：一堆数据前K大或前K小

    目录

    综述：

    1.堆的基本结构

     2.堆的插入删除

    2-1用数组下标计算父子关系：

     2-2堆上插入元素-向上调整算法

     2-3删除堆顶元素-向下调整算法

     2-4完整代码

    3.两种方法建堆:

    3-1向上调整法建堆

    3-2向下调整法建堆

    3-3.完整代码

    3-4.两种建堆方式的时间复杂度

    4.堆排序

     5.TopK问题

    1.堆的基本结构

    数据结构的堆和我们在操作系统里的堆不同，我们要讲的堆就是数据结构的堆。

    堆的逻辑结构（完全二叉树）和物理结构（数组）

    这里的堆是一个小根堆，（堆只分为大根堆和小根堆）
    ps:小根堆： 堆的逻辑结构（完全二叉树中）的任意一个结点值必须大于他的左孩子和右孩子的结点值,大根堆同理。

    值得注意的是这里即使是小根堆但依然不是有序的，通过小根堆我们能直接获取到的是最小值。

    PS：大小堆都只是父子之间的大小关系，兄弟之间是没有大小关系的
    所以下面让我们看看如何对堆进行排序。

    堆只有大根堆和小跟堆，

     2.堆的插入删除

    堆的核心就是插入数据和删除数据

    2-1用数组下标计算父子关系：

    leftchild=2*parent+1;

    rightchild=2*parent+2;

    parent=(child-1)/2; 

    我用下图理解了上面的child不分leftchild和rightchild的原因。（看不懂可以按自己的方式理解）

     2-2堆上插入元素-向上调整算法

    如果在小根堆上插入一个数据，由于堆的物理结构是数组，我们采用顺序表实现，同时，如果只是简单的在数组的最后面插入一个数据，这是相当简单的，但是我们为了在插入新数据后能够继续保持堆的形态，我们通常在插入一个新数据后采用向上调整算法来实现。

    向上调整法使用前提：树本身就是大堆或者小堆
    时间复杂度：LogN

    纠正上图：应该是向上调整算法，下图是向上调整法的图解实现
    你是否有一个问题就是为什么在将12向上调整的时候，只用关心12的祖先的大小关系
    在换的过程中不会打乱除了祖先外的结点和祖先结点的大小关系吗？
    答案：不会，因为这本来就是小根堆，如果某结点要下移来交换，移下来的结点换下来之后一定比最原先在换下来的那个位置的结点值还更小，所以一定能够保证换下来之后不会造成父子关系乱掉。

    那么向上调整法的代码实现是什么样的呐？如下

    1. typedef struct Heap
    2. {
    3. 	int* a;
    4. 	int size;
    5. 	int capacity;
    6. }HP;
    7.  
    8. void AdjustUp(int* a, int child)
    9. {
    10. 	assert(a);
    11. 	int parent = (child - 1) / 2;
    12. 	while (child > 0)//循环里写的是继续的条件while(满足):child==0时跳出循环
    13. 	{
    14. 		if (a[child] < a[parent])
    15. 		{
    16. 			Swap(&a[child], &a[parent]);
    17. 			child = parent;
    18. 			parent = (child - 1) / 2;
    19. 		}
    20. 		else
    21. 		{
    22. 			break;
    23. 		}
    24. 	}
    25. }
    26.  
    27. //插入X后继续保持堆形态
    28. void HeapPush(HP* php, int x)
    29. {
    30. 	assert(php);
    31. 	if (php->size == php->capacity)
    32. 	{
    33. 		int newcapacity = 2 * php->capacity;
    34. 		int* temp = (int*)realloc(php->a, sizeof(int) * newcapacity);
    35. 		if (temp == NULL)
    36. 		{
    37. 			perror("realloc fail.\n");
    38. 			exit(-1);
    39. 		}
    40. 		php->a = temp;
    41. 		php->capacity = newcapacity;
    42. 	}
    43. 	php->a[php->size] = x;
    44. 	php->size++;
    45.  
    46. 	//向上调整算法，传要调整的数组和从哪个下标child开始调
    47. 	AdjustUp(php->a, php->size - 1);
    48. }

    HeapPush函数的内容和原来顺序表不同的是在插入新数据X后进行了向上调整，因此我们的关注点只需放在AdjustUp函数。

    1. int main()
    2. {
    3. 	int a[] = { 10,2,20,4,12,67,56,1 };
    4. 	int size = sizeof(a) / sizeof(a[0]);
    5. 	HP heap;
    6. 	HeapInit(&heap);
    7. 	for (int i = 0; i < size; i++)
    8. 	{
    9. 		HeapPush(&heap, a[i]);
    10.     }
    11. 	HeapPrint(&heap);
    12. 	HeapDestory(&heap);
    13. 	return 0;
    14.  }

    测试用例：10,2,20,4,12,67,56,1

    写成完全二叉树的形式：（预期结果：小根堆）

    结果：小根堆，代码无误~~

     要是我想得到大根堆改如何改呐？

    小根堆就是要把小的换上去

    大根堆就是要把大的换上去

    因此同样顺序表插入代码，只需在调整部分稍作修改

    也就是只需改一下调整部分代码的判断条件

     2-3删除堆顶元素-向下调整算法

    错误的顺序表式删除头：

    正确的删除堆顶元素方式：向下调整算法
    前提：堆顶的把左子树和右子树都是大堆或者小堆。
    向下调整算法：将要删除的堆顶元素和数组的最后一个元素先做一个交换，交换后覆盖删除数组的最后一个元素，，将堆顶元素做一次向下调整。

    1. void HeapAdjustDown(int* a, int n, int parent)
    2. {
    3. 	int minchild = 2 * parent + 1;
    4. 	while (minchild < n)
    5. 	{
    6. 		if (minchild + 1 < n && a[minchild] > a[minchild + 1])
    7. 		{
    8. 			minchild++;
    9. 		}
    10. 		if (a[minchild] < a[parent])
    11. 		{
    12. 			Swap(&a[minchild], &a[parent]);
    13. 			parent = minchild;
    14. 			minchild = 2 * parent + 1;
    15. 		}
    16. 		else
    17. 		{
    18. 			break;
    19. 		}
    20. 	}
    21. }
    22.  
    23. //删除堆顶元素，找到次小或次大的元素
    24. //删除之后仍要尽量保持堆的形态
    25. void HeapPop(HP* php)
    26. {
    27. 	assert(php);
    28. 	Swap(&php->a[0], &php->a[php->size - 1]);
    29. 	php->size--;
    30. 	HeapAdjustDown(php->a, php->size-1,0);
    31. }

     

     

     

    2-4完整代码

    1. #include<stdio.h>
    2. #include<assert.h>
    3. #include<stdlib.h>
    4. #include<stdbool.h>
    5.  
    6. typedef struct Heap
    7. {
    8. 	int* a;
    9. 	int size;
    10. 	int capacity;
    11. }HP;
    12.  
    13. void HeapInit(HP* php)
    14. {
    15. 	assert(php);
    16. 	php->a = (int*)malloc(sizeof(HP) * 4);
    17. 	php->size = 0;
    18. 	php->capacity = 4;
    19. }
    20.  
    21. void HeapDestory(HP* php)
    22. {
    23. 	assert(php);
    24. 	php->a = NULL;
    25. 	php->size = php->capacity = 0;
    26. }
    27.  
    28. void Swap(int* a, int* b)
    29. {
    30. 	int temp = *a;
    31. 	*a = *b;
    32. 	*b = temp;
    33. }
    34.  
    35. void AdjustUp(int* a, int child)
    36. { 
    37. 	assert(a);
    38. 	int parent = (child - 1) / 2;
    39. 	while (child > 0)
    40. 	{
    41. 		if (a[child] < a[parent])
    42. 		{
    43. 			Swap(&a[child], &a[parent]);
    44. 			child = parent;
    45. 			parent = (child - 1) / 2;
    46. 		}
    47. 		else
    48. 		{
    49. 			break;
    50. 		}
    51. 	}
    52. }
    53.  
    54. //插入X后继续保持堆形态
    55. void HeapPush(HP* php, int x)
    56. {
    57. 	assert(php);
    58. 	if (php->size == php->capacity)
    59. 	{
    60. 		int newcapacity = 2 * php->capacity;
    61. 		int* temp = (int*)realloc(php->a, sizeof(int) * newcapacity);
    62. 		if (temp == NULL)
    63. 		{
    64. 			perror("realloc fail.\n");
    65. 			exit(-1);
    66. 		}
    67. 		php->a = temp;
    68. 		php->capacity = newcapacity;
    69. 	}
    70. 	php->a[php->size] = x;
    71. 	php->size++;
    72.  
    73. 	//向上调整算法，传要调整的数组和从哪个下标child开始调
    74. 	AdjustUp(php->a, php->size - 1);
    75. }
    76.  
    77. void HeapAdjustDown(int* a, int n, int parent)
    78. {
    79. 	int minchild = 2 * parent + 1;
    80. 	while (minchild < n)
    81. 	{
    82. 		if (minchild + 1 < n && a[minchild] > a[minchild + 1])
    83. 		{
    84. 			minchild++;
    85. 		}
    86. 		if (a[minchild] < a[parent])
    87. 		{
    88. 			Swap(&a[minchild], &a[parent]);
    89. 			parent = minchild;
    90. 			minchild = 2 * parent + 1;
    91. 		}
    92. 		else
    93. 		{
    94. 			break;
    95. 		}
    96. 	}
    97. }
    98.  
    99. //删除堆顶元素，找到次小或次大的元素
    100. //删除之后仍要尽量保持堆的形态
    101. void HeapPop(HP* php)
    102. {
    103. 	assert(php);
    104. 	Swap(&php->a[0], &php->a[php->size - 1]);
    105. 	php->size--;
    106. 	HeapAdjustDown(php->a, php->size-1,0);
    107. }
    108.  
    109. bool HeapEmpty(HP* php);
    110. int HeapTop(HP* php)
    111. {
    112. 	assert(php);
    113. 	assert(!HeapEmpty(php));
    114. 	return php->a[0];
    115. }
    116.  
    117. bool HeapEmpty(HP* php)
    118. {
    119. 	assert(php);
    120. 	return php->size == 0;
    121. }
    122.  
    123. int HeapSize(HP* php)
    124. {
    125. 	assert(php);
    126. 	return php->size;
    127. }
    128.  
    129. void HeapPrint(HP* php)
    130. {
    131. 	assert(php);
    132. 	for (int i = 0; i < php->size; i++)
    133. 	{
    134. 		printf("%d  ", php->a[i]);
    135. 	}
    136. }
    137.  
    138. int main()
    139. {
    140. 	int a[] = { 10,2,20,4,12,67,56,1 };
    141. 	int size = sizeof(a) / sizeof(a[0]);
    142. 	HP heap;
    143. 	HeapInit(&heap);
    144. 	for (int i = 0; i < size; i++)
    145. 	{
    146. 		HeapPush(&heap, a[i]);
    147.     }
    148. 	HeapPop(&heap);
    149. 	HeapPrint(&heap);
    150. 	HeapDestory(&heap);
    151. 	return 0;
    152.  }

    3.两种方法建堆:

    从上面我们可以知道：我们已经学会了建堆以及堆的插入删除数据。
    但是我们知道我们建好的堆并不是有序的，而且堆中的数组和待的数组还不是同一个数组，这就意味着如果要使待排序的数组有序的话，还得将堆中的数据通过heapTop函数和HeapPop函数不断先取出堆顶元素插入到待排序数组，后删除堆顶元素（向下调整法）....

    最重要的话这样的话还会导致我们使用额外的空间来拷贝待排序的数组来建堆

    因此问题来了：怎么将数组本身建立成一个堆，从而减少额外空间的开辟
    如果随便给你一个数组,元素向后顺序随机,要你把这个数组建成一个小根堆.    (比如 14, 12, 4, 3, 6, 68, 21, 2 )

    3-1向上调整法建堆

    向上调整法的使用前提:每插入一个元素前,原数组的逻辑二叉树必须是一个小根堆(大根堆).

    那么我们可以把14默认为是一个符合前提的堆,然后从12往后不断向数组中插入元素,并不断向上调整,直至把整个数组元素全部插完,即完成堆的建立.

    1. 	//向上调整法建堆
    2. 	for (int i = 0; i < n; i++)
    3. 	{
    4. 		AdjustUp(a, i);
    5. 	}

     

    3-2向下调整法建堆

    向下调整法使用的前提:左子树和右子树必须是小根堆(大根堆)

    由于排序的数组是随机给的,所以对于堆顶元素来说,其左子树和右子树大大部分都不是小根堆(大根堆),所以不能从第一个数组元素(堆顶)开始向下调整;同时,叶子节点不需要向下调整,所以我们采用从倒数第一个非叶子节点开始向下调整(当然如果代码中写的是从叶子节点开始向下调整,结果也没有问题,但是就是多次一举而已);

    1. 	向下调整法建堆
    2. 	//for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    3. 	//{
    4. 	//	HeapAdjustDown(a, n, i);
    5. 	//}

    3-3.完整代码

    1. void HeapSort(int* a, int n)
    2. {
    3. 	//向上调整法建堆
    4. 	for (int i = 0; i < n; i++)
    5. 	{
    6. 		AdjustUp(a, i);
    7. 	}
    8. 	
    9. 	向下调整法建堆
    10. 	//for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    11. 	//{
    12. 	//	HeapAdjustDown(a, n, i);
    13. 	//}
    14. }
    15.  
    16. void HeapPrint2(int* a, int n)
    17. {
    18. 	assert(a);
    19. 	for (int i = 0; i < n; i++)
    20. 	{
    21. 		printf("%d  ", a[i]);
    22. 	}
    23. }
    24.  
    25.  
    26.  
    27. int main()
    28. {
    29. 	int a[]={ 14, 12, 4, 3, 6, 68, 21, 2 };
    30. 	int sz = sizeof(a) / sizeof(a[0]);
    31. 	HeapSort(a, sz);
    32. 	HeapPrint2(a, sz);
    33.  
    34. 	return 0;
    35. }

    3-4.两种建堆方式的时间复杂度

    时间复杂度=总调整次数=每一层节点个数*该层需要调整的次数

     向下调整法建堆:LogN

     

     向上调整法建立堆:NLogN

     分析向上调整法和向下调整法建堆时间复杂度相差这么大的原因:

    因为向下调整法的节点数量多的时候,需要调整的次数就少;

    而向上调整法的节点数量多的时候,需要调整的次数也越多;

    4.堆排序

    前面我们学会了如何去高效的建立堆,其中我们优先采用时间复杂度更小的向下调整法建堆

    我们直接在数组上建立了堆,那我们就可以接着通过选数,把数组进行排序,从而完成堆排序

    那么问题又来了:如果我要排升序,我们应该建大堆还是小堆呐?

    让我们想一想,如果要排升序,如果我们建立的是小堆的话,我们的确可以轻松的选出最小的数,但是如果我们在选次小的数的时候,就不得不破坏整个堆的结构,父子关系全乱了(和堆的插入和删除那里一样),这样下来重新建堆的话就是O(N)的时间复杂度;要选N个数,选一次数就要重新建一次堆的话,时间复杂度总体上就是O(N*N),那还不如直接遍历数组n次,也是N方,这样简直是拿着一手好牌,却打的稀烂!

    所以我们升序的话采用建大堆的方式,那又有一个问题,建大堆后又是如何选出次小的呐?请往下看~~

     

     代码如下:(在原来的基础上增加的选数的代码完成堆排序)

    1. void HeapSort(int* a, int n)
    2. {
    3.  
    4. 	//向下调整法建堆,时间复杂度:O(N)
    5. 	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    6. 	{
    7. 		HeapAdjustDown(a, n, i);
    8. 	}
    9.  
    10. 	//升序-建小堆
    11. 	//降序-建大堆
    12.  
    13. 	//选数:堆排序
    14. 	int i = 1;
    15. 	//时间复杂度:O(NLogN)
    16. 	while (i < n)
    17. 	{
    18. 		Swap(&a[0], &a[n - i]);
    19. 		HeapAdjustDown(a, n - i, 0);
    20. 		++i;
    21. 	}
    22. }

     5.TopK问题

    在一堆数中,我们如果要找前K个最大的数,该怎么做?

    或许你脑海里最先想到的是用快排先排序,然后直接选择前K个数据，那代价有点大.

    这里鉴于选择排序中的堆排序的选数的经验,我们考虑采用堆的选数的思想解决这个问题.

    （这里因为数据量过大，担心内存空间不够大，我们选择在磁盘上存储这些数据）

     这时我们优先选择建小堆，我们建一个K个数的小堆，然后将后N-K个数和堆顶元素比较，如果堆顶元素小于后N-K个树数，就交换，然后向下调整，以此类推。

    1. #include<time.h>
    2.  
    3. void CreateFileName(const char* filename, int N)
    4. {
    5. 	FILE* pf = fopen(filename, "w");
    6. 	if (pf == NULL)
    7. 	{
    8. 		perror("fopen\n");
    9. 		exit(-1);
    10. 	}
    11.  
    12. 	//生成随机数
    13. 	srand(time(0));
    14. 	for (int i = 0; i < N; i++)
    15. 	{
    16. 		fprintf(pf, "%d ", rand() % 10000 + 1);
    17. 	}
    18.  
    19. 	fclose(pf);
    20. 	pf = NULL;
    21. }
    22.  
    23. void PrintTopK(const char* filename, int k)
    24. {
    25. 	FILE* pf = fopen(filename, "r");
    26. 	if (pf == NULL)
    27. 	{
    28. 		perror("fopen\n");
    29. 		exit(-1);
    30. 	}
    31.  
    32. 	//文件读取前K个数
    33. 	int* minHeap = (int*)malloc(sizeof(int) * k);
    34. 	if (minHeap == NULL)
    35. 	{
    36. 		perror("malloc");
    37. 		exit(-1);
    38. 	}
    39.  
    40. 	for (int i = 0; i < k; i++)
    41. 	{
    42. 		fscanf(pf,"%d", &minHeap[i]);
    43. 	}
    44.  
    45. 	//建小堆
    46. 	for (int i = (k-1-1)/2; i>=0;--i)
    47. 	{
    48. 		HeapAdjustDown(minHeap, k, i);
    49. 	}
    50. 	
    51. 	//后N-k个数和堆顶元素比较
    52. 	int val = 0;
    53. 	while (fscanf(pf, "%d", &val)!=EOF)
    54. 	{
    55. 		if (val > minHeap[0])
    56. 		{
    57. 			minHeap[0] = val;
    58. 			HeapAdjustDown(minHeap, k, 0);
    59. 		}
    60. 	}
    61.  
    62. 	//打印出前k大的数
    63. 	for (int i = 0; i < k; i++)
    64. 	{
    65. 		printf("%d ", minHeap[i]);
    66. 	}
    67.  
    68. 	fclose(pf);
    69. 	pf = NULL;
    70. }
    71.  
    72.  
    73. int main()
    74. {
    75. 	const char* filename = "test.txt";
    76. 	int N = 100;
    77. 	int k = 10;
    78. 	//给文件内随机生成N个数
    79. 	CreateFileName(filename, N);
    80. 	//从文件中选出N个数中前K大的几个数字，并且打印
    81. 	PrintTopK(filename, k);
    82. 	return 0;
    83. }

     TopK问题的时间复杂度分析：

     

  • 相关阅读:
    CSS书写位置和基础选择器
    私有化部署的即时通讯平台，为企业移动业务安全保驾护航
    Golang--channel+waitGroup控制并发量
    springboot 线程池参数解释
    返回流文件前端处理方法(全)
    自动驾驶--定位技术
    ArrayList详解
    传统企业如何做数字化转型？弄懂这3大底层逻辑你就懂了
    CCC联盟——UWB MAC（一）
    【MyBatis源码分析】六、MyBatis Plugins(拦截器)
  • 原文地址：https://blog.csdn.net/qq_64428099/article/details/126612709