海量数据Top K算法（C实现）

 最近2天受到http://blog.youkuaiyun.com/v_JULY_v/archive/2011/05/08/6403777.aspx的影响，从头开始实现了这个算法。收获还是挺大的：（1）实现了Hash链表（2）实现了堆；（3）熟悉了C语言的文件操作；

     海量数据处理的Top K 算法就是在很大的文件中找出重复出现次数最多的前K个字符串；

     如果数据可以一次读入内存，那么可以按照如下思路来解决：

    （1）首先遍历文件，将其加入Hash链表；Hash链表的节点定义为：

view plain

1. typedef struct node  
2. {  
3.     char *word;  
4.     int count;  
5.     struct node *next;  
6. }node,*node_ptr;  

word指向字符串，count为出现的次数；

   （2）建立一个容量为K的最小堆，然后遍历Hash表中剩下的元素；如果找到了一个元素的count值比这个元素值大，那么交换这个节点和堆顶节点；

     完整全部代码如下：在Eclipse + CDT + mingw 下调试通过

     程序有待完善的地方：

     （1）存在一个位置bug:改变HASHLEN的值，程序崩溃；

      （2）HASH链表的遍历不正确，应该遍历到每一个节点的时候，在判断该节点的next是否为空；

 

    

view plain

1. # include <stdio.h>  
2. # include <string.h>  
3. # include <malloc.h>  
4. # include <assert.h>  
5. # include <stdlib.h>  
6. #define HASHLEN 101  
7. #define WORDLEN 30  
8. #define MAX  100000  
9. #define DOMAIN 300  
10. #define K 5  
11. //Hash链表的节点定义  
12. typedef struct node  
13. {  
14.     char *word;  
15.     int count;  
16.     struct node *next;  
17. }node,*node_ptr;  
18. static node_ptr head[HASHLEN];  
19. static node array[K];  
20. //Hash函数  
21. int hash_function(char *p)  
22. {  
23.     unsigned int value = 0;  
24.     while (*p != '/0')  
25.     {  
26.         value = value * 31 + *p++;  
27.         if (value > HASHLEN)  
28.             value = value % HASHLEN;  
29.     }  
30.     return value;  
31. }  
32. //加入节点到HASH链表  
33. void append_word(char *str)  
34. {  
35.     int index = hash_function(str);  
36.     node_ptr p = head[index];  
37.     while (p != NULL)  
38.     {  
39.         if (strcmp(str, p->word) == 0)  
40.         {  
41.             (p->count)++;  
42.             return;  
43.         }  
44.         p = p->next;  
45.     }  
46.     // 新建一个结点  
47.     node_ptr q = (node_ptr)malloc(sizeof(node));  
48.     q->count = 1;  
49.     q->word = (char *)malloc(sizeof(str) + 1);  
50.     strcpy(q->word, str);  
51. //    q->word = str;  
52.     q->next = head[index];  
53.     head[index] = q;  
54. }  
55. //产生0~DOMAIN - 1范围内的MAX个整数  
56. void gen_data()  
57. {  
58.     FILE *fp = fopen("c://data1.txt", "w");  
59.     assert(fp);  
60.     int i = 0;  
61.     srand((int)(time(0)));  
62.     for (i = 0; i < MAX; i++)  
63.         fprintf(fp,"%d  ",rand()%DOMAIN);  
64.     fclose(fp);  
65. }  
66. //堆调整:调整为最小堆  
67. void heapAdjust(node array[], int beginIndex, int endIndex, int index)  
68. {  
69.     int length = endIndex - beginIndex + 1;  
70.     int largestIndex = index;  
71.     int leftIndex = 2 * index + 1;     //下标从0开始，可以自己做实验  
72.     int rightIndex = 2 * index + 2;  
73.     if (leftIndex <= length - 1 && array[leftIndex].count <= array[largestIndex].count )  
74.         {  
75.             largestIndex = leftIndex;  
76.         }  
77.     if (rightIndex <= length - 1 && array[rightIndex].count <= array[largestIndex].count )  
78.         {  
79.             largestIndex = rightIndex;  
80.         }  
81.     if (largestIndex != index)  
82.         {  
83.             node temp = array[largestIndex];  
84.             array[largestIndex] = array[index];  
85.             array[index] = temp;  
86.             heapAdjust (array, beginIndex, endIndex, largestIndex);  
87.         }  
88. }  
89. //建堆  
90. void heapBuild (node array[], int len )  
91.     {  
92.         int i = 0;  
93.         for (i = len/2 - 1; i >= 0; i --)  
94.         {  
95.             heapAdjust (array, 0, len - 1, i);  
96.         }  
97.     }  
98.   
99. int main()  
100. {  
101.     gen_data();  
102.     char str[WORDLEN];  
103. //  char *str;  
104.     int i;  
105.     int cnt1 = 0;  
106.     for (i = 0; i < HASHLEN; i++)  
107.        head[i] = NULL;  
108.     FILE *fp_passage = fopen("c://data1.txt", "r");  
109.     assert(fp_passage);  
110.     while (fscanf(fp_passage, "%s", str) != EOF)  
111.     {  
112.         cnt1++;  
113.         append_word(str);  
114.        }  
115.     printf("the cnt1 is %d/n", cnt1);  
116.          fclose(fp_passage);  
117.          //寻找Top K  
118.     for(i = 0; i < HASHLEN; i++)  
119.     {  
120.         if(i < K - 1)  
121.                 array[i] = *head[i];  
122.         else  
123.             if(i == K - 1)  
124.                 {  
125.                 array[i] = *head[i];  
126.                 heapBuild(array,K);  
127.                 }  
128.             else  
129.             {  
130.                 if(array[0].count < head[i]->count)  
131.                 {  
132.                     array[0] = *head[i];  
133.                     heapAdjust(array,0,K - 1,0);  
134.                 }  
135.             }  
136.     }  
137.     printf("the top K is as follows/n");  
138.     for(i = 0; i < K; i++)  
139.          printf("%s , and its count is %d/n",array[i].word, array[i].count);  
140. //  printf("the total number of word is %d",cnt);  
141.     return 0;  
142. }  

    

   运行结果：

100000个树中重复出现次数最多的前5个数：

the top K is as follows
49 , and its count is 372
4 , and its count is 374
249 , and its count is 373
246 , and its count is 380
227 , and its count is 376

http://blog.youkuaiyun.com/randyjiawenjie/article/details/6417753