计算机实践中发现，大多数信息的表达都存在着一定的冗余度，有效的降低这种冗余度可以使我们用更小的空间存储更大的数据量，同时在有限的通信带宽的情况下，可以传输更多的信息，等等……。那用什么办法可以降低这种冗余度，这里我们学习其中的一种huffman treee压缩（编码）和解压（译码）方法。
huffman tree的压缩和解压的过程如下：
1、描述
对于任意的ASCII格式的信息aba$a@ba*a$a，先统计它们的出现频率a6，b2，$2，*
1，@1，然后分别用不等长的01串来编码它们，如a1，b00，$011，*0100，@0101，后用01串替换原来的信息，得到100101110101001010010111，并按二进制位组合，这样就可以得到压缩后的文件。
相对应，解压时必须知道编码a1，b00，$011，*0100，@0101，然后根据1001011101010
01010010111一步步解压得到aba$a@ba*a$a原始信息。
2、分析
为了解压成功，首先必须保证任何已经编码的单个字符不能是其他字符编码的前缀，也就是说用1编码a以后，其他字符编码不能以1开头。为了实现压缩的小，同时要保证出现频率高的字符编码短，频率低的编码长。
3、方法
通过描述和分析，我们明白这种方法是可以实现压缩文件的，用什么办法可以实现这种方法呢？使用优二叉树也就是huffman tree可以实现上面的方法，步骤如下：
1） 将a6，b2，$2，*1，@1按照频率值从小到大有序入队，出队两个元素，分别以它们为左右子树，建立二叉树，并将它们出现次数之和作为根节点，把根节点有序入队。
2） 然后重复1步骤直到队中只剩下一个节点，该节点就是所求huffman tree的根节点，后按照左0，右1进行编码a1，b00，$011，*0100，@0101。
b2 4 a6
／ ＼
2 $2
／ ＼
@1 *1
|
6 a6
／ ＼
b2 4
／ ＼
2 $2
／ ＼
@1 *1
|
12
0／ 1＼
6 a6
0／ 1＼ 1
b2 4
00 0／ 1＼
2 $2
0／ 1＼ 011
*1 @1
0100 0101
|
4、步骤
第一步：统计aba$a@ba*a$a字符出现的频率，a6，b2，$2，*1，@1。
第二步：去除重复的字符ab$@*。
第三步：创建huffman tree，对ab$@*进行编码a1，b00，$011，*0100，@0101。
第四步：aba$a@ba*a$a根据编码a1，b00，$011，*0100，@0101压缩为10010111010
1001010010111。
第五步：100101110101001010010111根据huffman tree解压为aba$a@ba*a$a。
5、实现
treehuffman.c
1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include "treehuffman.h"
5. #include "../queue/queuelink.h"
&nbsnbsp; 6.
7. treehuffman *treecreate(char *s)
8. {
9. int w[256] = {};
10. int i;
11. char c[256] = {}, *pc = c;
12. queuelink *q = queuecreate();
13. queuedata temp;
14.
15. // 第一步
16. while(*s != '\0')
17. {
18. w[(int)*s++]++;
19. }
20.
21. // 第二步
22. for(i=0; i<256; i++)
23. {
24. if(w[i] != 0)
25. {
26. *pc++ = i;
27. }
28. }
nbsp; 29.
30. // 第三步
31. pc = c;
32. while(*pc != '\0')
33. {
34. temp = (treehuffman *)malloc(sizeof(treehuffman));
35.
36. temp->c = *pc;
37. temp->w = w[(int)*pc++];
38. temp->code[0] = '\0';
39. temp->lchild = temp->rchild = NULL;
40.
41. queueenterorder(q, temp);
42. }
43.
44. while(q->front->next != q->rear)
45. {
46. temp = (treehuffman *)malloc(sizeof(treehuffman));
47.
48. temp->code[0] = '\0';
49. temp->lchild = queuedelete(q);
50. temp->rchild = queuedelete(q);
51. temp->w = temp->lchild->w+temp->rchild->w;
52.
53. queueenterorder(q, temp);
54. }
55.
56. return queuedelete(q);
57. }
58.
59. // 第四步
60. char *treecompress(treehuffman *t, char *s, char *compressed)
61. {
62. queuelink *q = queuecreate();
63. queuedata temp;
64. char *code[256];
65.
66. queueenter(q, t);
67.
68. while(queueempty(q) == 0)
69. {
70. temp = queuedelete(q);
71.
72. if(temp->lchild==NULL && temp->rchild==NULL)
73. {
74. code[(int)temp->c] = temp->code;
75. printf("%c(%d) : %s\n", temp->c, temp->w, temp->code);
76. }
77.
78. if(temp->lchild != NULL)
79. {
80. strcpy(temp->lchild->code, temp->code);
81. strcat(temp->lchild->code, "0");
82. queueenter(q, temp->lchild);
83. }
84.
85. if(temp->rchild != NULL)
86. {
87. strcpy(temp->rchild->code, temp->code);
88. strcat(temp->rchild->code, "1");
89. queueenter(q, temp->rchild);
90. }
91. }
92.
93. while(*s != '\0')
94. {
95. strcat(compressed, code[(int)*s++]);
96. }
97.
98. return compressed;
99. }
nbsp; 100.
101. // 第五步
102. char *treeuncompress(treehuffman *t, char *compressed, char *compress)
103. {
104. char *p = compress;
105. treehuffman *temp = t;
106.
107. while(*compressed != '\0')
108. {
109. if(*compressed++ == '0')
110. {
111. temp = temp->lchild;
112. }
113. else
114. {
115. temp = temp->rchild;
116. }
117.
118. if(temp->lchild==NULL && temp->rchild==NULL)
119. {
120. *compress++ = temp->c;
121. temp = t;
122. }
123. }
124.
125. return p;
126. }
1treehuffman.h
127. #ifndef __TREEHUFFMAN_H__
128. #define __TREEHUFFMAN_H__
129.
130. typedef char treedata;
131.
132. typedef struct tree
133. {
134. treedata c;
135. int w;
136. char code[16];
137. struct tree *lchild, *rchild;
138. }treehuffman;
139.
140. extern treehuffman *treecreate(char *s);
141. extern char *treecompress(treehuffman *t, char *s, char *compressed);
142. extern char *treeuncompress(treehuffman *t, char *compressed, char *compress);
143.
144. #endif
注意：对于a6，b2，$2，*1，@1来说，结果可能有几种，可能是a1，b00，$011，*0100，@0101，也可以是a1，$00，b011，@0100，*0101。这是因为统计的频率中有相等的，所以在有序入队时他们可能是左子树，也可能是右子树，所以出来的结果可能与程序本身的处理有关，不过不影响终的压缩率。
