算法笔记贪心算法哈夫曼编码问题.docx
《算法笔记贪心算法哈夫曼编码问题.docx》由会员分享,可在线阅读,更多相关《算法笔记贪心算法哈夫曼编码问题.docx(17页珍藏版)》请在冰豆网上搜索。
![算法笔记贪心算法哈夫曼编码问题.docx](https://file1.bdocx.com/fileroot1/2023-2/10/f8836680-ce98-4705-8b18-514c39dd02b4/f8836680-ce98-4705-8b18-514c39dd02b41.gif)
算法笔记贪心算法哈夫曼编码问题
0023算法笔记——【贪心算法】哈夫曼编码问题
令狐采学
1、问题描述
哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。
其压缩率通常在20%~90%之间。
哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0,1串表示各字符的最优表示方式。
一个包含100,000个字符的文件,各字符出现频率不同,如下表所示。
有多种方式表示文件中的信息,若用0,1码表示字符的方法,即每个字符用唯一的一个0,1串表示。
若采用定长编码表示,则需要3位表示一个字符,整个文件编码需要300,000位;若采用变长编码表示,给频率高的字符较短的编码;频率低的字符较长的编码,达到整体编码减少的目的,则整个文件编码需要(45×1+13×3+12×3+16×3+9×4+5×4)×1000=224,000位,由此可见,变长码比定长码方案好,总码长减小约25%。
前缀码:
对每一个字符规定一个0,1串作为其代码,并要求任一字符的代码都不是其他字符代码的前缀。
这种编码称为前缀码。
编码的前缀性质可以使译码方法非常简单;例如001011101可以唯一的分解为0,0,101,1101,因而其译码为aabe。
译码过程需要方便的取出编码的前缀,因此需要表示前缀码的合适的数据结构。
为此,可以用二叉树作为前缀码的数据结构:
树叶表示给定字符;从树根到树叶的路径当作该字符的前缀码;代码中每一位的0或1分别作为指示某节点到左儿子或右儿子的“路标”。
从上图可以看出,表示最优前缀码的二叉树总是一棵完全二叉树,即树中任意节点都有2个儿子。
图a表示定长编码方案不是最优的,其编码的二叉树不是一棵完全二叉树。
在一般情况下,若C是编码字符集,表示其最优前缀码的二叉树中恰有|C|个叶子。
每个叶子对应于字符集中的一个字符,该二叉树有|C|-1个内部节点。
给定编码字符集C及频率分布f,即C中任一字符c以频率f(c)在数据文件中出现。
C的一个前缀码编码方案对应于一棵二叉树T。
字符c在树T中的深度记为dT(c)。
dT(c)也是字符c的前缀码长。
则平均码长定义为:
使平均码长达到最小的前缀码编码方案称为C的最优前缀码。
2、构造哈弗曼编码
哈夫曼提出构造最优前缀码的贪心算法,由此产生的编码方案称为哈夫曼编码。
其构造步骤如下:
(1)哈夫曼算法以自底向上的方式构造表示最优前缀码的二叉树T。
(2)算法以|C|个叶结点开始,执行|C|-1次的“合并”运算后产生最终所要求的树T。
(3)假设编码字符集中每一字符c的频率是f(c)。
以f为键值的优先队列Q用在贪心选择时有效地确定算法当前要合并的2棵具有最小频率的树。
一旦2棵具有最小频率的树合并后,产生一棵新的树,其频率为合并的2棵树的频率之和,并将新树插入优先队列Q。
经过n-1次的合并后,优先队列中只剩下一棵树,即所要求的树T。
构造过程如图所示:
具体代码实现如下:
(1)4d4.cpp,程序主文件
[cpp] viewplain copy
1.//4d4 贪心算法 哈夫曼算法
2.#include "stdafx.h"
3.#include "BinaryTree.h"
4.#include "MinHeap.h"
5.#include
6.using namespace std;
7.const int N = 6;
8.template class Huffman;
9.template
10.BinaryTree HuffmanTree(Type f[],int n);
11.template
12.class Huffman
13.{
14. friend BinaryTree HuffmanTree(Type[],int);
15. public:
16. operator Type() const
17. {
18. return weight;
19. }
20. //private:
21. BinaryTree tree;
22. Type weight;
23.};
24.int main()
25.{
26. char c[] = {'0','a','b','c','d','e','f'};
27. int f[] = {0,45,13,12,16,9,5};//下标从1开始
28. BinaryTree t = HuffmanTree(f,N);
29. cout<<"各字符出现的对应频率分别为:
"<30. for(int i=1; i<=N; i++)
31. {
32. cout<"<33. }
34. cout<35. cout<<"生成二叉树的前序遍历结果为:
"<36. t.Pre_Order();
37. cout<38. cout<<"生成二叉树的中序遍历结果为:
"<39. t.In_Order();
40. cout<41. t.DestroyTree();
42. return 0;
43.}
44.template
45.BinaryTree HuffmanTree(Type f[],int n)
46.{
47. //生成单节点树
48. Huffman *w = new Huffman[n+1];
49. BinaryTree z,zero;
50. for(int i=1; i<=n; i++)
51. {
52. z.MakeTree(i,zero,zero);
53. w[i].weight = f[i];
54. w[i].tree = z;
55. }
56. //建优先队列
57. MinHeap> Q(n);
58. for(int i=1; i<=n; i++) Q.Insert(w[i]);
59. //反复合并最小频率树
60. Huffman x,y;
61. for(int i=1; i62. {
63. x = Q.RemoveMin();
64. y = Q.RemoveMin();
65. z.MakeTree(0,x.tree,y.tree);
66. x.weight += y.weight;
67. x.tree = z;
68. Q.Insert(x);
69. }
70. x = Q.RemoveMin();
71. delete[] w;
72. return x.tree;
73.}
(2)BinaryTree.h二叉树实现
[cpp] viewplain copy
1.#include
2.using namespace std;
3.template
4.struct BTNode
5.{
6. T data;
7. BTNode *lChild,*rChild;
8. BTNode()
9. {
10. lChild=rChild=NULL;
11. }
12. BTNode(const T &val,BTNode *Childl=NULL,BTNode *Childr=NULL)
13. {
14. data=val;
15. lChild=Childl;
16. rChild=Childr;
17. }
18. BTNode* CopyTree()
19. {
20. BTNode *nl,*nr,*nn;
21. if(&data==NULL)
22. return NULL;
23. nl=lChild->CopyTree();
24. nr=rChild->CopyTree();
25. nn=new BTNode(data,nl,nr);
26. return nn;
27. }
28.};
29.template
30.class BinaryTree
31.{
32. public:
33. BTNode *root;
34. BinaryTree();
35. ~BinaryTree();
36. void Pre_Order();
37. void In_Order();
38. void Post_Order();
39. int TreeHeight()const;
40. int TreeNodeCount()const;
41. void DestroyTree();
42. void MakeTree(T pData,BinaryTree leftTree,BinaryTree rightTree);
43. void Change(BTNode *r);
44. private:
45. void Destroy(BTNode *&r);
46. void PreOrder(BTNode *r);
47. void InOrder(BTNode *r);
48. void PostOrder(BTNode *r);
49. int Height(const BTNode *r)const;
50. int NodeCount(const BTNode *r)const;
51.};
52.template
53.BinaryTree:
:
BinaryTree()
54.{
55. root=NULL;
56.}
57.template
58.BinaryTree:
:
~BinaryTree()
59.{
60.}
61.template
62.void BinaryTree:
:
Pre_Order()
63.{
64. PreOrder(root);
65.}
66.template
67.void BinaryTree:
:
In_Order()
68.{
69. InOrder(root);
70.}
71.template
72.void BinaryTree:
:
Post_Order()
73.{
74. PostOrder(root);
75.}
76.template
77.int BinaryTree:
:
TreeHeight()const
78.{
79. return Height(root);
80.}
81.template
82.int BinaryTree:
:
TreeNodeCount()const
83.{
84. return NodeCount(root);
85.}
86.template
87.void BinaryTree:
:
DestroyTree()
88.{
89. Destroy(root);
90.}
91.template
92.void BinaryTree:
:
PreOrder(BTNode *r)
93.{
94. if(r!
=NULL)
95. {
96. cout<data<<' ';
97. PreOrder(r->lChild);
98. PreOrder(r->rChild);
99. }
100.}
101.template
102.void BinaryTree:
:
InOrder(BTNode *r)
103.{
104. if(r!
=NULL)
105. {
106. InOrder(r->lChild);
107. cout<data<<' ';
108. InOrder(r->rChild);
109. }
110.}
111.template
112.void BinaryTree:
:
PostOrder(BTNode *r)
113.{
114. if(r!
=NULL)
115. {
116. PostOrder(r->lChild);
117. PostOrder(r->rChild);
118. cout<data<<' ';
119. }
120.}
121.template
122.int BinaryTree:
:
NodeCount(const BTNode *r)const
123.{
124. if(r==NULL)
125. return 0;
126. else
127. return 1+NodeCount(r->lChild)+NodeCount(r->rChild);
128.}
129.template
130.int BinaryTree:
:
Height(const BTNode *r)const
131.{
132. if(r==NULL)
133. return 0;
134. else
135. {
136. int lh,rh;
137. lh=Height(r->lChild);
138. rh=Height(r->rChild);
139. return 1+(lh>rh?
lh:
rh);
140. }
141.}
142.template
143.void BinaryTree:
:
Destroy(BTNode *&r)
144.{
145. if(r!
=NULL)
146. {
147. Destroy(r->lChild);
148. Destroy(r->rChild);
149. delete r;
150. r=NULL;
151. }
152.}
153.template
154.void BinaryTree:
:
Change(BTNode *r)//将二叉树bt所有结点的左右子树交换
155.{
156. BTNode *p;
157. if(r){
158. p=r->lChild;
159. r->lChild=r->rChild;
160. r->rChild=p; //左右子女交换
161. Change(r->lChild); //交换左子树上所有结点的左右子树
162. Change(r->rChild); //交换右子树上所有结点的左右子树
163. }
164.}
165.template
166.void BinaryTree:
:
MakeTree(T pData,BinaryTree leftTree,BinaryTree rightTree)
167.{
168. root = new BTNode();
169. root->data = pData;
170. root->lChild = leftTree.root;
171. root->rChild = rightTree.root;
172.}
(3)MinHeap.h最小堆实现
[cpp] viewplain copy
1.#include
2.using namespace std;
3.template
4.class MinHeap
5.{
6. private:
7. T *heap; //元素数组,0号位置也储存元素
8. int CurrentSize; //目前元素个数
9. int MaxSize; //可容纳的最多元素个数
10. void FilterDown(const int start,const int end); //自上往下调整,使关键字小的节点在上
11. void FilterUp(int start); //自下往上调整
12. public:
13. MinHeap(int n=1000);
14. ~MinHeap();
15. bool Insert(const T &x); //插入元素
16. T RemoveMin(); //删除最小元素
17. T GetMin(); //取最小元素
18. bool IsEmpty() const;
19. bool IsFull() const;
20. void Clear();
21.};
22.template
23.MinHeap:
:
MinHeap(int n)
24.{
25. MaxSize=n;
26. heap=new T[MaxSize];
27. CurrentSize=0;
28.}
29.template
30.MinHeap:
:
~MinHeap()
31.{
32. delete []heap;
33.}
34.template
35.void MinHeap:
:
FilterUp(int start) //自下往上调整
36.{
37. int j=start,i=(j-1)/2; //i指向j的双亲节点
38. T temp=heap[j];
39. while(j>0)
40. {
41. if(heap[i]<=temp)
42. break;
43. else
44. {
45. heap[j]=heap[i];
46. j=i;
47. i=(i-1)/2;
48. }
49. }
50. heap[j]=temp;
51.}
52.template
53.void MinHeap:
:
FilterDown(const int start,const int end) //自上往下调整,使关键字小的节点在上
54.{
55. int i=start,j=2*i+1;
56. T temp=heap[i];
57. while(j<=end)
58. {
59. if( (jheap[j+1]) )
60. j++;
61. if(temp<=heap[j])
62. break;
63. else
64. {
65. heap[i]=heap[j];
66. i=j;
67. j=2*j+1;
68. }
69. }
70. heap[i]=temp;
71.}
72.template
73.bool MinHeap:
:
Insert(const T &x)
74.{
75. if(CurrentSize==MaxSize)