重温经典之赫夫曼(Huffman)编码

先看看赫夫曼树
假设有n个权值{w1,w2,…，wn}，构造一个有n个叶子结点的二叉树，每个叶子结点权值为wi,则其中带权路径长度WPL最小的二叉树称作赫夫曼树或最优二叉树。
 
赫夫曼树的构造，赫夫曼最早给出了带有一般规律的算法，俗称赫夫曼算法。如下：
（1）根据给定的n个权值{w1,w2,…，wn}构造n棵二叉树的集合F={T1,T2,…，Tn}，其中Ti中只有一个权值为wi的根结点，左右子树为空。
（2）在F中选取两棵根结点的权值为最小的数作为左、右子树以构造一棵新的二叉树，且置新的二叉树的根结点的权值为左、右子树上根结点的权值之和。
（3）在F中删除这两棵树，同时将新得到的二叉树加入到F中。
（4）重复（2）和（3）直到F中只含一棵树为止，这棵树就是赫夫曼树。

例如下图便是赫夫曼树的构造过程。其中，根节点上标注的是所赋的权值。

设计一棵赫夫曼树，由此得到的二进制前缀编码就是赫夫曼编码。那么什么是前缀编码呢？所谓前缀编码，就是若要设计长短不等的编码，则必须是任意一个字符的编码都不是另一个字符编码的前缀。所以我们可以利用二叉树来设计二进制的前缀编码。

假设需要传送的字符为：A B A C C D A。如下图就是一个前缀编码的示例。

http://blog.csdn.net/fengchaokobe/article/details/6969217

说了这么多理论，总该实践一下了，下面是赫夫曼编码的具体实现代码:

1. #include <stdio.h>
2. #include <string.h>
3. #include <malloc.h>
4. #include <assert.h>
5. #define NUM 256
6. typedef struct{
7. int weight;
8. int parent, lchild, rchild;
9. }HTNode, *HuffmanTree;
10. /******* Choose two smallest from 0 to n in T *************/
11. void Select(HuffmanTree T, int len, int *s1, int *s2)
12. {
13. int i = 0;
14. while (T[i++].parent != -1);
15. *s1 = i-1;
16. while (T[i++].parent != -1);
17. *s2 = i-1;
18. if (T[*s1].weight>T[*s2].weight) {
19. i = *s1;
20. *s1 = *s2;
21. *s2 = i;
22. }
23. for (i=0; i<=len; i++) {
24. if(T[i].parent == -1) {
25. if (T[*s1].weight > T[i].weight) {
26. *s2 = *s1;
27. *s1 = i;
28. }
29. else if (T[*s2].weight >T[i].weight && i != *s1)
30. *s2 = i;
31. }
32. }
33. return;
34. }
35. void show_binary(char ch)
36. {
37. char i;
38. for (i = 0; i < 8; i++) {
39. if (ch&0x80)
40. printf("1");
41. else printf("0");
42. if (i == 3)
43. printf(",");
44. ch <<= 1;
45. }
46. printf(" ");
47. }
48. void HuffmanCoding(FILE *psrc, FILE *pdst, FILE *pdeciphering)
49. {
50. int i;
51. char ch;
52. int m = 2*NUM-1;
53. int size = m*sizeof(HTNode);
54. HuffmanTree HT = (HuffmanTree)malloc(size);
55. assert(HT);
56. memset(HT, -1, size);
57. for (i=0; i<NUM; i++)
58. HT[i].weight = 0;
59. while ((ch=fgetc(psrc)) != EOF) {
60. (HT[ch].weight)++;
61. }
62. rewind(psrc);
63. /******************printf the Huffman weight****
64. int j;
65. for(j=0; j<NUM; j++) {
66. printf("%c:%d\t", j, HT[j].weight);
67. }
68. **********************************************/
69. int s1, s2;
70. for (i=NUM; i<m; i++) {
71. Select(HT, i-1, &s1, &s2);
72. HT[s1].parent = i; HT[s2].parent = i;
73. HT[i].lchild = s1; HT[i].rchild = s2;
74. HT[i].weight = HT[s1].weight + HT[s2].weight;
75. }
76. /*******************printf the HuffmanTree*********
77. int j;
78. for (j=0; j<m; j++)
79. printf("%d:w%d p%d l%d r%d\t\t", j, HT[j].weight,
80. HT[j].parent, HT[j].lchild, HT[j].rchild);
81. **************************************************/
82. char **HC = (char**)malloc(NUM*sizeof(char*));
83. char* cd = (char*)malloc(NUM*sizeof(char));
84. cd[NUM-1] = '\0';
85. int start,c,f;
86. for (i=0; i<NUM; i++) {
87. start = NUM-1;
88. for (c=i,f=HT[i].parent; f!=-1; c=f,f=HT[f].parent) {
89. if (HT[f].lchild==c) cd[--start] ='0';
90. else cd[--start] ='1';
91. }
92. HC[i] = (char *)malloc((NUM-start)*sizeof(char));
93. strcpy(HC[i], &cd[start]);
94. }
95. /************printf the Huffmancode******************************
96. int j;
97. for (j=0; j<NUM; j++) {
98. printf("%c:%s\t", j, HC[j]);
99. }
100. ****************************************************************/
101. char buff[100] = {0};
102. char k = 0, j = 0;
103. while ((ch=fgetc(psrc)) != EOF) {
104. i = -1;
105. while (HC[ch][++i] != '\0') {
106. buff[j] <<= 1;
107. k++;
108. if (HC[ch][i] == '1')
109. buff[j] |= 0x01;
110. if ((k %= 8) == 0)
111. j++;
112. if (j == 100) {
113. j =0;
114. fwrite(buff, 1, 100, pdst);
115. }
116. }
117. }
118. buff[j] <<= (8-k);
119. fwrite(buff, 1, j + 1, pdst);
120. /*****************************************************
121. printf("\ndata write to %s\n", dstfile);
122. for (i=0; i<=j; i++)
123. show_binary(buff[i]);
124. ***************************************************/
125. rewind(pdst);
126. fflush(pdst);
127. c = 510;
128. while (!feof(pdst)) {
129. j = fread(buff, 1, 100, pdst);
130. /********************************************
131. printf("\nfrom read:\n");
132. for (i=0; i<j; i++)
133. show_binary(buff[i]);
134. *******************************************/
135. for (i=0; i<j; i++) {
136. for (k=0; k<8; k++) {
137. if (buff[i]&0x80)
138. c = HT[c].rchild;
139. else c = HT[c].lchild;
140. if (HT[c].lchild == -1) {
141. fputc((char)c, pdeciphering);
142. c = 510;
143. }
144. buff[i] <<= 1;
145. }
146. }
147. }
148. /**************free the memery and return*******************/
149. for(i=0; i<NUM; i++) {
150. free(HC[i]);
151. }
152. free(cd);
153. free(HC);
154. free(HT);
155. HT = NULL;
156. fclose(pdst);
157. fclose(psrc);
158. fclose(pdeciphering);
159. return;
160. }
161. int main(void)
162. {
163. char srcfile[100], dstfile[100],deciphering[100];
164. printf("Input source file:");
165. scanf("%s", srcfile);
166. printf("Input dest file:");
167. scanf("%s", dstfile);
168. printf("Input deciphering file:");
169. scanf("%s", deciphering);
170. FILE *psrc = fopen(srcfile, "r");
171. FILE *pdst = fopen(dstfile, "w+");
172. FILE *pdeciphering = fopen(deciphering, "w");
173. if (psrc == NULL || pdst == NULL || pdeciphering == NULL) {
174. printf("file opened failed\n");
175. return -1;
176. }
177. else
178. HuffmanCoding(psrc, pdst, pdeciphering);
179. return 0;
180. }