• 【数据结构】堆综合的运用

    江河入海，知识涌动，这是我参与江海计划的第9篇。

    目录

    一，运用堆结构进行排序

    二，经典的Topk问题

    一，运用堆结构进行排序

            当我们用堆结构进行排序时，首先要明确的是升序排列要建大堆，降序排列要建小堆，不是说升序建小堆就不行，降序建大堆就不行，而是如果运用这种建堆方式进行排序的话效率会比较低，下面我会跟大家详细分析。

            首先，我们来回顾一下堆的概念，大堆结构：双亲结点>=孩子结点。小堆结构：双亲结点<=孩子结点。其中，根节点是所有结点的"祖宗"，也就是在大堆中，根节点是在堆中最大的数据，在小堆中，根节点是在堆中最小的数据。排升序时，当我们运用建小堆思想，虽然第一个数据已确定序列位置，但后面的数据要想确定序列位置就必须对除去上一次数据外剩下的元素再次建堆，也就是建一次小堆相当于排好一个数据的序列位置。排降序时运用大堆同理。此时的时间效率为O((n*logn)*n)。由此可见，此种方法效率太低。

            当升序用建大堆思想时，大堆中根结点是最大数据，升序序列中最后的数据都是最大的数据，我们只需在大堆中将首元素与尾元素进行交换后即可确定最后一个元素的序列位置，然后再除去大堆中最后一个元素将根结点运用向下调整算法进行调整，这将又得到除去最后一个元素的大堆，以次不断循环，最终将有序。由此可见，大堆排升序是从后到前的排序。

            降序用小堆的思想与之同理，都是先建立堆，然后不断交换确定数据序列位置，都是从后到前的排序。具体代码如下：

    运用大堆排升序：

    void Swap(int* x, int* y) {
        int t = *x;
        *x = *y;
        *y = t;
    }
    void AdjustUp(int* a, int child) {
        assert(a);
        int parent = (child - 1) / 2;
        while (parent >= 0) {
            //调整建大堆
            if (a[parent] < a[child]) {
                Swap(a + parent, a + child);
                child = parent;
                parent = (child - 1) / 2;
            }
            if (a[parent] >= a[child]) {
                return;
            }
        }
    }
    void AdjustDown(int* a, int n, int parent) {
        assert(a);
        int child = parent * 2 + 1;
        while (child < n) {
            //调整建大堆
            if (child + 1 < n && a[child] < a[child + 1]) {
                child++;
            }
            if (a[child] > a[parent]) {
                Swap(a + child, a + parent);
                parent = child;
                child = parent * 2 + 1;
            }
            if (a[child] <= a[parent]) {
                return;
            }
        }
    }
    void HeadSort(int* a, int n) {
        //运用向上调整算法建大堆
        for (int i = 1; i < n; i++) {
            AdjustUp(a, i);
        }
        //end是堆中最后一个元素的下标
        int end = n - 1;
        while (end > 0) {
            //将堆中最大数据排到最后
            Swap(&a[0], &a[end]);
            //将end个数据建成堆 
            AdjustDown(a, end, 0);//因为根节点的左右子树都可看成大堆，所以只要向下调节根结点就可使end个数据成为大堆
            //后面已排好了一个数据，继续将剩下的数据建堆排序即可
            end--;
        }
    }

    运用小堆排降序

    void Swap(int* x, int* y) {
        int t = *x;
        *x = *y;
        *y = t;
    }
    void AdjustUp(int* a, int child) {
        assert(a);
        int parent = (child - 1) / 2;
        while (parent >= 0) {
            //调整建小堆
            if (a[parent] > a[child]) {
                Swap(a + parent, a + child);
                child = parent;
                parent = (child - 1) / 2;
            }
            if (a[parent] <= a[child]) {
                return;
            }
        }
    }
    void AdjustDown(int* a, int n, int parent) {
        assert(a);
        int child = parent * 2 + 1;
        while (child < n) {
            //调整建小堆
            if (child + 1 < n && a[child] > a[child + 1]) {
                child++;
            }
            if (a[child] < a[parent]) {
                Swap(a + child, a + parent);
                parent = child;
                child = parent * 2 + 1;
            }
            if (a[child] >= a[parent]) {
                return;
            }
        }
    }
    void HeadSort(int* a, int n) {
        //运用向上调整算法建小堆
        for (int i = 1; i < n; i++) {
            AdjustUp(a, i);
        }
        //end是堆中最后一个元素的下标
        int end = n - 1;
        while (end > 0) {
            //将堆中最小数据排到最后
            Swap(&a[0], &a[end]);
            //将end个数据建成堆 
            AdjustDown(a, end, 0);//因为根节点的左右子树都可看成小堆，所以只要向下调节根结点就可使end个数据成为小堆
            //因为后面排好了一个数据，继续将剩下的数据建堆排序即可
            end--;
        }
    }

    效率分析：

            我们先观察前面的建堆效率：时间复杂度：O(logn)     空间复杂度：O(1)

            在后面排序时，每当确定一个数据的序列位置时就要运用调整算法进行调整一次，所以，要对n个数据排序时的时间复杂度：O(nlogn)   空间复杂度：O(1)。因此，运用堆结构排序的整体效率：时间复杂度：O(nlogn)   空间复杂度：O(1)。

            注意：这只是大致的分析，但仔细分析，当运用向下调整法建堆时，最后一层的数据不用向下调整，通过综合计算循环次数可得，此时的时间复杂度为O(n)。向上调整法只有第一层的一个数据不需调整，所以计算可得，此时的时间复杂度为O(nlongn)。

            总：当运用向上调整算法建堆时，时间复杂度为O(nlongn)，空间复杂度为O(1)

                   当运用向下调整算法建堆时，时间复杂度为O(n)，空间复杂度为O(1)

    二，经典的Topk问题

            Topk问题：假设有100万个数据(也可以是1千万，1亿个数据，只要数据足够大即可)，而这些数据内存又存储不下，所以要靠文件来进行存储，在文件中，我们需要找出最大的前k个数据。

            此问题可以用堆结构来完成，具体步骤如下：

            1，读取文件的前k个数据，在内存数组中建立一个大小为k的小堆。

            2，再依次读取剩下的数据与堆顶数据比较，大于堆顶就替换这个数据进堆，然后向下调整，调整后的数据仍为堆，即堆顶数据是堆中最小的数据。

            3，所有数据读完，堆里面数据就是最大的前k个数据。

            首先，我们先造出这么多个数据，将其写入文件中。

    1. //str是文件的路径
    2. void CreatData(char* str) {
    3. 	FILE* file = fopen(str, "w");
    4. 	if (file == 0) {
    5. 		perror("fopen");
    6. 		exit(-1);
    7. 	}
    8. 	//造出1000000个数据，也可以造出更多
    9. 	srand(time(0));
    10. 	for (int i = 0; i < 1000000; i++) {
    11. 		//造出范围在[1, 1000]的数据
    12. 		int n = (rand() + i) % 1000 + 1;
    13. 		fprintf(file, "%d\n", n);
    14. 	}
    15. 	fclose(file);
    16. }

            然后，先建立起小堆结构，再将前k个数据放入小堆中，最后遍历文件数据进行交换。

    1. void CreatHeap(char* str, int k) {
    2. 	//建立堆结构并初始化
    3. 	int* a = (int*)malloc(sizeof(int) * k);
    4. 	if (a == 0) {
    5. 		perror("malloc");
    6. 		exit(-1);
    7. 	}
    8. 	memset(a, 0, sizeof(int) * k);
    9.  
    10. 	//先将文件中的前k个数据放到堆中，将其调成小堆
    11. 	FILE* file = fopen(str, "r");
    12. 	if (!file) {
    13. 		perror("fopen");
    14. 		exit(-1);
    15. 	}
    16. 	for (int i = 0; i < k; i++) {
    17. 		fscanf(file, "%d", a + i);
    18. 	}
    19. 	for (int i = (k - 2) / 2; i >= 0; i--) {
    20. 		AdjustDown(a, k, i);
    21. 	}
    22.  
    23. 	//然后遍历文件中剩下数据
    24. 	int x = 0;
    25. 	while (fscanf(file, "%d", &x) != EOF) {
    26. 		if (x > a[0]) {
    27. 			Swap(&x, &a[0]);
    28. 			AdjustDown(a, k, 0);
    29. 		}
    30. 	}
    31.  
    32. 	//输出
    33. 	for (int i = 0; i < k; i++) {
    34. 		fprintf(stdout, "%d ", a[i]);
    35. 	}
    36. 	puts("");
    37. 	free(a); 
    38. 	fclose(file);
    39. }

    整套代码如下(我们将k设置为100，即从100万个数据选出100个最大数)：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. void Swap(int* x, int* y) {
    7. 	int t = *x;
    8. 	*x = *y;
    9. 	*y = t;
    10. }
    11. void AdjustUp(int* a, int child) {
    12. 	assert(a);
    13. 	int parent = (child - 1) / 2;
    14. 	while (parent >= 0) {
    15. 		if (a[parent] > a[child]) {
    16. 			Swap(a + parent, a + child);
    17. 			child = parent;
    18. 			parent = (child - 1) / 2;
    19. 		}
    20. 		if (a[parent] <= a[child]) {
    21. 			return;
    22. 		}
    23. 	}
    24. }
    25. void AdjustDown(int* a, int n, int parent) {
    26. 	assert(a);
    27. 	int child = parent * 2 + 1;
    28. 	while (child < n) {
    29. 		if (child + 1 < n && a[child] > a[child + 1]) {
    30. 			child++;
    31. 		}
    32. 		if (a[child] < a[parent]) {
    33. 			Swap(a + child, a + parent);
    34. 			parent = child;
    35. 			child = parent * 2 + 1;
    36. 		}
    37. 		if (a[child] >= a[parent]) {
    38. 			return;
    39. 		}
    40. 	}
    41. }
    42. //str是文件的路径
    43. void CreatData(char* str) {
    44. 	//注意："w"表示以写入方式打开文件并清空文件内容
    45. 	FILE* file = fopen(str, "w");
    46. 	if (file == 0) {
    47. 		perror("fopen");
    48. 		exit(-1);
    49. 	}
    50. 	//造出1000000个数据，也可以造出更多
    51. 	int n = 1000000;
    52. 	srand(time(0));
    53. 	for (int i = 0; i < n; i++) {
    54. 		//造出范围在[1, 1000]的数据
    55. 		int n = (rand() + i) % 1000 + 1;
    56. 		fprintf(file, "%d\n", n);
    57. 	}
    58. 	fclose(file);
    59. }
    60. void CreatHeap(char* str, int k) {
    61. 	//建立堆结构并初始化
    62. 	int* a = (int*)malloc(sizeof(int) * k);
    63. 	if (a == 0) {
    64. 		perror("malloc");
    65. 		exit(-1);
    66. 	}
    67. 	memset(a, 0, sizeof(int) * k);
    68.  
    69. 	//先将文件中的前k个数据放到堆中，将其调成小堆
    70. 	FILE* file = fopen(str, "r");
    71. 	if (!file) {
    72. 		perror("fopen");
    73. 		exit(-1);
    74. 	}
    75. 	for (int i = 0; i < k; i++) {
    76. 		fscanf(file, "%d", a + i);
    77. 	}
    78. 	for (int i = (k - 2) / 2; i >= 0; i--) {
    79. 		AdjustDown(a, k, i);
    80. 	}
    81.  
    82. 	//然后遍历文件中剩下数据
    83. 	int x = 0;
    84. 	while (fscanf(file, "%d", &x) != EOF) {
    85. 		if (x > a[0]) {
    86. 			Swap(&x, &a[0]);
    87. 			AdjustDown(a, k, 0);
    88. 		}
    89. 	}
    90.  
    91. 	//输出
    92. 	for (int i = 0; i < k; i++) {
    93. 		fprintf(stdout, "%d ", a[i]);
    94. 	}
    95. 	puts("");
    96. 	free(a); 
    97. 	fclose(file);
    98. }
    99. //删除路径在str中的文件
    100. void DeleteFile(char* str) {
    101. 	if (remove(str) != 0) {
    102. 		fprintf(stdout, "无法删除文件\n");
    103. 	}
    104. 	else {
    105. 		fprintf(stdout, "文件已删除\n");
    106. 	}
    107. }
    108. int main() {
    109. 	//创建巨多数据，将其输出到文件中
    110. 	CreatData("E:\\test.txt");
    111.  
    112. 	//k为100,建立大小为100的小堆，并将文件中最大的前100个数据放入小堆中
    113. 	CreatHeap("E:\\test.txt", 100);
    114.  
    115. 	//删除文件
    116. 	DeleteFile("E:\\test.txt");
    117. 	return 0;
    118. }

     效率分析：

            从以上中不难发现：时间复杂度：O(n*logk)。空间复杂度：O(k)

    补：从以上两个运用不难发现，堆结构的效率很高，在今后遇到的复杂问题中，我们都可运用高效率的堆结构来进行优化。

  • 相关阅读:
    Win11缺少dll文件怎么办？Win11系统找不到dll文件修复方法
    Java学习笔记2—集合框架—2.1概述特点
    工业数字化转型 — 工业现场总线
    基于QT实现的图形软件图片编辑器
    docker push image harbor http 镜像
    锂电池充放电曲线、设置充电电流、检测TP4054的3种充电状态
    在C++中++a和a++有什么区别？
    java-php-python-基于SSM智能社区管理系统计算机毕业设计
    2022.9.8-----leetcode.667
    大数据Flink（九十）：Lookup Join（维表 Join）
  • 原文地址：https://blog.csdn.net/m0_74246469/article/details/133963566