第11周项目1-验证算法（4）哈夫曼编码的算法验证

Copyright (c)2016,烟台大学计算机与控制工程学院 
All rights reserved. 
文件名称：项目1-4.cbp 
作    者：王聪 
完成日期：2016年11月10日 
版 本 号：v1.0 
 
 
问题描述：实现哈夫曼编码的算法验证的算法验证，并测试数据。 
 
 
输入描述：无 
程序输出：测试数据 

代码：

1. #include <stdio.h>  
2. #include <string.h>  
3.   
4.   
5. #define N 50        //叶子结点数  
6. #define M 2*N-1     //树中结点总数  
7.   
8.   
9. //哈夫曼树的节点结构类型  
10. typedef struct  
11. {  
12.     char data;  //结点值  
13.     double weight;  //权重  
14.     int parent;     //双亲结点  
15.     int lchild;     //左孩子结点  
16.     int rchild;     //右孩子结点  
17. } HTNode;  
18.   
19.   
20. //每个节点哈夫曼编码的结构类型  
21. typedef struct  
22. {  
23.     char cd[N]; //存放哈夫曼码  
24.     int start;  
25. } HCode;  
26.   
27.   
28. //构造哈夫曼树  
29. void CreateHT(HTNode ht[],int n)  
30. {  
31.     int i,k,lnode,rnode;  
32.     double min1,min2;  
33.     for (i=0; i<2*n-1; i++)         //所有结点的相关域置初值-1  
34.         ht[i].parent=ht[i].lchild=ht[i].rchild=-1;  
35.     for (i=n; i<2*n-1; i++)         //构造哈夫曼树  
36.     {  
37.         min1=min2=32767;            //lnode和rnode为最小权重的两个结点位置  
38.         lnode=rnode=-1;  
39.         for (k=0; k<=i-1; k++)  
40.             if (ht[k].parent==-1)   //只在尚未构造二叉树的结点中查找  
41.             {  
42.                 if (ht[k].weight<min1)  
43.                 {  
44.                     min2=min1;  
45.                     rnode=lnode;  
46.                     min1=ht[k].weight;  
47.                     lnode=k;  
48.                 }  
49.                 else if (ht[k].weight<min2)  
50.                 {  
51.                     min2=ht[k].weight;  
52.                     rnode=k;  
53.                 }  
54.             }  
55.         ht[i].weight=ht[lnode].weight+ht[rnode].weight;  
56.         ht[i].lchild=lnode;  
57.         ht[i].rchild=rnode;  
58.         ht[lnode].parent=i;  
59.         ht[rnode].parent=i;  
60.     }  
61. }  
62.   
63.   
64. //实现哈夫曼编码  
65. void CreateHCode(HTNode ht[],HCode hcd[],int n)  
66. {  
67.     int i,f,c;  
68.     HCode hc;  
69.     for (i=0; i<n; i++) //根据哈夫曼树求哈夫曼编码  
70.     {  
71.         hc.start=n;  
72.         c=i;  
73.         f=ht[i].parent;  
74.         while (f!=-1)   //循序直到树根结点  
75.         {  
76.             if (ht[f].lchild==c)    //处理左孩子结点  
77.                 hc.cd[hc.start--]='0';  
78.             else                    //处理右孩子结点  
79.                 hc.cd[hc.start--]='1';  
80.             c=f;  
81.             f=ht[f].parent;  
82.         }  
83.         hc.start++;     //start指向哈夫曼编码最开始字符  
84.         hcd[i]=hc;  
85.     }  
86. }  
87.   
88.   
89. //输出哈夫曼编码  
90. void DispHCode(HTNode ht[],HCode hcd[],int n)  
91. {  
92.     int i,k;  
93.     double sum=0,m=0;  
94.     int j;  
95.     printf("  输出哈夫曼编码:\n"); //输出哈夫曼编码  
96.     for (i=0; i<n; i++)  
97.     {  
98.         j=0;  
99.         printf("      %c:\t",ht[i].data);  
100.         for (k=hcd[i].start; k<=n; k++)  
101.         {  
102.             printf("%c",hcd[i].cd[k]);  
103.             j++;  
104.         }  
105.         m+=ht[i].weight;  
106.         sum+=ht[i].weight*j;  
107.         printf("\n");  
108.     }  
109.     printf("\n  平均长度=%g\n",1.0*sum/m);  
110. }  
111.   
112.   
113. int main()  
114. {  
115.     int n=8,i;      //n表示初始字符串的个数  
116.     char str[]= {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};  
117.     double fnum[]= {0.07,0.19,0.02,0.06,0.32,0.03,0.21,0.1};  
118.     HTNode ht[M];  
119.     HCode hcd[N];  
120.     for (i=0; i<n; i++)  
121.     {  
122.         ht[i].data=str[i];  
123.         ht[i].weight=fnum[i];  
124.     }  
125.     printf("\n");  
126.     CreateHT(ht,n);  
127.     CreateHCode(ht,hcd,n);  
128.     DispHCode(ht,hcd,n);  
129.     printf("\n");  
130.     return 0;  
131. }  

  运行结果：