哈夫曼编码

思想：得到哈夫曼树后，自顶向下按路径编号，指向左节点的边编号0，指向右节点的边编号1，从根到叶节点的所有边上的0和1连接起来，就是叶子节点中字符的哈夫曼编码。

下图体现了哈夫曼编码的过程：

 

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. //哈夫曼树结点
   
6. typedef struct HuffNode
   
7. {
   
8.     int weight;
   
9.     char ch;
   
10.     char code[20];
    
11.     struct HuffNode *rchild;
    
12.     struct HuffNode *lchild;
    
13.     
    
14. }HuffMan;
    
15. 
    
16. //队列设计
    
17. typedef struct _node_
    
18. {
    
19.     HuffMan *data;
    
20.     struct _node_ *next;
    
21. }ListNode;
    
22. 
    
23. typedef struct
    
24. {
    
25.     ListNode *front;
    
26.     ListNode *rear;
    
27. }Queue;
    
28. 
    
29. //create empty queue
    
30. Queue *create_empty_queue()
    
31. {
    
32.     ListNode *HList;
    
33.     Queue *Hqueue;
    
34. 
    
35.     HList = (ListNode *)malloc(sizeof(ListNode));
    
36.     HList->next = NULL;
    
37.     
    
38.     Hqueue = (Queue *)malloc(sizeof(Queue));
    
39.     Hqueue->front = Hqueue->rear = HList;
    
40. 
    
41.     return Hqueue;
    
42. }
    
43. 
    
44. //入队
    
45. int EnterQueue(Queue *head,HuffMan *data)
    
46. {
    
47.     ListNode *temp;
    
48. 
    
49.     temp = (ListNode *)malloc(sizeof(ListNode));
    
50.     temp->data = data;
    
51.     temp->next = NULL;
    
52. 
    
53.     head->rear->next = temp;
    
54.     head->rear = temp;
    
55. 
    
56.     return 0;
    
57. }
    
58. 
    
59. //有序插入结点
    
60. int OrderEnterQueue(Queue *head,HuffMan *p)
    
61. {
    
62.     ListNode *m = head->front->next;
    
63.     ListNode *n = head->front;
    
64.     ListNode *temp;
    
65. 
    
66.     while(m)
    
67.     {
    
68.         if(m->data->weight < p->weight)
    
69.         {
    
70.             m = m->next;
    
71.             n = n->next;
    
72.         }
    
73.         else{
    
74.             
    
75.             break;
    
76.         }
    
77.     }
    
78. 
    
79.     //插到最后一个结点
    
80.     if(m == NULL)
    
81.     {
    
82.         temp = (ListNode *)malloc(sizeof(ListNode));
    
83.         temp->data = p;
    
84.         temp->next = NULL;
    
85.         n->next = temp;
    
86.         head->rear = temp;
    
87. 
    
88.         return 0;
    
89.     }
    
90. 
    
91.     //插入中间结点
    
92.     temp = (ListNode *)malloc(sizeof(ListNode));
    
93.     temp->data = p;
    
94.     n->next = temp;
    
95.     temp->next = m;
    
96. 
    
97.     return 0;
    
98. }
    
99. 
    
100. //判断队列是否为空(注意，我们认为队列含有一个结点为空，想想为什么
     
101. //这样做?
     
102. int _is_empty_queue(Queue *head)
     
103. {
     
104.     if(head->front->next->next == NULL)
     
105.     {
     
106.         printf("is_empty_queue\n");
     
107.         return 1;
     
108.     }
     
109.     
     
110.     return 0;
     
111. }
     
112. 
     
113. //判断队列是否为空
     
114. int is_empty_queue(Queue *head)
     
115. {
     
116.     if(head->front == head->rear)
     
117.         return 1;
     
118.     else
     
119.         return 0;
     
120. }
     
121. 
     
122. //出队
     
123. HuffMan *DeleteQueue(Queue * head)
     
124. {
     
125.     ListNode *temp;
     
126. 
     
127.     temp = head->front;
     
128.     head->front = temp->next;
     
129.     free(temp);
     
130.     temp = NULL;
     
131. 
     
132.     return head->front->data;
     
133. }
     
134. 
     
135. //创建哈夫曼树
     
136. HuffMan *create_huffman_tree(Queue *head)
     
137. {
     
138.     HuffMan *right,*left,*current;
     
139. 
     
140.     //循环结束时，队列只含有一个结点
     
141.     while(!_is_empty_queue(head))
     
142.     {
     
143.         left = DeleteQueue(head);
     
144.         right = DeleteQueue(head);
     
145.         current = (HuffMan *)malloc(sizeof(HuffMan));
     
146.         current->weight = left->weight + right->weight;
     
147.         current->rchild = right;
     
148.         current->lchild = left;
     
149.         OrderEnterQueue(head,current);    
     
150.     }
     
151. 
     
152.     return head->front->next->data;
     
153. }
     
154. 
     
155. //哈夫曼编码
     
156. int HuffmanCode(HuffMan *root)
     
157. {
     
158.     HuffMan *current = NULL;
     
159.     Queue *queue = NULL;
     
160. 
     
161.     queue = create_empty_queue();
     
162. 
     
163.     EnterQueue(queue, root);
     
164. 
     
165.     while(!is_empty_queue(queue))
     
166.     {
     
167.         current = DeleteQueue(queue);
     
168. 
     
169.         if(current->rchild == NULL && current->lchild == NULL)
     
170.         {
     
171.             printf("%c:%d %s\n",current->ch,current->weight,current->code);
     
172.         }
     
173. 
     
174.         if(current->lchild)
     
175.         {
     
176.             strcpy(current->lchild->code,current->code);
     
177.             strcat(current->lchild->code,"0");
     
178.             EnterQueue(queue, current->lchild);
     
179.         }
     
180. 
     
181.         if(current->rchild)
     
182.         {
     
183.             strcpy(current->rchild->code,current->code);
     
184.             strcat(current->rchild->code,"1");
     
185.             EnterQueue(queue, current->rchild);
     
186.         }
     
187.     }
     
188. 
     
189.     return 0;
     
190. }

运行结果: