算法设计与分析--霍夫曼树编码(C++实现)

问题描述：

设需要编码的字符集为{d1, d2, …, dn}，它们出现的频率为{w1,w2, …, wn}，应用哈夫曼树构造最短的不等长编码方案。

Huffman算法：

给定实数w1,w2,···，wt且 w1<=w2<=···<=wt           

（1）连接w1,w2为权的两片树叶，得一分支点，其权为w1+w2 ；

（2）在w1+w2, w3+···+wt中选出两个最小的权，连接它们对应的顶点（不一定都是树叶），得分支点及所带的权；

（3）重复（2），直到形成t– 1个分支点，t片树叶为止。

算法实例：

C++代码：

[cpp] view plain copy

1. #include<iostream>  
2. #include<string>  
3. using namespace std;  
4.   
5. //结点类型  
6. struct element  
7. {  
8.     double weight;  //字符出现的概率为实数  
9.     char ch;  
10.     int lchild, rchild, parent;  
11. };  
12.   
13.   
14. //在HuffTer中找权值最小的两个结点i1和i2  
15. void Select(element huffTree[], int *a, int *b, int n)  
16. {  
17.     int i;  
18.     double weight = 0;  
19.     for(i = 0; i <n; i++)  
20.     {  
21.         if(huffTree[i].parent != - 1)       //如果有父结点的，不进行判断  
22.             continue;  
23.         else  
24.         {  
25.             if(weight == 0)  
26.             {  
27.                 weight = huffTree[i].weight;  
28.                 *a = i;  
29.             }  
30.             else  
31.             {  
32.                 if(huffTree[i].weight < weight)  
33.                 {  
34.                     weight = huffTree[i].weight;  
35.                     *a = i;  
36.                 }  
37.             }  
38.         }  
39.     }  
40.     weight = 0;  
41.     for(i = 0; i < n; i++)  
42.     {  
43.         if(huffTree[i].parent != -1 || (i == *a))  
44.             continue;  
45.         else   
46.         {  
47.             if(weight == 0)  
48.             {  
49.                 weight = huffTree[i].weight;  
50.                 *b = i;  
51.             }  
52.             else   
53.             {  
54.                 if(huffTree[i].weight  < weight)  
55.                 {  
56.                     weight = huffTree[i].weight;  
57.                     *b = i;  
58.                 }  
59.             }  
60.         }  
61.     }  
62.     int temp;  
63.     if(huffTree[*a].lchild < huffTree[*b].lchild)        //避免根结点的左右子树混淆  
64.     {  
65.         temp = *a;  
66.         *a = *b;  
67.         *b = temp;  
68.     }  
69. }  
70.   
71.   
72.   
73. //建立霍夫曼树  
74. void HuffmanTree(element huffTree[], int w[], char ch[], int n)  
75. {  
76.     for(int i = 0; i < 2 * n - 1;i++) //霍夫曼树共有2*n - 1个结点  
77.     {  
78.         huffTree[i].parent = -1;    //双亲结点  
79.         huffTree[i].lchild = -1;    //左孩子结点  
80.         huffTree[i].rchild = -1;    //右孩子结点  
81.     }  
82.     for(int i = 0; i < n; i++)       //构造n棵只含有根结点的二叉树  
83.     {  
84.         huffTree[i].weight = w[i];  //给哈夫曼树赋权值  
85.         huffTree[i].ch = ch[i];     //需要编码的字符  
86.     }  
87.     for(int k = n; k < 2 * n - 1; k++)//n-1次合并  
88.     {  
89.         int i1 = 0;  
90.         int i2 = 0;  
91.         Select(huffTree,&i1,&i2,k); //在HuffTer中找权值最小的两个结点i1和i2  
92.         huffTree[i1].parent = k;    //将i1和i2合并，则i1和i2的双亲是k  
93.         huffTree[i2].parent = k;  
94.         huffTree[k].weight = huffTree[i1].weight + huffTree[i2].weight;  
95.         huffTree[k].lchild = i1;  
96.         huffTree[k].rchild = i2;  
97.     }  
98. }  
99.   
100. //霍夫曼编码  
101. void HuffmanCode(element huffTree[], int n)  
102. {  
103.     int i, j,k;  
104.     string s = "";  
105.     for(i = 0; i < n; i++)   //在数组HuffTree中前n个元素是叶子结点，需要编码  
106.     {  
107.         s = "";         //编码s初始化为空串  
108.         j = i;                  //暂存i，不破坏循环变量  
109.         while(huffTree[j].parent != -1) //结点j存在双亲  
110.         {  
111.             k = huffTree[j].parent;  
112.             if(j == huffTree[k].lchild) //结点j是其双亲的左孩子  
113.             {  
114.                 s = s + "0";  
115.             }  
116.             else                //结点j是其双亲的右孩子  
117.             {  
118.                 s = s + "1";  
119.             }  
120.             j = huffTree[j].parent; //将结点j的双亲赋给j  
121.         }  
122.         cout<<"字符"<<huffTree[i].ch<<"的编码："<<endl;  
123.         for(int i =s.size() - 1; i >= 0; i--)    //将s作为结点i的编码逆序输出  
124.         {  
125.             cout<<s.at(i)<<" ";  
126.         }  
127.         cout<<endl;  
128.     }  
129. }  
130.   
131. int main()  
132. {  
133.     const int n = 6;  
134.     element huffTree[2 * n];  
135.     char ch[] = {'a', 'b', 'c','d','e','f'};  
136.     int w[] = {50, 60, 150, 200, 240, 300};  
137.     // 构造霍夫曼树  
138.     HuffmanTree(huffTree,w,ch,n);  
139.     //编码  
140.     HuffmanCode(huffTree,n);  
141.     system("pause");  
142.     return 0;  
143. }  

实验结果：