【C】语言写的基于Trie的字典统计单词出现次数

usr

受到：【C】语言编写的字典支持各种类型扩展 这篇帖子的启发，写了一个C语言基于Trie的字典。
这个工程使用了StoneValley库。
StoneValley库在使用的时候将库文件全部添加到工程即可。
以后还会写一些基于StoneValley库的代码供大家参考。
以下是主函数文件的代码：

1. 
   
2. #include <stdio.h>
   
3. #include <ctype.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include "svtree.h"
   
7. #include "svstring.h"
   
8. 
   
9. typedef struct st_VOCABULARY
   
10. {
    
11.         long freq; /* 单词频率 */
    
12.         char * pword; /* malloc申请的单词字符串 */
    
13. } VOCABULARY, * P_VOCABULARY;
    
14. 
    
15. P_VOCABULARY CreateWord()
    
16. {
    
17.         P_VOCABULARY pvol = malloc(sizeof(VOCABULARY));
    
18.         if (NULL != pvol)
    
19.         {
    
20.                 pvol->freq = 1;
    
21.                 pvol->pword = NULL;
    
22.         }
    
23.         return pvol;
    
24. }
    
25. 
    
26. void DeleteWord(P_VOCABULARY pvol)
    
27. {
    
28.         free(pvol->pword);
    
29.         free(pvol);
    
30. }
    
31. 
    
32. void DestoryArray(P_ARRAY_Z parrz)
    
33. {
    
34.         size_t i = 0;
    
35.         for (; i < parrz->num; ++i)
    
36.         {
    
37.                 P_VOCABULARY pvol = *(((P_VOCABULARY *)parrz->pdata) + i);
    
38.                 DeleteWord(pvol);
    
39.         }
    
40.         strFreeArrayZ(parrz);
    
41. }
    
42. 
    
43. int CbfPrintResult(void * pitem, size_t param)
    
44. {
    
45.         printf("%s %lu\n", (*((P_VOCABULARY *)pitem))->pword, (*((P_VOCABULARY *)pitem))->freq);
    
46.         DWC4100(param);
    
47.         return CBF_CONTINUE;
    
48. }
    
49. 
    
50. int cbfcmpchar(const void * px, const void * py)
    
51. {
    
52.         return *(char *)px - *(char *)py;
    
53. }
    
54. 
    
55. int cbfcmpfreq(const void * px, const void * py)
    
56. {
    
57.         return (*(P_VOCABULARY *)py)->freq - (*(P_VOCABULARY *)px)->freq;
    
58. }
    
59. 
    
60. int main(int argc, char * argv[])
    
61. {
    
62.         int c;
    
63.         long i, j = 0, k = 0, sizeBuffer = 1024, sizeArray = 1024;
    
64.         BOOL bCase = FALSE, bSort = FALSE;
    
65.         char * buffer = NULL;
    
66.         P_TRIE_A ptrie;
    
67.         ARRAY_Z arrz;
    
68. 
    
69.         if (NULL == (buffer = (char *) malloc(sizeBuffer)))
    
70.                 return 1;
    
71.         *buffer = '\0';
    
72.         if (NULL == (ptrie = treCreateTrieA()))
    
73.                 return 2;
    
74.         if (NULL == strInitArrayZ(&arrz, sizeArray, sizeof(P_VOCABULARY)))
    
75.                 return 3;
    
76. 
    
77.         for (i = 1; i < argc; ++i)
    
78.         {
    
79.                 if (0 == strcmp("-s", argv[i])) /* 排序开关 */
    
80.                         bSort = TRUE;
    
81.                 else if (0 == strcmp("-c", argv[i])) /* 大小写开关 */
    
82.                         bCase = TRUE;
    
83.                 else
    
84.                         return 4;
    
85.         }
    
86.         while (EOF != (c = fgetc(stdin)))
    
87.         {
    
88.                 if (j >= sizeBuffer)
    
89.                 {
    
90.                         char * tempBuffer;
    
91.                         sizeBuffer += 1024;
    
92.                         if (NULL == (tempBuffer = realloc(buffer, sizeBuffer)))
    
93.                                 return 5;
    
94.                         buffer = tempBuffer;
    
95.                 }
    
96.                 if (c >= 'A' && c <= 'Z')
    
97.                 {
    
98.                         *(buffer + j++) = bCase ? (char)c : (char)tolower(c);
    
99.                 }
    
100.                 else if (c >= 'a' && c <= 'z')
     
101.                 {
     
102.                         *(buffer + j++) = (char)c;
     
103.                 }
     
104.                 else
     
105.                 {
     
106.                         *(buffer + j) = '\0';
     
107.                         if (0 != j)
     
108.                         {
     
109.                                 size_t * presult;
     
110.                                 P_VOCABULARY pvol;
     
111.                                 size_t bufferLen = strlen(buffer);
     
112.                                 /* 在Trie里查询buffer所包含的单词 */
     
113.                                 if (NULL == (presult = treSearchTrieA(ptrie, buffer, bufferLen, sizeof(char), cbfcmpchar)))
     
114.                                 {
     
115.                                         if (k >= sizeArray)
     
116.                                         {
     
117.                                                 sizeArray += 1024;
     
118.                                                 strResizeArrayZ(&arrz, sizeArray, sizeof(P_VOCABULARY));
     
119.                                         }
     
120.                                         /* 如果没找到就创建一个新单词 */
     
121.                                         pvol = CreateWord();
     
122.                                         /* 将新单词插入Trie */
     
123.                                         treInsertTrieA(ptrie, buffer, bufferLen, sizeof(char), (size_t)pvol, cbfcmpchar);
     
124.                                         if (NULL == (pvol->pword = malloc(bufferLen + 1)))
     
125.                                                 return 6;
     
126.                                         memcpy(pvol->pword, buffer, bufferLen + 1);
     
127.                                         /* 将新单词的指针存储在数组里 */
     
128.                                         *(((P_VOCABULARY *)arrz.pdata) + k++) = pvol;
     
129.                                 }
     
130.                                 else
     
131.                                 {        /* 如果找到单词，就把Trie里存储的Appendix拿出来转换为P_VOCABULARY指针，并且把频率+1 */
     
132.                                         pvol = (P_VOCABULARY)*presult;
     
133.                                         ++pvol->freq;
     
134.                                 }
     
135.                         }
     
136.                         j = 0;
     
137. 
     
138.                 }
     
139.         }
     
140.         strResizeArrayZ(&arrz, k, sizeof(P_VOCABULARY));
     
141.         if (bSort)
     
142.                 strSortArrayZ(&arrz, sizeof(P_VOCABULARY), cbfcmpfreq);
     
143.         strTraverseArrayZ(&arrz, sizeof(P_VOCABULARY), CbfPrintResult, 0, FALSE);
     
144.         DestoryArray(&arrz);
     
145.         treDeleteTrieA(ptrie, sizeof(char));
     
146.         free(buffer);
     
147.         return 0;
     
148. }
     

复制代码

使用的时候（在Linux环境下）将工程里所有的文件编译为一个名为freq的可执行体：
$ cc *.c -o freq
将可执行体移动到Debug文件夹下就可以对其测试：
$ mv freq ../Debug
以下是一个供测试的小短文：
A wildfire burning in Grand County, Colorado, has exploded from 19,000 acres to more than 125,000 on Thursday, forcing thousands of families to evacuate.
The so-called East Troublesome Fire raced through the town of Grand Lake and into the western portion of Rocky Mountain National Park, which closed to visitors Thursday, CBS Denver reported.
Thick smoke and flames were closing in on homes and terrifying residents. Security video even captured the scene as flames overtook a home. It was not immediately clear how much damage the fire caused in the Grand Lake community.
"We know that historic buildings and businesses are on people's minds, and we just don't have confirmed information at this time. Many of the buildings and the establishments, they are the heart and soul of our community. And as soon we know something definitive, we'll share with those who are affected and the community," Mayor Steve Kudron said late Thursday morning, according to the TV station.
The flames are being driven by high winds and dead, dry timber.
"We plan for the worst. This is the worst of the worst of the worst," said Grand County Sheriff Brett Schroetlin while referencing the fire's 100,000-acre jump in mere hours.
Nearly 300 firefighters are battling the flames in dense wooded hills as the fire continues to spread into the national park. This wildfire could end up merging with the Cameron Peak Fire, which was reported to be burning just a few miles away, according to CBS Denver.
因为程序是用stdin作为输入，所以使用管道连接程序十分方便：
输入以下代码按单词出现顺序统计单词出现频率（区分大小写）：
$ cat new2.txt | ./freq -c
A 1
wildfire 2
burning 2
in 5
Grand 4
County 2
Colorado 1
has 1
exploded 1
from 1
acres 1
to 7
more 1
than 1
on 3
Thursday 3
forcing 1
thousands 1
of 7
families 1
evacuate 1
The 2
so 1
called 1
East 1
Troublesome 1
Fire 2
raced 1
through 1
the 19
town 1
Lake 2
and 9
into 2
western 1
portion 1
Rocky 1
Mountain 1
National 1
Park 1
which 2
closed 1
visitors 1
CBS 2
Denver 2
reported 2
Thick 1
smoke 1
flames 4
were 1
closing 1
homes 1
terrifying 1
residents 1
Security 1
video 1
even 1
captured 1
scene 1
as 3
overtook 1
a 2
home 1
It 1
was 2
not 1
immediately 1
clear 1
how 1
much 1
damage 1
fire 3
caused 1
community 3
We 2
know 2
that 1
historic 1
buildings 2
businesses 1
are 5
people 1
s 2
minds 1
we 3
just 2
don 1
t 1
have 1
confirmed 1
information 1
at 1
this 1
time 1
Many 1
establishments 1
they 1
heart 1
soul 1
our 1
And 1
soon 1
something 1
definitive 1
ll 1
share 1
with 2
those 1
who 1
affected 1
Mayor 1
Steve 1
Kudron 1
said 2
late 1
morning 1
according 2
TV 1
station 1
being 1
driven 1
by 1
high 1
winds 1
dead 1
dry 1
timber 1
plan 1
for 1
worst 4
This 2
is 1
Sheriff 1
Brett 1
Schroetlin 1
while 1
referencing 1
acre 1
jump 1
mere 1
hours 1
Nearly 1
firefighters 1
battling 1
dense 1
wooded 1
hills 1
continues 1
spread 1
national 1
park 1
could 1
end 1
up 1
merging 1
Cameron 1
Peak 1
be 1
few 1
miles 1
away 1
输入以下代码可以按频率由高到低的顺序显示单词和出现次数：
$ cat new2.txt | ./freq -s -c
以下代码可以显示包含特定字符串“the”的单词及出现次数（不区分大小写）：
$ cat new2.txt | ./freq | grep "the"

这里放出打包好的工程源码：
freq.7z (67.52 KB, 下载次数: 1)

2020-10-23 21:43 上传

点击文件名下载附件