《算法设计与分析》上机实验报告(3)

福州大学数学与计算机科学学院《算法设计与分析》上机实验报告（3）

求任一字符的代码都不是其他字符代码的前缀。这种编码称为前缀码。编码的前缀性质可以使译码方法非常简单；例如001011101可以唯一的分解为0,0,101,1101，因而其译码为aabe。

哈夫曼提出了构造最优前缀码的贪心算法，由此产生的编码方案称为哈夫曼算法。

2.算法的设计思想

哈夫曼编码依据贪心算法来构造最优前缀码，构造思想步骤如下：

(1)哈夫曼算法以自底向上的方式构造表示最优前缀码的二叉树T。

(2)算法以|C|个叶结点开始，执行|C|－1次的“合并”运算后产生最终所要求的树T。

(3)假设编码字符集中每一字符c的频率是f(c)。以f为键值的优先队列Q用在贪心选择时有效地确定算法当前要合并的2棵具有最小频率的树。一旦2棵具有最小频率的树合并后，产生一棵新的树，其频率为合并的2棵树的频率之和，并将新树插入优先队列Q。经过n－1次的合并后，优先队列中只剩下一棵树，即所要求的树T。

构造过程如图所示：

3.算法正确性证明

由此可知，树T和T'的前缀码的平均码长之差为：

码长，同时，仅最优一位编码不同。

(2)最优子结构性质

二叉树T表示字符集C的一个最优前缀码，x和y是树T 中的两个叶子且为兄弟，z是它们的父亲。若将z当作是具有频率f(z)=f(x)+f(y)的字符，则树T’=T-{x,y}表示字符集C’=C-{x, y} ∪ { z}的一个最优前缀码。因此，有：

如果T’不是C’的最优前缀码，假定T”是C’的最优前缀码，那么有

，显然T”’是比T更优的前缀码，跟前提矛盾！故T'所表示的C'的前缀码是最优的。

由贪心选择性质和最优子结构性质可以推出哈夫曼算法是正确的，即HuffmanTree产生的一棵最优前缀编码树。

4.哈夫曼编码算法的程序代码

(1)huffman.cpp，程序主文件

1.//huffman 贪心算法哈夫曼算法

2.#include "stdafx.h"

3.#include "BinaryTree.h"

4.#include "MinHeap.h"

5.#include

https://www.360docs.net/doc/0b16407648.html,ing namespace std;

7.

8.const int N = 6;

9.

10.template class Huffman;

11.

12.template

13.BinaryTree HuffmanTree(Type f[],int n)

;

14.

15.template

16.class Huffman

17.{

18.friend BinaryTree HuffmanTree(Type

[],int);

19.public:

20. operator Type() const

21. {

22.return weight;

23. }

24.//private:

25. BinaryTree tree;

26. Type weight;

27.};

28.

29.int main()

30.{

31.char c[] = {'0','a','b','c','d','e','f'

};

32.int f[] = {0,45,13,12,16,9,5};//下标从1

开始

33. BinaryTree t = HuffmanTree(f,N);

34.

35. cout<<"各字符出现的对应频率分别为：

"<

36.for(int i=1; i<=N; i++)

37. {

38. cout<

39. }

40. cout<

41.

42. cout<<"生成二叉树的前序遍历结果为：

"<

43. t.Pre_Order();

44. cout<

45.

46. cout<<"生成二叉树的中序遍历结果为：

"<

47. t.In_Order();

48. cout<

49.

50. t.DestroyTree();

51.return 0;

52.}

53.

54.template

55.BinaryTree HuffmanTree(Type f[],int n)

56.{

57.//生成单节点树

58. Huffman *w = new Huffman[n+

1];

59. BinaryTree z,zero;

60.

61.for(int i=1; i<=n; i++)

62. {

63. z.MakeTree(i,zero,zero);

64. w[i].weight = f[i];

65. w[i].tree = z;

66. }

67.

68.//建优先队列

69. MinHeap> Q(n);

70.for(int i=1; i<=n; i++) Q.Insert(w[i]);

71.

72.//反复合并最小频率树

73. Huffman x,y;

74.for(int i=1; i

75. {

76. x = Q.RemoveMin();

77. y = Q.RemoveMin();

78. z.MakeTree(0,x.tree,y.tree);

79. x.weight += y.weight;

80. x.tree = z;

81. Q.Insert(x);

82. }

83.

84. x = Q.RemoveMin();

85.

86.delete[] w;

87.

88.return x.tree;

89.}

(2)BinaryTree.h 二叉树实现

1.#include

https://www.360docs.net/doc/0b16407648.html,ing namespace std;

3.

4.template

5.struct BTNode

6.{

7. T data;

8. BTNode *lChild,*rChild;

9.

10. BTNode()

11. {

12. lChild=rChild=NULL;

13. }

14.

15. BTNode(const T &val,BTNode *Childl=N

ULL,BTNode *Childr=NULL)

16. {

17. data=val;

18. lChild=Childl;

19. rChild=Childr;

20. }

21.

22. BTNode* CopyTree()

23. {

24. BTNode *nl,*nr,*nn;

25.

26.if(&data==NULL)

27.return NULL;

28.

29. nl=lChild->CopyTree();

30. nr=rChild->CopyTree();

31.

32. nn=new BTNode(data,nl,nr);

33.return nn;

34. }

35.};

36.

37.

38.template

39.class BinaryTree

40.{

41.public:

42. BTNode *root;

43. BinaryTree();

44. ~BinaryTree();

45.

46.void Pre_Order();

47.void In_Order();

48.void Post_Order();

49.

50.int TreeHeight()const;

51.int TreeNodeCount()const;

52.

53.void DestroyTree();

54.void MakeTree(T pData,BinaryTree

leftTree,BinaryTree rightTree);

55.void Change(BTNode *r);

56.

57.private:

58.void Destroy(BTNode *&r);

59.void PreOrder(BTNode *r);

60.void InOrder(BTNode *r);

61.void PostOrder(BTNode *r);

62.

63.int Height(const BTNode *r)const

;

64.int NodeCount(const BTNode *r)co

nst;

65.};

66.

67.template

68.BinaryTree::BinaryTree()

69.{

70. root=NULL;

71.}

72.

73.template

74.BinaryTree::~BinaryTree()

75.{

76.

77.}

78.

79.template

80.void BinaryTree::Pre_Order()

81.{

82. PreOrder(root);

83.}

84.

85.template

86.void BinaryTree::In_Order()

87.{

88. InOrder(root);

89.}

90.

91.template

92.void BinaryTree::Post_Order()

93.{

94. PostOrder(root);

95.}

96.

97.template

98.int BinaryTree::TreeHeight()const

99.{

100.return Height(root);

101.}

102.

103.template

104.int BinaryTree::TreeNodeCount()const 105.{

106.return NodeCount(root);

107.}

108.

109.template

110.void BinaryTree::DestroyTree()

111.{

112. Destroy(root);

113.}

114.

115.template

116.void BinaryTree::PreOrder(BTNode *r)

117.{

118.if(r!=NULL)

119. {

120. cout<data<<' ';

121. PreOrder(r->lChild);

122. PreOrder(r->rChild);

123. }

124.}

125.

126.template

127.void BinaryTree::InOrder(BTNode *r)

128.{

129.if(r!=NULL)

130. {

131. InOrder(r->lChild);

132. cout<data<<' ';

133. InOrder(r->rChild);

134. }

135.}

136.

137.template

138.void BinaryTree::PostOrder(BTNode *r )

139.{

140.if(r!=NULL)

141. {

142. PostOrder(r->lChild);

143. PostOrder(r->rChild);

144. cout<data<<' ';

145. }

146.}

147.

148.template

149.int BinaryTree::NodeCount(const BTNode< T> *r)const

150.{

151.if(r==NULL)

152.return 0;

153.else

154.return 1+NodeCount(r->lChild)+Node Count(r->rChild);

155.}

156.

157.template

158.int BinaryTree::Height(const BTNode *r)const

159.{

160.if(r==NULL)

161.return 0;

162.else

163. {

164.int lh,rh;

165. lh=Height(r->lChild);

166. rh=Height(r->rChild);

167.return 1+(lh>rh?lh:rh);

168. }

169.}

170.

171.template

172.void BinaryTree::Destroy(BTNode *&r)

173.{

174.if(r!=NULL)

175. {

176. Destroy(r->lChild);

177. Destroy(r->rChild);

178.delete r;

179. r=NULL;

180. }

181.}

182.

183.template

184.void BinaryTree::Change(BTNode *r)//将二叉树bt所有结点的左右子树交换

185.{

186. BTNode *p;

187.if(r){

188. p=r->lChild;

189. r->lChild=r->rChild;

190. r->rChild=p; //左右子女交换

191. Change(r->lChild); //交换左子树上

所有结点的左右子树

192. Change(r->rChild); //交换右子树上所有结点的左右子树

193. }

194.}

195.

196.template

197.void BinaryTree::MakeTree(T pData,Binar yTree leftTree,BinaryTree rightTree)

198.{

199. root = new BTNode();

200. root->data = pData;

201. root->lChild = leftTree.root;

202. root->rChild = rightTree.root;

203.}

(3)MinHeap.h 最小堆实现

1.#include

https://www.360docs.net/doc/0b16407648.html,ing namespace std;

3.template

4.class MinHeap

5.{

6.private:

7. T *heap; //元素数组，0号位置也储存元

素

8.int CurrentSize; //目前元素个数

9.int MaxSize; //可容纳的最多元素个

数

10.

11.void FilterDown(const int start,con

st int end); //自上往下调整，使关键字小的节点在

上

12.void FilterUp(int start); //自下往

上调整

13.

14.public:

15. MinHeap(int n=1000);

16. ~MinHeap();

17.bool Insert(const T &x); //插入元

素

18.

19. T RemoveMin(); //删除最小元素

20. T GetMin(); //取最小元素

21.

22.bool IsEmpty() const;

23.bool IsFull() const;

24.void Clear();

25.};

26.

27.template

28.MinHeap::MinHeap(int n)

29.{

30. MaxSize=n;

31. heap=new T[MaxSize];

32. CurrentSize=0;

33.}

34.

35.template

36.MinHeap::~MinHeap()

37.{

38.delete []heap;

39.}

40.

41.template

42.void MinHeap::FilterUp(int start) //自下

往上调整

43.{

44.int j=start,i=(j-1)/2; //i指向j的双亲节

点

45. T temp=heap[j];

46.

47.while(j>0)

48. {

49.if(heap[i]<=temp)

50.break;

51.else

52. {

53. heap[j]=heap[i];

54. j=i;

55. i=(i-1)/2;

56. }

57. }

58. heap[j]=temp;

59.}

60.

61.template

62.void MinHeap::FilterDown(const int start

,const int end) //自上往下调整，使关键字小的节点在上

63.{

64.int i=start,j=2*i+1;

65. T temp=heap[i];

66.while(j<=end)

67. {

68.if( (jheap[j+1])

)

69. j++;

70.if(temp<=heap[j])

71.break;

72.else

73. {

74. heap[i]=heap[j];

75. i=j;

76. j=2*j+1;

77. }

78. }

79. heap[i]=temp;

80.}

81.

82.template

83.bool MinHeap::Insert(const T &x)

84.{

85.if(CurrentSize==MaxSize)

86.return false;

87.

88. heap[CurrentSize]=x;

89. FilterUp(CurrentSize);

90.

91. CurrentSize++;

92.return true;

93.}

94.

95.template

96.T MinHeap::RemoveMin( )

97.{

98. T x=heap[0];

99. heap[0]=heap[CurrentSize-1];

100.

101. CurrentSize--;

102. FilterDown(0,CurrentSize-1); //调整新的根节点

103.

104.return x;

105.}

106.

107.template

108.T MinHeap::GetMin()

109.{

110.return heap[0];

111.}

112.

113.template

114.bool MinHeap::IsEmpty() const

115.{

116.return CurrentSize==0;

117.}

118.

119.template

120.bool MinHeap::IsFull() const

121.{