C语言之霍夫曼编码学习

?
1，霍夫曼编码描述
哈夫曼树─即最优二叉树，带权路径长度最小的二叉树，经常应用于数据压缩。 在计算机信息处理中,“哈夫曼编码”是一种一致性编码法（又称“熵编码法”），用于数据的无损耗压缩。这一术语是指使用一张特殊的编码表将源字符（例如某文件中的一个符号）进行编码。这张编码表的特殊之处在于，它是根据每一个源字符出现的估算概率而建立起来的（出现概率高的字符使用较短的编码，反之出现概率低的则使用较长的编码，这便使编码之后的字符串的平均期望长度降低，从而达到无损压缩数据的目的）。这种方法是由David.A.Huffman发展起来的。 例如，在英文中，e的出现概率很高，而z的出现概率则最低。当利用哈夫曼编码对一篇英文进行压缩时，e极有可能用一个位(bit)来表示，而z则可能花去25个位（不是26）。用普通的表示方法时，每个英文字母均占用一个字节（byte），即8个位。二者相比，e使用了一般编码的1/8的长度，z则使用了3倍多。若能实现对于英文中各个字母出现概率的较准确的估算，就可以大幅度提高无损压缩的比例。

2，问题描述
霍夫曼编码前首先要统计每个字的字频，即出现次数，例如：

1、将所有字母出现的次数以从小到大的顺序排序，如上图

2、每个字母都代表一个终端节点（叶节点），比较F.O.R.G.E.T五个字母中每个字母的出现频率，将最小的两个字母频率相加合成一个新的节点。如上图所示，发现F与O的频率最小，故相加2+3=5，将F、O组成一个树，F为左节点，O为右节点，（FO）为根节点，每个节点的取值为其出现频率（FO的出现频率为5）

3、比较5.R.G.E.T，发现R与G的频率最小，故相加4+4=8，将RG组成一个新的节点

4、比较5.8.E.T，发现5与E的频率最小，故相加5+5=10，因此将FO作为左节点，E作为右节点，FOE作为根节点

5、比较8.10.T，发现8与T的频率最小，故相加8+7=15，将RG作为左节点，T作为右节点，RGT作为根节点

6、最后剩10.15，没有可以比较的对象，相加10+15=25，FOE作为左节点，RGT作为右节点

根节点不取值，每个左子节点取值0，右子节点取值1，将每个字母从根节点开始遍历，沿途的取值组成编码：

首先选择一个文本，统计每个字符出现的次数，组成以下数组：
typedef struct FrequencyTreeNode {
    int freq;
    char c;
    struct FrequencyTreeNode *left;
    struct FrequencyTreeNode *right;
} FrequencyTreeNodeStruct, *pFrequencyTreeNodeStruct;

然后将获得的数组frequencies进行排序，按照freq由小到大的顺序组成一个二叉查找树，FrequencyTreeNodeStruct，从二叉查找树中找到最小的节点，从树中删除，再取最小的节点，两个子节点，组成一个新的树，根节点c为0，freq为两个子节点的和，加入frequencies中，并排序，重复该步骤，一直到frequencies中只有一个节点，则该节点为Huffman coding tree的根节点

以short类型按照前述的规则为每个字符编码，尔后将文本翻译为Huffman coding，再通过Huffman coding tree进行解码，验证编码的正确性。

3，代码实现

1. #include<stdio.h>
2. #define n 5 //叶子数目
3. #define m (2*n-1) //结点总数
4. #define maxval 10000.0
5. #define maxsize 100 //哈夫曼编码的最大位数
6. //定义结构体
7. typedef struct FrequencyTreeNode {
8. int freq;
9. char c;
10. struct FrequencyTreeNode *left;
11. struct FrequencyTreeNode *right;
12. } FrequencyTreeNodeStruct, *pFrequencyTreeNodeStruct;
13. FrequencyTreeNodeStruct frequencies[MAXALPABETNUM];
14. typedef struct
15. {
16. char bits[n]; //位串
17. int start; //编码在位串中的起始位置
18. char ch; //字符
19. }codetype;
20. // 读取文件内容，统计字符以及出现频率
21. void readTxtStatistics(char* fileName)
22. {
23. unsigned int nArray[52] = {0};
24. unsigned int i, j;
25. char szBuffer[MAXLINE];
26. int k=0;
27. // 读取文件内容
28. FILE* fp = fopen(fileName, \"r\");
29. if (fp != NULL)
30. { /*读取文件内容,先统计字母以及出现次数*/
31. while(fgets(szBuffer, MAXLINE, fp)!=NULL)
32. {
33. for(i = 0; i < strlen(szBuffer); i++)
34. {
35. if(szBuffer[i] <= \‘Z\‘ && szBuffer[i] >= \‘A\‘)
36. {
37. j = szBuffer[i] - \‘A\‘;
38. }
39. else if(szBuffer[i] <= \‘z\‘ && szBuffer[i] >= \‘a\‘)
40. {
41. j = szBuffer[i] - \‘a\‘ + 26;
42. }
43. else
44. continue;
45. nArray[j]++;
46. }
47. }
48. // 然后赋值给frequencies数组
49. for(i = 0, j = \‘A\‘; i < 52; i++, j++)
50. {
51. if (nArray[i] >0)
52. {
53. /*****/
54. frequencies[k].c=j;
55. frequencies[k].freq=nArray[i];
56. frequencies[k].left=NULL;
57. frequencies[k].right=NULL;
58. k++;
59. printf(\"%c:%d\\n\", j, nArray[i]);
60. }
61. if(j == \‘Z\‘)
62. j = \‘a\‘ - 1;
63. }
64. }
65. }
66. //建立哈夫曼树
67. void huffMan(frequencies tree[]){
68. int i,j,p1,p2;//p1,p2分别记住每次合并时权值最小和次小的两个根结点的下标
69. float small1,small2,f;
70. char c;
71. for(i=0;i<m;i++) //初始化
72. {
73. tree[i].parent=0;
74. tree[i].lchild=-1;
75. tree[i].rchild=-1;
76. tree[i].weight=0.0;
77. }
78. printf(\"【依次读入前%d个结点的字符及权值(中间用空格隔开)】\\n\",n);
79. //读入前n个结点的字符及权值
80. for(i=0;i<n;i++)
81. {
82. printf(\"输入第%d个字符为和权值\",i+1);
83. scanf(\"%c %f\",&c,&f);
84. getchar();
85. tree[i].ch=c;
86. tree[i].weight=f;
87. }
88. //进行n-1次合并，产生n-1个新结点
89. for(i=n;i<m;i++)
90. {
91. p1=0;p2=0;
92. //maxval是float类型的最大值
93. small1=maxval;small2=maxval;
94. //选出两个权值最小的根结点
95. for(j=0;j<i;j++)
96. {
97. if(tree[j].parent==0)
98. if(tree[j].weight<small1)
99. {
100. small2=small1; //改变最小权、次小权及对应的位置
101. small1=tree[j].weight;
102. p2=p1;
103. p1=j;
104. }
105. else if(tree[j].weight<small2)
106. {
107. small2=tree[j].weight; //改变次小权及位置
108. p2=j;
109. }
110. tree[p1].parent=i;
111. tree[p2].parent=i;
112. tree[i].lchild=p1; //最小权根结点是新结点的左孩子
113. tree[i].rchild=p2; //次小权根结点是新结点的右孩子
114. tree[i].weight=tree[p1].weight+tree[p2].weight;
115. }
116. }
117. }
118. //根据哈夫曼树求出哈夫曼编码，code[]为求出的哈夫曼编码，tree[]为已知的哈夫曼树
119. void huffmancode(codetype code[],frequencies tree[])
120. {
121. int i,c,p;
122. codetype cd; //缓冲变量
123. for(i=0;i<n;i++)
124. {
125. cd.start=n;
126. cd.ch=tree[i].ch;
127. c=i; //从叶结点出发向上回溯
128. p=tree[i].parent; //tree[p]是tree[i]的双亲
129. while(p!=0)
130. {
131. cd.start--;
132. if(tree[p].lchild==c)
133. cd.bits[cd.start]=\‘0\‘; //tree[i]是左子树，生成代码\‘0\‘
134. else
135. cd.bits[cd.start]=\‘1\‘; //tree[i]是右子树，生成代码\‘1\‘
136. c=p;
137. p=tree[p].parent;
138. }
139. code[i]=cd; //第i+1个字符的编码存入code[i]
140. }
141. }
142. //根据哈夫曼树解码
143. void decode(hufmtree tree[])
144. {
145. int i,j=0;
146. char b[maxsize];
147. char endflag=\‘2\‘; //电文结束标志取2
148. i=m-1; //从根结点开始往下搜索
149. printf(\"输入发送的编码(以\‘2\‘为结束标志)：\");
150. gets(b);
151. printf(\"编码后的字符为\");
152. while(b[j]!=\‘2\‘)
153. {
154. if(b[j]==\‘0\‘)
155. i=tree[i].lchild; //走向左子节点
156. else
157. i=tree[i].rchild; //走向右子节点
158. if(tree[i].lchild==-1) //tree[i]是叶结点
159. {
160. printf(\"%c\",tree[i].ch);
161. i=m-1; //回到根结点
162. }
163. j++;
164. }
165. printf(\"\\n\");
166. if(tree[i].lchild!=-1&&b[j]!=\‘2\‘) //文本读完，但尚未到叶子结点
167. printf(\"\\nERROR\\n\"); //输入文本有错
168. }
169. void main()
170. {
171. printf(\"---------------—— 哈夫曼编码实战 ——\\n\");
172. printf(\"总共有%d个字符\\n\",n);
173. frequencies tree[m];
174. codetype code[n];
175. int i,j;//循环变量
176. huffMan(tree);//建立哈夫曼树
177. huffmancode(code,tree);//根据哈夫曼树求出哈夫曼编码
178. printf(\"【输出每个字符的哈夫曼编码】\\n\");
179. for(i=0;i<n;i++)
180. {
181. printf(\"%c: \",code[i].ch);
182. for(j=code[i].start;j<n;j++)
183. printf(\"%c \",code[i].bits[j]);
184. printf(\"\\n\");
185. }
186. printf(\"【读入内容，并进行编码】\\n\");
187. // 开始编码
188. decode(tree);
189. }

----------------------------------------------------------------------------------------------------------------
<版权所有，文章允许转载，但必须以链接方式注明源地址，否则追究法律责任!>
原博客地址： http://blog.itpub.net/26230597/viewspace-1384144/
原作者：黄杉 (mchdba)
----------------------------------------------------------------------------------------------------------------