哈夫曼

1. //huffmantree.h  
2. #ifndef HUFFMANTREE_H  
3. #define HUFFMANTREE_H  
4. #include <IOSTREAM>  
5. #include <STRING>  
6. #include <MAP>  
7. typedef struct HuffmanNode* pHuffmanNode;  
8. struct HuffmanNode   
9. {  
10.     int data;  
11.     pHuffmanNode left,right;  
12. };  
13. class MinHeap  
14. {  
15. private:  
16.     pHuffmanNode Data[100];  
17.     int Size;  
18.     int Capacity;  
19. public:  
20.     MinHeap():Size(0),Capacity(100)  
21.     {  
22.         //Data=new HuffmanNode[Capacity];  
23.         Data[0]=NULL;  
24.     }  
25.     ~MinHeap(){}  
26.     bool Insert(pHuffmanNode);  
27.     pHuffmanNode DeleteMin();  
28.     bool IsFull(){return Size==Capacity-1;}  
29.     bool IsEmpty(){return Size==0;}  
30.     void Print();  
31.     int GetSize(){return Size;}  
32. };  
33. bool MinHeap::Insert(pHuffmanNode x)  
34. {  
35.     if(IsFull())  
36.         return false;  
37.     for(int i=++Size;i>1&&Data[i/2]->data>x->data;i/=2)  
38.     {  
39.         Data[i]=Data[i/2];  
40.     }  
41.     Data[i]=x;  
42.     return true;  
43. }  
44. pHuffmanNode MinHeap::DeleteMin()  
45. {  
46.     /*if(IsEmpty()) 
47.         return Type(-1111);*/  
48.     pHuffmanNode temp=Data[1];  
49.     pHuffmanNode last=Data[Size--];  
50.     int parent,child;  
51.     for(parent=1;2*parent<=Size;parent=child)  
52.     {  
53.         child=parent*2;  
54.         if(2*parent+1<=Size&&Data[2*parent]->data>Data[2*parent+1]->data)  
55.             child++;  
56.         if(last->data>Data[child]->data)  
57.             Data[parent]=Data[child];  
58.         else  
59.             break;  
60.     }  
61.     Data[parent]=last;  
62.     return temp;  
63. }  
64. void MinHeap::Print()  
65. {  
66.     for(int i=1;i<=Size;i++)  
67.     {  
68.         std::cout<<Data[i]->data<<" ";  
69.     }  
70.     std::cout<<std::endl;  
71. }  
72. class HuffmanTree  
73. {  
74.     private:  
75.         pHuffmanNode root;  
76.         MinHeap minheap;  
77.         char code[11][10];  
78.     public:  
79.         HuffmanTree():root(NULL){  
80.             for(int i=0;i<11;i++)  
81.                 for(int j=0;j<10;j++)  
82.                     code[i][j]=' ';  
83.         }  
84.         ~HuffmanTree();  
85.         void ReleaseHuffmanTreeNode(pHuffmanNode);  
86.         pHuffmanNode CreateHuffmanTree(int* a,int length);  
87.         void BuildMinHeap(int*,int);  
88.         void PrintPreOrder();  
89.         void PrintInOrder();  
90.         void PreOrderTraversal(pHuffmanNode);  
91.         void InOrderTraversal(pHuffmanNode);  
92.         void EnCode();  
93.         void DeCode(char*,int);  
94.         void MakeCode(int i,char* temp,pHuffmanNode pNode);  
95. };  
96. pHuffmanNode HuffmanTree::CreateHuffmanTree(int* a,int length)  
97. {  
98.     BuildMinHeap(a,length);  
99.     while(1)  
100.     {  
101.         if(minheap.GetSize()==1)  
102.             return root;  
103.         HuffmanNode* temp1;  
104.         HuffmanNode* temp2;  
105.         temp1=minheap.DeleteMin();  
106.         temp2=minheap.DeleteMin();  
107.         if(!temp2)  
108.             return root;  
109.         HuffmanNode* temp3=new HuffmanNode;  
110.         temp3->data=temp1->data+temp2->data;  
111.         temp3->left=temp1;  
112.         temp3->right=temp2;  
113.         minheap.Insert(temp3);  
114.         root=temp3;  
115.     }  
116.     return root;  
117. }  
118. void HuffmanTree::BuildMinHeap(int* a,int length)  
119. {  
120.     for(int i=0;i<length;i++)  
121.     {  
122.         HuffmanNode* sample=new HuffmanNode;  
123.         sample->data=a[i];  
124.         sample->left=sample->right=NULL;  
125.         minheap.Insert(sample);  
126.     }     
127. }  
128. void HuffmanTree::PrintPreOrder()  
129. {  
130.     PreOrderTraversal(root);  
131. }  
132. void HuffmanTree::PreOrderTraversal(pHuffmanNode temp)  
133. {  
134.     if(!temp)  
135.         return;  
136.     std::cout<<temp->data<<" ";  
137.     PreOrderTraversal(temp->left);     
138.     PreOrderTraversal(temp->right);  
139. }  
140. void HuffmanTree::PrintInOrder()  
141. {  
142.     InOrderTraversal(root);  
143. }  
144. void HuffmanTree::InOrderTraversal(pHuffmanNode temp)  
145. {  
146.     if(!temp)  
147.         return;  
148.     InOrderTraversal(temp->left);  
149.     std::cout<<temp->data<<" ";  
150.     InOrderTraversal(temp->right);  
151. }  
152. HuffmanTree::~HuffmanTree()  
153. {  
154.     ReleaseHuffmanTreeNode(root);  
155. }  
156. void HuffmanTree::ReleaseHuffmanTreeNode(pHuffmanNode temp)  
157. {  
158.     if(!temp)  
159.         return;  
160.     ReleaseHuffmanTreeNode(temp->left);  
161.     ReleaseHuffmanTreeNode(temp->right);  
162. }  
163. void HuffmanTree::EnCode()  
164. {  
165.     char temp[10]={'0'};  
166.     MakeCode(-1,temp,root);  
167.     for(int i=1;i<11;i++)  
168.     {  
169.         std::cout<<i<<": ";  
170.         for(int j=0;j<10;j++)  
171.         {  
172.             std::cout<<code[i][j];  
173.         }  
174.         std::cout<<std::endl;  
175.     }  
176. }  
177. void HuffmanTree::MakeCode(int i,char* temp,pHuffmanNode pNode)  
178. {  
179.     //遍历该哈夫曼树  
180.     if(!pNode->left&&!pNode->right)  
181.     {  
182.         for(int j=0;j<=i;j++)  
183.             code[pNode->data][j]=temp[j];  
184.         return;  
185.     }  
186.     temp[i+1]='0';  
187.     MakeCode(i+1,temp,pNode->left);  
188.     temp[i+1]='1';  
189.     MakeCode(i+1,temp,pNode->right);  
190. }  
191. void HuffmanTree::DeCode(char* str,int length)  
192. {  
193.     int deCodeNum[100]={0};  
194.     int orderOfCode=0;  
195.     for(int i=0;i<length;i++)  
196.     {  
197.         for(int j=1;j<11;j++)  
198.         {  
199.             int k=i;  
200.             int l=0;  
201.             bool bCodeIn=false;  
202.             while(code[j][l]==str[k])  
203.             {  
204.                 bCodeIn=true;  
205.                 k++;  
206.                 l++;  
207.             }  
208.             if(code[j][l]==' '&&bCodeIn)  
209.             {  
210.                 //当str中的前k位与code[j]的前k位相同时  
211.                 deCodeNum[orderOfCode++]=j;   
212.                 i=k-1;  
213.                 break;  
214.             }  
215.         }  
216.     }  
217.     for(i=0;i<orderOfCode;i++)  
218.     {  
219.         std::cout<<deCodeNum[i]<<" ";  
220.     }  
221.     std::cout<<std::endl;  
222. }  
223. #endif