编程练习——huffman编码

 这个类的名字叫huffman Tree，但是不仅仅是生成huffman Tree，因为Huffman树的生成要使用优先队列，也就是堆。stl中其实有这个的实现。但是我机器里的vs2005这个堆的使用有点小bug（估计是stl中使用的就是数组存储，而且数组一旦固定大小，就再也无法改变，其实这样实现失去了堆的某些特性。所以我还是自己实现了一下。顺便练习下。）。刚开始的时候就采用int作为编码的存储单元。后来发现huffman是可变长编码。所以使用int作为编码单元就失去了huffman的特性。于是寻找bit数组。找到了bitset这个stl类，却发现这个是不可变的。无语。只得自己实现一个可变大小的bit vector。然后近乎重写了这个Huffman的编码和解码。不过也不是很难。在这之间又陆陆续续的发现了一系列的bug和编译错误。对以后的编程大有启发。

 

 

1. /* created by chico chen
2. *  date 2008/10/25
3. */
6. #ifndef _HUFFMAN_TREE_
7. #define _HUFFMAN_TREE_
8. #include "Heap.h"
9. #include "TreeNode.h"
10. #include "BinaryTree.h"
11. #include <map>
12. #include "../../ArithmeticTest/ArithmeticTest/BITVector.h"
13. using namespace std;
15. // this class is used for the combin function in huffmanTree class.
16. class IntCombin
17. {
18. public:
19.     static int Add(int i, int j)
20.     {
21.         return i+j;
22.     }
23. };
25. // this class for compare tree node
26. template<class T>
27. class TreeNodeCompare
28. {
29. public:
30.     static bool Up(TreeNode<T>* d1, TreeNode<T>* d2)
31.     {
32.         return Lt(d1->getData(),d2->getData());
33.     }
35.     static bool Eq(T& d1, T& d2)
36.     {
37.         if(d1 == d2)
38.             return true;
39.         return false;
40.     }
42.     static bool Gt(T& d1, T& d2)
43.     {
44.         if(d1 > d2)
45.             return true;
46.         return false;
47.     }
49.     static bool Lt(T& d1, T& d2)
50.     {
51.         if(d1 < d2)
52.             return true;
53.         return false;
54.     }
55. };
57. // this class is for storing huffman code.
58. // bits and the length of bits
59. class HuffmanCode
60. {
61. public:
62.     BITVector bits;
63.     int len;
64.     HuffmanCode()
65.     {
66.         len = 0;
67.     }
69.     HuffmanCode(const HuffmanCode & codes):bits(codes.bits)
70.     {
71.         len  = codes.len;
73.     }
75.     const HuffmanCode& operator=(const HuffmanCode & codes)
76.     {
77.         if(this != &codes)
78.         {
79.             this->len = codes.len;
80.             this->bits = codes.bits;
81.         }
82.         return * this;
83.     }
85.     ~HuffmanCode()
86.     {
88.     }
89. };
91. template<class T, class Cmp, class Combin>
92. class HuffmanTree:public BinaryTree<T>
93. {
94. private:
95.     // store the data, and sort it, then for building a huffman tree
96.     Heap<TreeNode<T>* ,Cmp> huffmanQueue;
98.     const unsigned int mask;
99.     // the max number can be shifted, if it is unsigned int then it will be 32.
100.     const int maxShiftNum;
102.     
103.     TreeNode<T>* initTree()
104.     // init the huffman tree
105.     {
106.         TreeNode<T> * combinNode = NULL;
107.         T tempData;
108.         while(!this->huffmanQueue.IsEmpty())
109.         {
110.             // fetch two small data and generate a large data
111.             TreeNode<T> * node1 = this->huffmanQueue.Top();
112.             combinNode = node1;
113.             this->huffmanQueue.RemoveTop();
114.             if(!this->huffmanQueue.IsEmpty())
115.             {
116.                 TreeNode<T> * node2 = this->huffmanQueue.Top();
117.                 this->huffmanQueue.RemoveTop();
118.                 tempData =  Combin::Add(node1->getData(),node2->getData());
121.                 if(Cmp::Lt(node1->getData(),node2->getData()))
122.                 {
123.                     // here is comparing the data1 of node1 and the data2 of node2
124.                     //  Cmp:Lt means '<' and Cmp:Gt means '>'
126.                     combinNode = new TreeNode<T>(tempData,node1,node2); 
127.                 }
128.                 else
129.                 {
130.                     combinNode = new TreeNode<T>(tempData,node2,node1);
131.                 }
132.                 this->huffmanQueue.Insert(combinNode);
133.             }
134.             else
135.             {
136.                 break;
137.             }
139.         }
140.         return combinNode;
141.     }
145.     // the final huffman code
146.     map<T,HuffmanCode> huffmanTable;
147.     
148.     
149.     void SelfEncode(TreeNode<T>* subRoot,unsigned int bitcode,int num,map<T,HuffmanCode > &ht)
150.     // encoding the data from a huffman tree. 
151.     // The left branch is 0, and the right branch is 1
152.     {
154.         if(subRoot != NULL)
155.         {
157.             if(subRoot->left == NULL && subRoot->right==NULL)
158.             {
159.                 HuffmanCode hc;
160.                 hc.bits.SetInt(bitcode,0,maxShiftNum-num);
161.                 hc.len = maxShiftNum-num;
162.                 ht[subRoot->getData()] = hc;
163.                 return;
164.             }
165.             else 
166.             {
167.                 if(num<=0)
168.                 {
169.                     throw "the huffman is too deep!";
170.                 }
173.                 SelfEncode(subRoot->left,bitcode,num-1,ht);
174.                 bitcode = bitcode | (0x80000000 >> (maxShiftNum-num));
175.                 SelfEncode(subRoot->right,bitcode,num-1,ht);
176.             }
177.         }
180.     }
182.     
183.     void DecodeFromTree(TreeNode<T>* subRoot,BITVector& bits,int index,const int& len,vector<T>& decode)
184.     // decoding the code. use the code to search the data from the huffmanTree.
185.     // here you can create you own map<code,data> deHuffmanTable. 
186.     // but I can not analyze the space the table will use,
187.     // so I find the data by searching huffman tree
188.     {
189.         if(index == len)
190.         {
191.             if(subRoot->getLeft()==NULL && subRoot->getRight() == NULL)
192.             {
194.                 decode.push_back(subRoot->getData());
195.                 return;
196.             }
197.             throw "code length is not match the bits length. Huffman Tree construct error.";
198.         }
199.         if(subRoot == NULL)
200.         {
201.             throw "decode error!";
203.         }
204.         else if(subRoot->getLeft() == NULL && subRoot->getRight() == NULL)
205.         {
207.             decode.push_back(subRoot->getData());
208.             return DecodeFromTree(this->root,bits,index,len,decode);
209.         }
211.         if(bits.Get(index) == 0)
212.         {
213.             return DecodeFromTree(subRoot->getLeft(),bits,index+1,len,decode);
214.         }
215.         else if(bits.Get(index)==1)
216.         {
218.             return DecodeFromTree(subRoot->getRight(),bits,index+1,len,decode);
219.         }
220.         else
221.         {
222.             throw "code error!";
223.         }
226.     }
229.     unsigned int FindCodeFromTable(T& data)
230.     // find the data code from huffman table    
231.     // may be not efficient. 
232.     {
233.         return this->huffmanTable[data];
234.     }
235.     
236. public:
238.     HuffmanTree(T t[], int n):
239.       BinaryTree<T>(),mask(0x80000000),maxShiftNum(sizeof(unsigned int)*8)
240.       // the array t type is T, and the number is n
241.       {
242.           if(n == 0)
243.               return;
244.           TreeNode<T>* node;
245.           for(int i = 0; i < n; i++)
246.           {
247.               node = new TreeNode<T>(t[i]);
248.               this->huffmanQueue.Insert(node);
249.           }
250.           this->root = initTree();
251.       }
253.       ~HuffmanTree()
254.       {
255.           // destroy
257.       }
260.     void SelfEncode()
261.     // convert the huffmanTree into huffmanTable
262.     // unsigned int code is 32 bits, so the huffman tree has only less than 33 layer.
263.     {
264.         string s="";
266.         SelfEncode(this->root,0,maxShiftNum,this->huffmanTable);
268.     }
272.     void Decode(HuffmanCode& huffmanCode,vector<T>& decode)
273.     // use bit to find the data node.
274.     {
276.         return DecodeFromTree(this->root,huffmanCode.bits,0,huffmanCode.len,decode);
278.     }
280.     HuffmanCode Encode(T info[], int n)
281.     // n is size
282.     {
283.         HuffmanCode hc;
285.         for(int i = 0; i < n; i++)
286.         {
288.             hc.bits.SetBitVector(((HuffmanCode)this->huffmanTable[info[i]]).bits,hc.len,((HuffmanCode)this->huffmanTable[info[i]]).len);
289.             hc.len +=((HuffmanCode)this->huffmanTable[info[i]]).len;
290.         }
292.         return hc;
293.     }
296.     void PrintHuffmanTable()
297.     // print the huffman table
298.     // print the pair data<->code
299.     {
300.         int len = this->huffmanTable.size();
301.         cout << "i/tdata/tcode/n";
302.         int count = 0;
303.         map<T,HuffmanCode>::iterator i= this->huffmanTable.begin();
304.         for(; i != this->huffmanTable.end(); i++)
305.         {
306.             cout << count++<<"/t"<<(*i).first<<"/t";
307.             (*i).second.bits.PrintfZeroOne(0,(*i).second.len);
308.             cout<<endl;
309.         }
311.     }
313. };
316. #endif

这个类设计方面还有些不足之处。比如encode方法

 

测试一下：

1.     int a[10] = {12,224,33,32,1,91,35,34,36,291};
2.     HuffmanTree<int,TreeNodeCompare<int>,IntCombin> ht(a,10);
3.     ht.SelfEncode();
4.     ht.PrintHuffmanTable();
5.     ht.printTree();
6.     cout << endl;
7.     int info[] = {33,34,33};
8.     HuffmanCode hc = ht.Encode(info,3);
9.     hc.bits.PrintfZeroOne(0,hc.len);
10.     vector<int> code;
11.     ht.Decode(hc,code);
12.     for(int i = 0; i != code.size();i++)
13.     {
15.         cout<<code[i]<<endl;
16.     }
17.      
18.     return 0;