程序员编程艺术：第三章续、Top K算法问题的实现

程序员编程艺术：第三章续、Top K算法问题的实现

作者：July，zhouzhenren，yansha。

    致谢：微软100题实现组，狂想曲创作组。

    时间：2011年05月08日

    微博：http://weibo.com/julyweibo 。

    出处：http://blog.csdn.net/v_JULY_v 。

    wiki：http://tctop.wikispaces.com/。

-----------------------------------------------

前奏

    在上一篇文章，程序员面试题狂想曲：第三章、寻找最小的k个数中，后来为了论证类似快速排序中partition的方法在最坏情况下，能在O（N）的时间复杂度内找到最小的k个数，而前前后后updated了10余次。所谓功夫不负苦心人，终于得到了一个想要的结果。

简单总结如下（详情，请参考原文第三章）：

    1、RANDOMIZED-SELECT，以序列中随机选取一个元素作为主元，可达到线性期望时间O（N）的复杂度。

    2、SELECT，快速选择算法，以序列中“五分化中项的中项”，或“中位数的中位数”作为主元（枢纽元），则不容置疑的可保证在最坏情况下亦为O（N）的复杂度。

本章，咱们来阐述寻找最小的k个数的反面，即寻找最大的k个数，但此刻可能就有读者质疑了，寻找最大的k个数和寻找最小的k个数，原理不是一样的么?

是的，的确是一样，但这个寻找最大的k个数的问题的实用范围更广，因为它牵扯到了一个Top K算法问题，以及有关搜索引擎，海量数据处理等广泛的问题，所以本文特意对这个Top K算法问题，进行阐述以及实现（侧重实现，因为那样看起来，会更令人激动人心），算是第三章的续。ok，有任何问题，欢迎随时不吝指正。谢谢。

说明

关于寻找最小K个数能做到最坏情况下为O（N）的算法及证明，请参考原第三章，寻找最小的k个数，本文的代码不保证O（N）的平均时间复杂度，只是根据第三章有办法可以做到而已（如上面总结的，2、SELECT，快速选择算法，以序列中“五分化中项的中项”，或“中位数的中位数”作为主元或枢纽元的方法，原第三章已经严格论证并得到结果）。

第一节、寻找最小的第k个数

在进入寻找最大的k个数的主题之前，先补充下关于寻找最k小的数的三种简单实现。由于堆的完整实现，第三章：第五节，堆结构实现，处理海量数据中已经给出，下面主要给出类似快速排序中partition过程的代码实现：

寻找最小的k个数，实现一（下段代码经本文评论下多位读者指出有问题：当a [ i ]=a [ j ]=pivot时，则会产生一个无限循环，在Mark
Allen Weiss的数据结构与算法分析C++描述中文版的P209-P210有描述，读者可参看之。特此说明，因本文代码存在问题的地方还有几处，故请待后续统一修正.2012.08.21）：

1. //copyright@ mark allen weiss && July && yansha
2. //July，yansha、updated，2011.05.08.
3. //本程序，后经飞羽找出错误，已经修正。
4. //随机选取枢纽元，寻找最小的第k个数
5. #include <iostream>
6. #include <stdlib.h>
7. using namespace std;
8. int my_rand(int low, int high)
9. {
10. int size = high - low + 1;
11. return  low + rand() % size;
12. }
13. //q_select places the kth smallest element in a[k]
14. int q_select(int a[], int k, int left, int right)
15. {
16. if(k > right || k < left)
17. {
18. //         cout<<"---------"<<endl;   //为了处理当k大于数组中元素个数的异常情况
19. return false;
20. }
21. //真正的三数中值作为枢纽元方法，关键代码就是下述六行
22. int midIndex = (left + right) / 2;
23. if(a[left] < a[midIndex])
24. swap(a[left], a[midIndex]);
25. if(a[right] < a[midIndex])
26. swap(a[right], a[midIndex]);
27. if(a[right] < a[left])
28. swap(a[right], a[left]);
29. swap(a[left], a[right]);
30. int pivot = a[right];   //之前是int pivot = right，特此，修正。
31. // 申请两个移动指针并初始化
32. int i = left;
33. int j = right-1;
34. // 根据枢纽元素的值对数组进行一次划分
35. for (;;)
36. {
37. while(a[i] < pivot)
38. i++;
39. while(a[j] > pivot)
40. j--;
41. //a[i] >= pivot, a[j] <= pivot
42. if (i < j)
43. swap(a[i], a[j]);   //a[i] <= a[j]
44. else
45. break;
46. }
47. swap(a[i], a[right]);
48. /* 对三种情况进行处理
49. 1、如果i=k，即返回的主元即为我们要找的第k小的元素，那么直接返回主元a[i]即可;
50. 2、如果i>k，那么接下来要到低区间A[0....m-1]中寻找，丢掉高区间;
51. 3、如果i<k，那么接下来要到高区间A[m+1...n-1]中寻找，丢掉低区间。
52. */
53. if (i == k)
54. return true;
55. else if (i > k)
56. return q_select(a, k, left, i-1);
57. else return q_select(a, k, i+1, right);
58. }
59. int main()
60. {
61. int i;
62. int a[] = {7, 8, 9, 54, 6, 4, 11, 1, 2, 33};
63. q_select(a, 4, 0, sizeof(a) / sizeof(int) - 1);
64. return 0;
65. }

寻找最小的第k个数，实现二：

1. //copyright@ July
2. //yansha、updated，2011.05.08。
3. // 数组中寻找第k小元素，实现二
4. #include <iostream>
5. using namespace std;
6. const int numOfArray = 10;
7. // 这里并非真正随机
8. int my_rand(int low, int high)
9. {
10. int size = high - low + 1;
11. return low + rand() % size;
12. }
13. // 以最末元素作为主元对数组进行一次划分
14. int partition(int array[], int left, int right)
15. {
16. int pos = right;
17. for(int index = right - 1; index >= left; index--)
18. {
19. if(array[index] > array[right])
20. swap(array[--pos], array[index]);
21. }
22. swap(array[pos], array[right]);
23. return pos;
24. }
25. // 随机快排的partition过程
26. int random_partition(int array[], int left, int right)
27. {
28. // 随机从范围left到right中取一个值作为主元
29. int index = my_rand(left, right);
30. swap(array[right], array[index]);
31. // 对数组进行划分，并返回主元在数组中的位置
32. return partition(array, left, right);
33. }
34. // 以线性时间返回数组array[left...right]中第k小的元素
35. int random_select(int array[], int left, int right, int k)
36. {
37. // 处理异常情况
38. if (k < 1 || k > (right - left + 1))
39. return -1;
40. // 主元在数组中的位置
41. int pos = random_partition(array, left, right);
42. /* 对三种情况进行处理：(m = i - left + 1)
43. 1、如果m=k，即返回的主元即为我们要找的第k小的元素，那么直接返回主元array[i]即可;
44. 2、如果m>k，那么接下来要到低区间array[left....pos-1]中寻找，丢掉高区间;
45. 3、如果m<k，那么接下来要到高区间array[pos+1...right]中寻找，丢掉低区间。
46. */
47. int m = pos - left + 1;
48. if(m == k)
49. return array[pos];
50. else if (m > k)
51. return random_select(array, left, pos - 1, k);
52. else
53. return random_select(array, pos + 1, right, k - m);
54. }
55. int main()
56. {
57. int array[numOfArray] = {7, 8, 9, 54, 6, 4, 2, 1, 12, 33};
58. cout << random_select(array, 0, numOfArray - 1, 4) << endl;
59. return 0;
60. }

寻找最小的第k个数，实现三：

1. //求取无序数组中第K个数，本程序枢纽元的选取有问题，不作推荐。
2. //copyright@ 飞羽
3. //July、yansha，updated，2011.05.18。
4. #include <iostream>
5. #include <time.h>
6. using namespace std;
7. int kth_elem(int a[], int low, int high, int k)
8. {
9. int pivot = a[low];
10. //这个程序之所以做不到O（N）的最最重要的原因，就在于这个枢纽元的选取。
11. //而这个程序直接选取数组中第一个元素作为枢纽元，是做不到平均时间复杂度为 O（N）的。
12. //要 做到，就必须 把上面选取枢纽元的 代码改掉，要么是随机选择数组中某一元素作为枢纽元，能达到线性期望的时间
13. //要么是选取数组中中位数的中位数作为枢纽元，保证最坏情况下，依然为线性O（N）的平均时间复杂度。
14. int low_temp = low;
15. int high_temp = high;
16. while(low < high)
17. {
18. while(low < high && a[high] >= pivot)
19. --high;
20. a[low] = a[high];
21. while(low < high && a[low] < pivot)
22. ++low;
23. a[high] = a[low];
24. }
25. a[low] = pivot;
26. //以下就是主要思想中所述的内容
27. if(low == k - 1)
28. return a[low];
29. else if(low > k - 1)
30. return kth_elem(a, low_temp, low - 1, k);
31. else
32. return kth_elem(a, low + 1, high_temp, k);
33. }
34. int main()   //以后尽量不再用随机产生的数组进行测试，没多大必要。
35. {
36. for (int num = 5000; num < 50000001; num *= 10)
37. {
38. int *array = new int[num];
39. int j = num / 10;
40. int acc = 0;
41. for (int k = 1; k <= num; k += j)
42. {
43. // 随机生成数据
44. srand(unsigned(time(0)));
45. for(int i = 0; i < num; i++)
46. array[i] = rand() * RAND_MAX + rand();
47. //”如果数组本身就是利用随机化产生的话，那么选择其中任何一个元素作为枢轴都可以看作等价于随机选择枢轴，
48. //（虽然这不叫随机选择枢纽）”，这句话，是完全不成立的，是错误的。
49. //“因为你总是选择 随机数组中第一个元素 作为枢纽元，不是 随机选择枢纽元”
50. //相当于把上面这句话中前面的 “随机” 两字去掉，就是：
51. //因为 你总是选择数组中第一个元素作为枢纽元，不是 随机选择枢纽元。
52. //所以，这个程序，始终做不到平均时间复杂度为O（N）。
53. //随机数组和给定一个非有序而随机手动输入的数组，是一个道理。稍后，还将就程序的运行结果继续解释这个问题。
54. //July、updated，2011.05.18。
55. // 计算一次查找所需的时钟周期数
56. clock_t start = clock();
57. int data = kth_elem(array, 0, num - 1, k);
58. clock_t end = clock();
59. acc += (end - start);
60. }
61. cout << "The average time of searching a date in the array size of " << num << " is " << acc / 10 << endl;
62. }
63. return 0;
64. }

测试：

The average time of searching a date in the array size of 5000 is 0

The average time of searching a date in the array size of 50000 is 1

The average time of searching a date in the array size of 500000 is 12

The average time of searching a date in the array size of 5000000 is 114

The average time of searching a date in the array size of 50000000 is 1159

Press any key to continue

通过测试这个程序，我们竟发现这个程序的运行时间是线性的?

或许，你还没有意识到这个问题，ok，听我慢慢道来。

我们之前说，要保证这个算法是线性的，就一定要在枢纽元的选取上下足功夫：

1、要么是随机选取枢纽元作为划分元素

2、要么是取中位数的中位数作为枢纽元划分元素

 

现在，这程序直接选取了数组中第一个元素作为枢纽元

竟然，也能做到线性O（N）的复杂度，这不是自相矛盾么?

你觉得这个程序的运行时间是线性O（N），是巧合还是确定会是如此?

哈哈，且看1、@well：根据上面的运行结果不能判断线性，如果人家是O(n^1.1) 也有可能啊，而且部分数据始终是拟合，还是要数学证明才可靠。2、@July：同时，随机数组中选取一个元素作为枢纽元！=> 随机数组中随机选取一个元素作为枢纽元（如果是随机选取随机数组中的一个元素作为主元，那就不同了，跟随机选取数组中一个元素作为枢纽元一样了）。3、@飞羽：正是因为数组本身是随机的，所以选择第一个元素和随机选择其它的数是等价的（由等概率产生保证），这第3点，我与飞羽有分歧，至于谁对谁错，待时间让我考证。

关于上面第3点我和飞羽的分歧，在我们进一步讨论之后，一致认定（不过，相信，你看到了上面程序更新的注释之后，你应该有几分领会了）：

1. 我们说输入一个数组的元素，不按其顺序输入：如，1,2,3,4,5,6,7，而是这样输入：5,7,6,4,3，1,2，这就叫随机输入，而这种情况就相当于上述程序主函数中所产生的随机数组。然而选取随机输入的数组或随机数组中第一个元素作为主元，我们不能称之为说是随机选取枢纽元。
2. 因为，随机数产生器产生的数据是随机的，没错，但你要知道，你总是选取随机数组的第一个元素作为枢纽元，这不叫随机选取枢纽元。
3. 所以，上述程序的主函数中随机产生的数组对这个程序的算法而言，没有任何意义，就是帮忙产生了一个随机数组，帮助我们完成了测试，且方便我们测试大数据量而已，就这么简单。
4. 且一般来说，我们看一个程序的 时间复杂度，是不考虑 其输入情况的，即不考虑主函数，正如这个 kth number 的程序所见，你每次都是随机选取数组中第一个元素作为枢纽元，而并不是随机选择枢纽元，所以，做不到平均时间复杂度为O（N）。

所以：想要保证此快速选择算法为O（N）的复杂度，只有两种途径，那就是保证划分的枢纽元元素的选取是：

1、随机的（注，此枢纽元随机不等同于数组随机）

2、五分化中项的中项，或中位数的中位数。

所以，虽然咱们对于一切心知肚明，但上面程序的运行结果说明不了任何问题，这也从侧面再次佐证了咱们第三章中观点的正确无误性。

updated：

非常感谢飞羽等人的工作，将上述三个版本综合到了一起（待进一步测试）：

1. ///下面的代码对July博客中的三个版本代码进行重新改写。欢迎指出错误。
2. ///先把它们贴在这里，还要进行随机化数据测试。待发...
3. //modified by 飞羽 at 2011.5.11
4. /////Top_K_test
5. //修改了下命名规范，July、updated，2011.05.12。
6. #include <iostream>
7. #include <stdlib.h>
8. using namespace std;
9. inline int my_rand(int low, int high)
10. {
11. int size = high - low + 1;
12. return  low + rand() % size;
13. }
14. int partition(int array[], int left, int right)
15. {
16. int pivot = array[right];
17. int pos = left-1;
18. for(int index = left; index < right; index++)
19. {
20. if(array[index] <= pivot)
21. swap(array[++pos], array[index]);
22. }
23. swap(array[++pos], array[right]);
24. return pos;//返回pivot所在位置
25. }
26. bool median_select(int array[], int left, int right, int k)
27. {
28. //第k小元素，实际上应该在数组中下标为k-1
29. if (k-1 > right || k-1 < left)
30. return false;
31. //真正的三数中值作为枢纽元方法，关键代码就是下述六行
32. int midIndex=(left+right)/2;
33. if(array[left]<array[midIndex])
34. swap(array[left],array[midIndex]);
35. if(array[right]<array[midIndex])
36. swap(array[right],array[midIndex]);
37. if(array[right]<array[left])
38. swap(array[right],array[left]);
39. swap(array[left], array[right]);
40. int pos = partition(array, left, right);
41. if (pos == k-1)
42. return true;
43. else if (pos > k-1)
44. return median_select(array, left, pos-1, k);
45. else return median_select(array, pos+1, right, k);
46. }
47. bool rand_select(int array[], int left, int right, int k)
48. {
49. //第k小元素，实际上应该在数组中下标为k-1
50. if (k-1 > right || k-1 < left)
51. return false;
52. //随机从数组中选取枢纽元元素
53. int Index = my_rand(left, right);
54. swap(array[Index], array[right]);
55. int pos = partition(array, left, right);
56. if (pos == k-1)
57. return true;
58. else if (pos > k-1)
59. return rand_select(array, left, pos-1, k);
60. else return rand_select(array, pos+1, right, k);
61. }
62. bool kth_select(int array[], int left, int right, int k)
63. {
64. //直接取最原始的划分操作
65. if (k-1 > right || k-1 < left)
66. return false;
67. int pos = partition(array, left, right);
68. if(pos == k-1)
69. return true;
70. else if(pos > k-1)
71. return kth_select(array, left, pos-1, k);
72. else return kth_select(array, pos+1, right, k);
73. }
74. int main()
75. {
76. int array1[] = {7, 8, 9, 54, 6, 4, 11, 1, 2, 33};
77. int array2[] = {7, 8, 9, 54, 6, 4, 11, 1, 2, 33};
78. int array3[] = {7, 8, 9, 54, 6, 4, 11, 1, 2, 33};
79. int numOfArray = sizeof(array1) / sizeof(int);
80. for(int i=0; i<numOfArray; i++)
81. printf("%d/t",array1[i]);
82. int K = 9;
83. bool flag1 = median_select(array1, 0, numOfArray-1, K);
84. bool flag2 = rand_select(array2, 0, numOfArray-1, K);
85. bool flag3 = kth_select(array3, 0, numOfArray-1, K);
86. if(!flag1)
87. return 1;
88. for(i=0; i<K; i++)
89. printf("%d/t",array1[i]);
90. printf("/n");
91. if(!flag2)
92. return 1;
93. for(i=0; i<K; i++)
94. printf("%d/t",array2[i]);
95. printf("/n");
96. if(!flag3)
97. return 1;
98. for(i=0; i<K; i++)
99. printf("%d/t",array3[i]);
100. printf("/n");
101. return 0;
102. }

说明：@飞羽：因为预先设定了K，经过分割算法后，数组肯定被划分为array[0...k-1]和array[k...length-1]，注意到经过Select_K_Version操作后，数组是被不断地分割的，使得比array[k-1]的元素小的全在左边，题目要求的是最小的K个元素，当然也就是array[0...k-1]，所以输出的结果就是前k个最小的数：

7       8       9       54      6       4       11      1       2       33

4       1       2       6       7       8       9       11      33

7       6       4       1       2       8       9       11      33

7       8       9       6       4       11      1       2       33

Press any key to continue

（更多，请参见：此狂想曲系列tctop修订wiki页面：http://tctop.wikispaces.com/）

第二节、寻找最大的k个数

把之前第三章的问题，改几个字，即成为寻找最大的k个数的问题了，如下所述：

查找最大的k个元素

题目描述：输入n个整数，输出其中最大的k个。

例如输入1，2，3，4，5，6，7和8这8个数字，则最大的4个数字为8，7，6和5。

分析：由于寻找最大的k个数的问题与之前的寻找最小的k个数的问题，本质是一样的，所以，这里就简单阐述下思路，ok，考验你举一反三能力的时间到了：

1、排序，快速排序。我们知道，快速排序平均所费时间为n*logn，从小到大排序这n个数，然后再遍历序列中后k个元素输出，即可，总的时间复杂度为O（n*logn+k）=O（n*logn）。

2、排序，选择排序。用选择或交换排序，即遍历n个数，先把最先遍历到得k个数存入大小为k的数组之中，对这k个数，利用选择或交换排序，找到k个数中的最小数kmin（kmin设为k个元素的数组中最小元素），用时O（k）（你应该知道，插入或选择排序查找操作需要O（k）的时间），后再继续遍历后n-k个数，x与kmin比较：如果x>kmin，则x代替kmin，并再次重新找出k个元素的数组中最大元素kmin‘（多谢jiyeyuran 提醒修正）；如果x<kmin，则不更新数组。这样，每次更新或不更新数组的所用的时间为O（k）或O（0），整趟下来，总的时间复杂度平均下来为：n*O（k）=O（n*k）。

3、维护k个元素的最小堆，原理与上述第2个方案一致，即用容量为k的最小堆存储最先遍历到的k个数，并假设它们即是最大的k个数，建堆费时O（k），并调整堆（费时O（logk））后，有k1>k2>...kmin（kmin设为小顶堆中最大元素）。继续遍历数列，每次遍历一个元素x，与堆顶元素比较，若x>kmin，则更新堆（用时logk），否则不更新堆。这样下来，总费时O（k*logk+（n-k）*logk）=O（n*logk）。此方法得益于在堆中，查找等各项操作时间复杂度均为logk（不然，就如上述思路2所述：直接用数组也可以找出最大的k个元素，用时O（n*k））。

4、按编程之美第141页上解法二的所述，类似快速排序的划分方法，N个数存储在数组S中，再从数组中随机选取一个数X，把数组划分为Sa和Sb俩部分，Sa>=X>=Sb，如果要查找的k个元素小于Sa的元素个数，则返回Sa中较大的k个元素，否则返回Sa中所有的元素+Sb中最大的k-|Sa|个元素。不断递归下去，把问题分解成更小的问题，平均时间复杂度为O（N）（编程之美所述的n*logk的复杂度有误，应为O（N），特此订正。其严格证明，请参考第三章：程序员面试题狂想曲：第三章、寻找最小的k个数、updated
10次）。

   .........

其它的方法，在此不再重复了，同时，寻找最小的k个数借助堆的实现，代码在上一篇文章第三章已有给出，更多，可参考第三章，只要把最大堆改成最小堆，即可。

第三节、Top K 算法问题

3.1、搜索引擎热门查询统计

题目描述：

    搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。

    假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。），请你统计最热门的10个查询串，要求使用的内存不能超过1G。

分析：这个问题在之前的这篇文章十一、从头到尾彻底解析Hash表算法里，已经有所解答。方法是:

第一步、先对这批海量数据预处理，在O（N）的时间内用Hash表完成统计（之前写成了排序，特此订正。July、2011.04.27）；

    第二步、借助堆这个数据结构，找出Top K，时间复杂度为N‘logK。

        即，借助堆结构，我们可以在log量级的时间内查找和调整/移动。因此，维护一个K(该题目中是10)大小的小根堆（K1>K2>....Kmin，Kmin设为堆顶元素），然后遍历300万的Query，分别和根元素Kmin进行对比比较（如上第2节思路3所述，若X>Kmin，则更新并调整堆，否则，不更新），我们最终的时间复杂度是：O（N） + N'*O（logK），（N为1000万，N’为300万）。ok，更多，详情，请参考原文。

或者：采用trie树，关键字域存该查询串出现的次数，没有出现为0。最后用10个元素的最小推来对出现频率进行排序。

ok，本章里，咱们来实现这个问题，为了降低实现上的难度，假设这些记录全部是一些英文单词，即用户在搜索框里敲入一个英文单词，然后查询搜索结果，最后，要你统计输入单词中频率最大的前K个单词。ok，复杂问题简单化了之后，编写代码实现也相对轻松多了，画的简单示意图（绘制者，yansha），如下：

完整源码：

1. //copyright@yansha &&July
2. //July、updated，2011.05.08
3. //题目描述：
4. //搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的
5. //长度为1-255字节。假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果
6. //除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门），
7. //请你统计最热门的10个查询串，要求使用的内存不能超过1G。
8. #include <iostream>
9. #include <string>
10. #include <assert.h>
11. using namespace std;
12. #define HASHLEN 2807303
13. #define WORDLEN 30
14. // 结点指针
15. typedef struct node_no_space *ptr_no_space;
16. typedef struct node_has_space *ptr_has_space;
17. ptr_no_space head[HASHLEN];
18. struct node_no_space
19. {
20. char *word;
21. int count;
22. ptr_no_space next;
23. };
24. struct node_has_space
25. {
26. char word[WORDLEN];
27. int count;
28. ptr_has_space next;
29. };
30. // 最简单hash函数
31. int hash_function(char const *p)
32. {
33. int value = 0;
34. while (*p != '/0')
35. {
36. value = value * 31 + *p++;
37. if (value > HASHLEN)
38. value = value % HASHLEN;
39. }
40. return value;
41. }
42. // 添加单词到hash表
43. void append_word(char const *str)
44. {
45. int index = hash_function(str);
46. ptr_no_space p = head[index];
47. while (p != NULL)
48. {
49. if (strcmp(str, p->word) == 0)
50. {
51. (p->count)++;
52. return;
53. }
54. p = p->next;
55. }
56. // 新建一个结点
57. ptr_no_space q = new node_no_space;
58. q->count = 1;
59. q->word = new char [strlen(str)+1];
60. strcpy(q->word, str);
61. q->next = head[index];
62. head[index] = q;
63. }
64. // 将单词处理结果写入文件
65. void write_to_file()
66. {
67. FILE *fp = fopen("result.txt", "w");
68. assert(fp);
69. int i = 0;
70. while (i < HASHLEN)
71. {
72. for (ptr_no_space p = head[i]; p != NULL; p = p->next)
73. fprintf(fp, "%s  %d/n", p->word, p->count);
74. i++;
75. }
76. fclose(fp);
77. }
78. // 从上往下筛选，保持小根堆
79. void sift_down(node_has_space heap[], int i, int len)
80. {
81. int min_index = -1;
82. int left = 2 * i;
83. int right = 2 * i + 1;
84. if (left <= len && heap[left].count < heap[i].count)
85. min_index = left;
86. else
87. min_index = i;
88. if (right <= len && heap[right].count < heap[min_index].count)
89. min_index = right;
90. if (min_index != i)
91. {
92. // 交换结点元素
93. swap(heap[i].count, heap[min_index].count);
94. char buffer[WORDLEN];
95. strcpy(buffer, heap[i].word);
96. strcpy(heap[i].word, heap[min_index].word);
97. strcpy(heap[min_index].word, buffer);
98. sift_down(heap, min_index, len);
99. }
100. }
101. // 建立小根堆
102. void build_min_heap(node_has_space heap[], int len)
103. {
104. if (heap == NULL)
105. return;
106. int index = len / 2;
107. for (int i = index; i >= 1; i--)
108. sift_down(heap, i, len);
109. }
110. // 去除字符串前后符号
111. void handle_symbol(char *str, int n)
112. {
113. while (str[n] < '0' || (str[n] > '9' && str[n] < 'A') || (str[n] > 'Z' && str[n] < 'a') || str[n] > 'z')
114. {
115. str[n] = '/0';
116. n--;
117. }
118. while (str[0] < '0' || (str[0] > '9' && str[0] < 'A') || (str[0] > 'Z' && str[0] < 'a') || str[0] > 'z')
119. {
120. int i = 0;
121. while (i < n)
122. {
123. str[i] = str[i+1];
124. i++;
125. }
126. str[i] = '/0';
127. n--;
128. }
129. }
130. int main()
131. {
132. char str[WORDLEN];
133. for (int i = 0; i < HASHLEN; i++)
134. head[i] = NULL;
135. // 将字符串用hash函数转换成一个整数并统计出现频率
136. FILE *fp_passage = fopen("string.txt", "r");
137. assert(fp_passage);
138. while (fscanf(fp_passage, "%s", str) != EOF)
139. {
140. int n = strlen(str) - 1;
141. if (n > 0)
142. handle_symbol(str, n);
143. append_word(str);
144. }
145. fclose(fp_passage);
146. // 将统计结果输入文件
147. write_to_file();
148. int n = 10;
149. ptr_has_space heap = new node_has_space [n+1];
150. int c;
151. FILE *fp_word = fopen("result.txt", "r");
152. assert(fp_word);
153. for (int j = 1; j <= n; j++)
154. {
155. fscanf(fp_word, "%s %d", &str, &c);
156. heap[j].count = c;
157. strcpy(heap[j].word, str);
158. }
159. // 建立小根堆
160. build_min_heap(heap, n);
161. // 查找出现频率最大的10个单词
162. while (fscanf(fp_word, "%s %d", &str, &c) != EOF)
163. {
164. if (c > heap[1].count)
165. {
166. heap[1].count = c;
167. strcpy(heap[1].word, str);
168. sift_down(heap, 1, n);
169. }
170. }
171. fclose(fp_word);
172. // 输出出现频率最大的单词
173. for (int k = 1; k <= n; k++)
174. cout << heap[k].count << " " << heap[k].word << endl;
175. return 0;
176. }

程序测试：咱们接下来，来对下面的通过用户输入单词后，搜索引擎记录下来，“大量”单词记录进行统计（同时，令K=10，即要你找出10个最热门查询的单词）：

运行结果：根据程序的运行结果，可以看到，搜索引擎记录下来的查询次数最多的10个单词为（注，并未要求这10个数要有序输出）：in（312次），it（384次），a（432），that（456），MPQ（408），of（504），and（624），is（456），the（1008），to（936）。

 读者反馈from 杨忠胜：3.1节的代码第38行 hash_function(char const *p)有误吧，这样的话，不能修改p的值（但是函数需要修改指针的值），要想不修改*p指向的内容，应该是const char *p; 此外，您程序中的/t,  /n有误，C语言是\t,\n。

    感谢这位读者的来信，日后统一订正。谢谢。

3.2、统计出现次数最多的数据

题目描述：

给你上千万或上亿数据（有重复），统计其中出现次数最多的前N个数据。

分析：上千万或上亿的数据，现在的机器的内存应该能存下（也许可以，也许不可以）。所以考虑采用hash_map/搜索二叉树/红黑树等来进行统计次数。然后就是取出前N个出现次数最多的数据了。当然，也可以堆实现。

ok，此题与上题类似，最好的方法是用hash_map统计出现的次数，然后再借用堆找出出现次数最多的N个数据。不过，上一题统计搜索引擎最热门的查询已经采用过hash表统计单词出现的次数，特此，本题咱们改用红黑树取代之前的用hash表，来完成最初的统计，然后用堆更新，找出出现次数最多的前N个数据。

同时，正好个人此前用c && c++ 语言实现过红黑树，那么，代码能借用就借用吧。

完整代码：

1. //copyright@ zhouzhenren &&July
2. //July、updated，2011.05.08.
3. //题目描述：
4. //上千万或上亿数据（有重复），统计其中出现次数最多的前N个数据
5. //解决方案：
6. //1、采用红黑树（本程序中有关红黑树的实现代码来源于@July）来进行统计次数。
7. //2、然后遍历整棵树，同时采用最小堆更新前N个出现次数最多的数据。
8. //声明：版权所有，引用必须注明出处。
9. #define PARENT(i) (i)/2
10. #define LEFT(i)   2*(i)
11. #define RIGHT(i)  2*(i)+1
12. #include <stdio.h>
13. #include <stdlib.h>
14. #include <string.h>
15. typedef enum rb_color{ RED, BLACK }RB_COLOR;
16. typedef struct rb_node
17. {
18. int key;
19. int data;
20. RB_COLOR color;
21. struct rb_node* left;
22. struct rb_node* right;
23. struct rb_node* parent;
24. }RB_NODE;
25. RB_NODE* RB_CreatNode(int key, int data)
26. {
27. RB_NODE* node = (RB_NODE*)malloc(sizeof(RB_NODE));
28. if (NULL == node)
29. {
30. printf("malloc error!");
31. exit(-1);
32. }
33. node->key = key;
34. node->data = data;
35. node->color = RED;
36. node->left = NULL;
37. node->right = NULL;
38. node->parent = NULL;
39. return node;
40. }
41. /**
42. * 左旋
43. *
44. *  node           right
45. *  / /    ==>     / /
46. * a  right     node  y
47. *     / /       / /
48. *     b  y     a   b
49. */
50. RB_NODE* RB_RotateLeft(RB_NODE* node, RB_NODE* root)
51. {
52. RB_NODE* right = node->right;    // 指定指针指向 right<--node->right
53. if ((node->right = right->left))
54. right->left->parent = node;  // 好比上面的注释图，node成为b的父母
55. right->left = node;   // node成为right的左孩子
56. if ((right->parent = node->parent))
57. {
58. if (node == node->parent->right)
59. node->parent->right = right;
60. else
61. node->parent->left = right;
62. }
63. else
64. root = right;
65. node->parent = right;  //right成为node的父母
66. return root;
67. }
68. /**
69. * 右旋
70. *
71. *      node            left
72. *       / /             / /
73. *     left y   ==>     a  node
74. *     / /                  / /
75. *    a   b                b   y
76. */
77. RB_NODE* RB_RotateRight(RB_NODE* node, RB_NODE* root)
78. {
79. RB_NODE* left = node->left;
80. if ((node->left = left->right))
81. left->right->parent = node;
82. left->right = node;
83. if ((left->parent = node->parent))
84. {
85. if (node == node->parent->right)
86. node->parent->right = left;
87. else
88. node->parent->left = left;
89. }
90. else
91. root = left;
92. node->parent = left;
93. return root;
94. }
95. /**
96. * 红黑树的3种插入情况
97. * 用z表示当前结点, p[z]表示父母、p[p[z]]表示祖父, y表示叔叔.
98. */
99. RB_NODE* RB_Insert_Rebalance(RB_NODE* node, RB_NODE* root)
100. {
101. RB_NODE *parent, *gparent, *uncle, *tmp;  //父母p[z]、祖父p[p[z]]、叔叔y、临时结点*tmp
102. while ((parent = node->parent) && parent->color == RED)
103. { // parent 为node的父母，且当父母的颜色为红时
104. gparent = parent->parent;   // gparent为祖父
105. if (parent == gparent->left)  // 当祖父的左孩子即为父母时,其实上述几行语句，无非就是理顺孩子、父母、祖父的关系。
106. {
107. uncle = gparent->right; // 定义叔叔的概念，叔叔y就是父母的右孩子。
108. if (uncle && uncle->color == RED) // 情况1：z的叔叔y是红色的
109. {
110. uncle->color = BLACK;   // 将叔叔结点y着为黑色
111. parent->color = BLACK;  // z的父母p[z]也着为黑色。解决z，p[z]都是红色的问题。
112. gparent->color = RED;
113. node = gparent;     // 将祖父当做新增结点z，指针z上移俩层，且着为红色。
114. // 上述情况1中，只考虑了z作为父母的右孩子的情况。
115. }
116. else                     // 情况2：z的叔叔y是黑色的，
117. {
118. if (parent->right == node)  // 且z为右孩子
119. {
120. root = RB_RotateLeft(parent, root); // 左旋[结点z，与父母结点]
121. tmp = parent;
122. parent = node;
123. node = tmp;     // parent与node 互换角色
124. }
125. // 情况3：z的叔叔y是黑色的，此时z成为了左孩子。
126. // 注意，1：情况3是由上述情况2变化而来的。
127. // ......2：z的叔叔总是黑色的，否则就是情况1了。
128. parent->color = BLACK;   // z的父母p[z]着为黑色
129. gparent->color = RED;    // 原祖父结点着为红色
130. root = RB_RotateRight(gparent, root); // 右旋[结点z，与祖父结点]
131. }
132. }
133. else
134. {
135. // 这部分是特别为情况1中，z作为左孩子情况，而写的。
136. uncle = gparent->left;  // 祖父的左孩子作为叔叔结点。[原理还是与上部分一样的]
137. if (uncle && uncle->color == RED)  // 情况1：z的叔叔y是红色的
138. {
139. uncle->color = BLACK;
140. parent->color = BLACK;
141. gparent->color = RED;
142. node = gparent;           // 同上
143. }
144. else                               // 情况2：z的叔叔y是黑色的，
145. {
146. if (parent->left == node)  // 且z为左孩子
147. {
148. root = RB_RotateRight(parent, root);  // 以结点parent、root右旋
149. tmp = parent;
150. parent = node;
151. node = tmp;       // parent与node 互换角色
152. }
153. // 经过情况2的变化，成为了情况3.
154. parent->color = BLACK;
155. gparent->color = RED;
156. root = RB_RotateLeft(gparent, root);   // 以结点gparent和root左旋
157. }
158. }
159. }
160. root->color = BLACK; // 根结点，不论怎样，都得置为黑色。
161. return root;      // 返回根结点。
162. }
163. /**
164. * 红黑树查找结点
165. * rb_search_auxiliary：查找
166. * rb_node_t* rb_search：返回找到的结点
167. */
168. RB_NODE* RB_SearchAuxiliary(int key, RB_NODE* root, RB_NODE** save)
169. {
170. RB_NODE* node = root;
171. RB_NODE* parent = NULL;
172. int ret;
173. while (node)
174. {
175. parent = node;
176. ret = node->key - key;
177. if (0 < ret)
178. node = node->left;
179. else if (0 > ret)
180. node = node->right;
181. else
182. return node;
183. }
184. if (save)
185. *save = parent;
186. return NULL;
187. }
188. /**
189. * 返回上述rb_search_auxiliary查找结果
190. */
191. RB_NODE* RB_Search(int key, RB_NODE* root)
192. {
193. return RB_SearchAuxiliary(key, root, NULL);
194. }
195. /**
196. * 红黑树的插入
197. */
198. RB_NODE* RB_Insert(int key, int data, RB_NODE* root)
199. {
200. RB_NODE* parent = NULL;
201. RB_NODE* node = NULL;
202. parent = NULL;
203. if ((node = RB_SearchAuxiliary(key, root, &parent)))  // 调用RB_SearchAuxiliary找到插入结点的地方
204. {
205. node->data++; // 节点已经存在data值加1
206. return root;
207. }
208. node = RB_CreatNode(key, data);  // 分配结点
209. node->parent = parent;
210. if (parent)
211. {
212. if (parent->key > key)
213. parent->left = node;
214. else
215. parent->right = node;
216. }
217. else
218. {
219. root = node;
220. }
221. return RB_Insert_Rebalance(node, root);   // 插入结点后，调用RB_Insert_Rebalance修复红黑树的性质
222. }
223. typedef struct rb_heap
224. {
225. int key;
226. int data;
227. }RB_HEAP;
228. const int heapSize = 10;
229. RB_HEAP heap[heapSize+1];
230. /**
231. * MAX_HEAPIFY函数对堆进行更新，使以i为根的子树成最大堆
232. */
233. void MIN_HEAPIFY(RB_HEAP* A, const int& size, int i)
234. {
235. int l = LEFT(i);
236. int r = RIGHT(i);
237. int smallest = i;
238. if (l <= size && A[l].data < A[i].data)
239. smallest = l;
240. if (r <= size && A[r].data < A[smallest].data)
241. smallest = r;
242. if (smallest != i)
243. {
244. RB_HEAP tmp = A[i];
245. A[i] = A[smallest];
246. A[smallest] = tmp;
247. MIN_HEAPIFY(A, size, smallest);
248. }
249. }
250. /**
251. * BUILD_MINHEAP函数对数组A中的数据建立最小堆
252. */
253. void BUILD_MINHEAP(RB_HEAP* A, const int& size)
254. {
255. for (int i = size/2; i >= 1; --i)
256. MIN_HEAPIFY(A, size, i);
257. }
258. /*
259. 3、维护k个元素的最小堆，原理与上述第2个方案一致，
260. 即用容量为k的最小堆存储最先在红黑树中遍历到的k个数，并假设它们即是最大的k个数，建堆费时O（k），
261. 然后调整堆（费时O（logk））后，有k1>k2>...kmin（kmin设为小顶堆中最小元素）。
262. 继续中序遍历红黑树，每次遍历一个元素x，与堆顶元素比较，若x>kmin，则更新堆（用时logk），否则不更新堆。
263. 这样下来，总费时O（k*logk+（n-k）*logk）=O（n*logk）。
264. 此方法得益于在堆中，查找等各项操作时间复杂度均为logk）。
265. */
266. //中序遍历RBTree
267. void InOrderTraverse(RB_NODE* node)
268. {
269. if (node == NULL)
270. {
271. return;
272. }
273. else
274. {
275. InOrderTraverse(node->left);
276. if (node->data > heap[1].data) // 当前节点data大于最小堆的最小元素时，更新堆数据
277. {
278. heap[1].data = node->data;
279. heap[1].key = node->key;
280. MIN_HEAPIFY(heap, heapSize, 1);
281. }
282. InOrderTraverse(node->right);
283. }
284. }
285. void RB_Destroy(RB_NODE* node)
286. {
287. if (NULL == node)
288. {
289. return;
290. }
291. else
292. {
293. RB_Destroy(node->left);
294. RB_Destroy(node->right);
295. free(node);
296. node = NULL;
297. }
298. }
299. int main()
300. {
301. RB_NODE* root = NULL;
302. RB_NODE* node = NULL;
303. // 初始化最小堆
304. for (int i = 1; i <= 10; ++i)
305. {
306. heap[i].key = i;
307. heap[i].data = -i;
308. }
309. BUILD_MINHEAP(heap, heapSize);
310. FILE* fp = fopen("data.txt", "r");
311. int num;
312. while (!feof(fp))
313. {
314. fscanf(fp, "%d", &num);
315. root = RB_Insert(num, 1, root);
316. }
317. fclose(fp);
318. InOrderTraverse(root);   //递归遍历红黑树
319. RB_Destroy(root);
320. for (i = 1; i <= 10; ++i)
321. {
322. printf("%d/t%d/n", heap[i].key, heap[i].data);
323. }
324. return 0;
325. }

程序测试：咱们来对下面这个小文件进行测试：

运行结果：如下图所示，

问题补遗：

ok，由于在遍历红黑树采用的是递归方式比较耗内存，下面给出一个非递归遍历的程序（下述代码若要运行，需贴到上述程序之后，因为其它的代码未变，只是在遍历红黑树的时候，采取非递归遍历而已，同时，主函数的编写也要稍微修改下）：

1. //copyright@ zhouzhenren
2. //July、updated，2011.05.08.
3. #define STACK_SIZE 1000
4. typedef struct
5. {                                              // 栈的结点定义
6. RB_NODE** top;
7. RB_NODE** base;
8. }*PStack, Stack;
9. bool InitStack(PStack& st)                       // 初始化栈
10. {
11. st->base = (RB_NODE**)malloc(sizeof(RB_NODE*) * STACK_SIZE);
12. if (!st->base)
13. {
14. printf("InitStack error!");
15. exit(1);
16. }
17. st->top = st->base;
18. return true;
19. }
20. bool Push(PStack& st, RB_NODE*& e)                    // 入栈
21. {
22. if (st->top - st->base >= STACK_SIZE)
23. return false;
24. *st->top = e;
25. st->top++;
26. return true;
27. }
28. bool Pop(PStack& st, RB_NODE*& e)                     // 出栈
29. {
30. if (st->top == st->base)
31. {
32. e = NULL;
33. return false;
34. }
35. e = *--st->top;
36. return true;
37. }
38. bool StackEmpty(PStack& st)                     // 栈是否为空
39. {
40. if (st->base == st->top)
41. return true;
42. else
43. return false;
44. }
45. bool InOrderTraverse_Stack(RB_NODE*& T)                 // 中序遍历
46. {
47. PStack S = (PStack)malloc(sizeof(Stack));
48. RB_NODE* P = T;
49. InitStack(S);
50. while (P != NULL || !StackEmpty(S))
51. {
52. if (P != NULL)
53. {
54. Push(S, P);
55. P = P->left;
56. }
57. else
58. {
59. Pop(S, P);
60. if (P->data > heap[1].data) // 当前节点data大于最小堆的最小元素时，更新堆数据
61. {
62. heap[1].data = P->data;
63. heap[1].key = P->key;
64. MIN_HEAPIFY(heap, heapSize, 1);
65. }
66. P = P->right;
67. }
68. }
69. free(S->base);
70. S->base = NULL;
71. free(S);
72. S = NULL;
73. return true;
74. }
75. bool PostOrderTraverse_Stack(RB_NODE*& T)               //后序遍历
76. {
77. PStack S = (PStack)malloc(sizeof(Stack));
78. RB_NODE* P = T;
79. RB_NODE* Pre = NULL;
80. InitStack(S);
81. while (P != NULL || !StackEmpty(S))
82. {
83. if (P != NULL) // 非空直接入栈
84. {
85. Push(S, P);
86. P = P->left;
87. }
88. else
89. {
90. Pop(S, P); // 弹出栈顶元素赋值给P
91. if (P->right == NULL || P->right == Pre) // P的右子树空或是右子树是刚访问过的
92. { // 节点，则释放当前节点内存
93. free(P);
94. Pre = P;
95. P = NULL;
96. }
97. else // 反之，当前节点重新入栈，接着判断右子树
98. {
99. Push(S, P);
100. P = P->right;
101. }
102. }
103. }
104. free(S->base);
105. S->base = NULL;
106. free(S);
107. S = NULL;
108. return true;
109. }
110. //主函数稍微修改如下：
111. int main()
112. {
113. RB_NODE* root = NULL;
114. RB_NODE* node = NULL;
115. // 初始化最小堆
116. for (int i = 1; i <= 10; ++i)
117. {
118. heap[i].key = i;
119. heap[i].data = -i;
120. }
121. BUILD_MINHEAP(heap, heapSize);
122. FILE* fp = fopen("data.txt", "r");
123. int num;
124. while (!feof(fp))
125. {
126. fscanf(fp, "%d", &num);
127. root = RB_Insert(num, 1, root);
128. }
129. fclose(fp);
130. //若上面的程序后面加上了上述的非递归遍历红黑树的代码，那么以下几行代码，就得修改如下：
131. //InOrderTraverse(root); //此句去掉（递归遍历树）
132. InOrderTraverse_Stack(root); // 非递归遍历树
133. //RB_Destroy(root); //此句去掉（通过递归释放内存）
134. PostOrderTraverse_Stack(root); // 非递归释放内存
135. for (i = 1; i <= 10; ++i)
136. {
137. printf("%d/t%d/n", heap[i].key, heap[i].data);
138. }
139. return 0;
140. }

updated：

后来，我们狂想曲创作组中的3又用hash+堆实现了上题，很明显比采用上面的红黑树，整个实现简洁了不少，其完整源码如下：

完整源码：

1. //Author: zhouzhenren  
2. //Description: 上千万或上亿数据（有重复），统计其中出现次数最多的钱N个数据  
3.   
4. //Algorithm： 采用hash_map来进行统计次数+堆（找出Top K）。  
5. //July，2011.05.12。纪念汶川地震三周年，默哀三秒。  
6.   
7. #define PARENT(i) (i)/2  
8. #define LEFT(i)   2*(i)  
9. #define RIGHT(i)  2*(i)+1  
10.   
11. #define HASHTABLESIZE 2807303  
12. #define HEAPSIZE 10  
13. #define A 0.6180339887  
14. #define M 16384     //m=2^14  
15.   
16. #include <stdio.h>  
17. #include <stdlib.h>  
18.   
19. typedef struct hash_node  
20. {  
21.     int data;  
22.     int count;  
23.     struct hash_node* next;  
24. }HASH_NODE;  
25. HASH_NODE* hash_table[HASHTABLESIZE];  
26.   
27. HASH_NODE* creat_node(int& data)  
28. {  
29.     HASH_NODE* node = (HASH_NODE*)malloc(sizeof(HASH_NODE));  
30.       
31.     if (NULL == node)  
32.     {  
33.         printf("malloc node failed!/n");  
34.         exit(EXIT_FAILURE);  
35.     }  
36.       
37.     node->data = data;  
38.     node->count = 1;  
39.     node->next = NULL;  
40.     return node;  
41. }  
42.   
43. /**  
44. * hash函数采用乘法散列法 
45. * h(k)=int(m*(A*k mod 1)) 
46. */  
47. int hash_function(int& key)    
48. {    
49.     double result = A * key;  
50.     return (int)(M * (result - (int)result));    
51. }  
52.   
53. void insert(int& data)  
54. {  
55.     int index = hash_function(data);  
56.     HASH_NODE* pnode = hash_table[index];  
57.     while (NULL != pnode)  
58.     {   // 以存在data，则count++  
59.         if (pnode->data == data)  
60.         {  
61.             pnode->count += 1;  
62.             return;  
63.         }  
64.         pnode = pnode->next;  
65.     }  
66.       
67.     // 建立一个新的节点，在表头插入  
68.     pnode = creat_node(data);  
69.     pnode->next = hash_table[index];  
70.     hash_table[index] = pnode;  
71. }  
72.   
73. /**  
74. * destroy_node释放创建节点产生的所有内存 
75. */  
76. void destroy_node()  
77. {  
78.     HASH_NODE* p = NULL;  
79.     HASH_NODE* tmp = NULL;  
80.     for (int i = 0; i < HASHTABLESIZE; ++i)  
81.     {  
82.         p = hash_table[i];  
83.         while (NULL != p)  
84.         {  
85.             tmp = p;  
86.             p = p->next;  
87.             free(tmp);  
88.             tmp = NULL;  
89.         }  
90.     }  
91. }  
92.   
93. typedef struct min_heap  
94. {  
95.     int count;  
96.     int data;  
97. }MIN_HEAP;  
98. MIN_HEAP heap[HEAPSIZE + 1];  
99.   
100. /**  
101. * min_heapify函数对堆进行更新，使以i为跟的子树成最大堆 
102. */  
103. void min_heapify(MIN_HEAP* H, const int& size, int i)  
104. {  
105.     int l = LEFT(i);  
106.     int r = RIGHT(i);  
107.     int smallest = i;  
108.       
109.     if (l <= size && H[l].count < H[i].count)  
110.         smallest = l;  
111.     if (r <= size && H[r].count < H[smallest].count)  
112.         smallest = r;  
113.       
114.     if (smallest != i)  
115.     {  
116.         MIN_HEAP tmp = H[i];  
117.         H[i] = H[smallest];  
118.         H[smallest] = tmp;  
119.         min_heapify(H, size, smallest);  
120.     }  
121. }  
122.   
123. /**  
124. * build_min_heap函数对数组A中的数据建立最小堆 
125. */  
126. void build_min_heap(MIN_HEAP* H, const int& size)  
127. {  
128.     for (int i = size/2; i >= 1; --i)  
129.         min_heapify(H, size, i);  
130. }  
131.   
132. /**  
133. * traverse_hashtale函数遍历整个hashtable，更新最小堆 
134. */  
135. void traverse_hashtale()  
136. {  
137.     HASH_NODE* p = NULL;  
138.     for (int i = 0; i < HASHTABLESIZE; ++i)  
139.     {  
140.         p = hash_table[i];  
141.         while (NULL != p)  
142.         {   // 如果当前节点的数量大于最小堆的最小值，则更新堆  
143.             if (p->count > heap[1].count)  
144.             {  
145.                 heap[1].count = p->count;  
146.                 heap[1].data = p->data;  
147.                 min_heapify(heap, HEAPSIZE, 1);  
148.             }  
149.             p = p->next;  
150.         }  
151.     }  
152. }  
153.   
154. int main()  
155. {  
156.     // 初始化最小堆  
157.     for (int i = 1; i <= 10; ++i)  
158.     {  
159.         heap[i].count = -i;  
160.         heap[i].data = i;  
161.     }  
162.     build_min_heap(heap, HEAPSIZE);  
163.       
164.     FILE* fp = fopen("data.txt", "r");  
165.     int num;  
166.     while (!feof(fp))  
167.     {  
168.         fscanf(fp, "%d", &num);  
169.         insert(num);  
170.     }  
171.     fclose(fp);  
172.       
173.     traverse_hashtale();  
174.       
175.     for (i = 1; i <= 10; ++i)  
176.     {  
177.         printf("%d/t%d/n", heap[i].data, heap[i].count);  
178.     }  
179.       
180.     return 0;  
181. }   

程序测试：对65047kb的数据量文件，进行测试统计（不过，因其数据量实在太大，半天没打开）：

运行结果：如下，

第四节、海量数据处理问题一般总结

关于海量数据处理的问题，一般有Bloom filter，Hashing，bit-map，堆，trie树等方法来处理。更详细的介绍，请查看此文：十道海量数据处理面试题与十个方法大总结。

余音

反馈：此文发布后，走进搜索引擎的作者&&深入搜索引擎-海量信息的压缩、索引和查询的译者，梁斌老师，对此文提了点意见，如下：1、首先TopK问题，肯定需要有并发的，否则串行搞肯定慢，IO和计算重叠度不高。其次在IO上需要一些技巧，当然可能只是验证算法，在实践中IO的提升会非常明显。最后上文的代码可读性虽好，但机器的感觉可能就会差，这样会影响性能。2、同时，TopK可以看成从地球上选拔k个跑的最快的，参加奥林匹克比赛，各个国家自行选拔，各个大洲选拔，层层选拔，最后找出最快的10个。发挥多机多核的优势。