C语言 词频统计

cobras

下面的算法按空格分词。

1. #include <ctype.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. 
   
6. #define MAX_WORD_TYPE       1024
   
7. #define FILE_NAME           "cntword.c"
   
8. 
   
9. struct word
   
10. {
    
11.         const char *word;
    
12.         int word_len;
    
13.         int count;
    
14. };
    
15. 
    
16. char *read_file(const char *file, int *o_len)
    
17. {
    
18.         FILE *fp;
    
19.         char *buf;
    
20.         long len;
    
21. 
    
22.         fp = fopen(file, "rb");
    
23.         if (fp != NULL) {
    
24.                 fseek(fp, 0, SEEK_END);
    
25.                 len = ftell(fp);
    
26.                 fseek(fp, 0, SEEK_SET);
    
27.                 buf = (char *)malloc(len);
    
28.                 if (buf != NULL) {
    
29.                         if (fread(buf, len, 1, fp) == 1) {
    
30.                                 *o_len = len;
    
31.                                 fclose(fp);
    
32.                                 return buf;
    
33.                         }
    
34.                         free(buf);
    
35.                 }
    
36.                 fclose(fp);
    
37.         }
    
38.         return NULL;
    
39. }
    
40. 
    
41. int nstr_ltrim(const char *s, int off, int lmt)
    
42. {
    
43.         int i;
    
44. 
    
45.         for (i = off; i < lmt; ++i) {
    
46.                 if (!isspace(s[i])) {
    
47.                         break;
    
48.                 }
    
49.         }
    
50.         return i;
    
51. }
    
52. 
    
53. int nstr_get_next_space(const char *s, int off, int lmt)
    
54. {
    
55.         int i;
    
56.        
    
57.         for (i = off; i < lmt; ++i) {
    
58.                 if (isspace(s[i])) {
    
59.                         break;
    
60.                 }
    
61.         }
    
62.         return i;
    
63. }
    
64. 
    
65. int get_word(const char *s, int *io_off, int lmt, int *o_word_off, int *o_word_lmt)
    
66. {
    
67.         int off;
    
68.         int word_off;
    
69.         int word_lmt;
    
70. 
    
71.         off = *io_off;
    
72.         off = nstr_ltrim(s, off, lmt);
    
73.         if (off < lmt) {
    
74.                 word_off = off;
    
75.                 off = nstr_get_next_space(s, off, lmt);
    
76.                 word_lmt = off;
    
77.                 *io_off = off;
    
78.                 *o_word_off = word_off;
    
79.                 *o_word_lmt = word_lmt;
    
80.                 return 0;
    
81.         }
    
82.         return -1;
    
83. }
    
84. 
    
85. int add_word(struct word *table, int table_len, const char *word, int word_len)
    
86. {
    
87.         int i;
    
88. 
    
89.         for (i = 0; i < table_len; ++i) {
    
90.                 if (table[i].word == NULL) {
    
91.                         break;
    
92.                 }
    
93.                 if (table[i].word_len == word_len && strncmp(table[i].word, word, word_len) == 0) {
    
94.                         ++table[i].count;
    
95.                         return 0;
    
96.                 }
    
97.         }
    
98.         if (i < table_len) {
    
99.                 table[i].word = word;
    
100.                 table[i].word_len = word_len;
     
101.                 table[i].count = 1;
     
102.                 return 0;
     
103.         }
     
104.         return -1;
     
105. }
     
106. 
     
107. int count_word(char *file, int file_len, struct word *table, int table_len)
     
108. {
     
109.         int file_off;
     
110.         int word_off, word_lmt;
     
111. 
     
112.         file_off = 0;
     
113.         while (get_word(file, &file_off, file_len, &word_off, &word_lmt) == 0) {
     
114.                 add_word(table, table_len, file + word_off, word_lmt - word_off);
     
115.         }
     
116.         return 0;
     
117. }
     
118. 
     
119. int print_word(struct word *table, int table_len)
     
120. {
     
121.         int i;
     
122. 
     
123.         for (i = 0; i < table_len; ++i) {
     
124.                 if (table[i].word == NULL) {
     
125.                         break;
     
126.                 }
     
127.                 fwrite(table[i].word, 1, table[i].word_len, stdout);
     
128.                 printf(": %d\n", table[i].count);
     
129.         }
     
130.         return 0;
     
131. }
     
132. 
     
133. int get_table_len(struct word *table, int table_len)
     
134. {
     
135.         int i;
     
136. 
     
137.         for (i = 0; i < table_len; ++i) {
     
138.                 if (table[i].word == NULL) {
     
139.                         break;
     
140.                 }
     
141.         }
     
142.         return i;
     
143. }
     
144. 
     
145. int compare_word(const struct word *word1, const struct word *word2)
     
146. {
     
147.         if (word1->count < word2->count) {
     
148.                 return 1;
     
149.         }else if (word1->count > word2->count) {
     
150.                 return -1;
     
151.         }
     
152.         return 0;
     
153. }
     
154. 
     
155. int main(void)
     
156. {
     
157.         struct word table[MAX_WORD_TYPE];
     
158.         char *file;
     
159.         int len;
     
160.         int table_len;
     
161. 
     
162.         file = read_file(FILE_NAME, &len);
     
163.         if (file != NULL) {
     
164.                 memset(table, 0, sizeof(table));
     
165.                 count_word(file, len, table, MAX_WORD_TYPE);
     
166.                 table_len = get_table_len(table, MAX_WORD_TYPE);
     
167.                 qsort(table, table_len, sizeof(struct word), compare_word);
     
168.                 print_word(table, table_len);
     
169.                 free(file);
     
170.                 return 0;
     
171.         }
     
172.         return -1;
     
173. }
     

复制代码

laoliuya

回复 11# cobras


    哇！辛苦了。我读这估计比较困难。我来仔细读读