最小堆的应用之哈弗曼树

转：https://blog.csdn.net/qq_26046771/article/details/69388436

 

哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度的乘积之和。哈弗曼编码是它的重要应用，哈弗曼编码是一种无前缀编码。

 

假设计算机世界里文字只由由A、B、C、D、E四个字符组成，它们出现的频率分别为5,4,3,2,1,那么我们第一步先取两个最小权值作为左右子树构造一个新树，即取1，2构成新树，其结点为1+2=3，如图：

 

虚线为新生成的结点，第二步再把新生成的权值为3的结点放到剩下的集合中，所以集合变成{5,4,3,3}，再根据第二步，取最小的两个权值构成新树，如图：

再依次建立哈夫曼树，如下图：

其中各个权值替换对应的字符即为下图：

所以各字符对应的编码为：A->11,B->10,C->00,D->011,E->010

霍夫曼编码是一种无前缀编码。解码时不会混淆。其主要应用在数据压缩，加密解密等场合。

(以上来自网络，接下来进入正题编码，创建二叉树后，用前序遍历粗略检测)

以下代码为原创

输入:

5

1 2 3 4 5

输出:15 6 3 3 1 2 9 4 5

 

1. #include<stdio.h>

2. #include<stdlib.h>

3. #include<stdbool.h>

4. #include<time.h>

5. typedef int Weight;

6. typedef struct Tnode

7. {

8. Weight weight;

9. struct Tnode *left,*right;

10. }*Ptnode;

11. typedef Ptnode Huffman;

12.  

13. ///

14. typedef Ptnode Ele;

15. const Ele ERROR=NULL;

16. typedef struct Hnode

17. {

18. Ele *data;

19. int size;

20. int maxsize;

21. }*heap;

22. typedef heap Minheap;

23.  
24.  

25. Minheap createMinheap(int maxsize){

26. Minheap h=(Minheap)malloc(sizeof(struct Hnode));

27. h->data=(Ele*)malloc(sizeof(Ele)*(maxsize+1));

28. h->size=0;

29. h->maxsize=maxsize;

30. return h;

31. }

32. void freeMinheap(Minheap h){

33. if(h!=NULL){

34. free(h->data);

35. free(h);

36. }

37. h=NULL;

38. }

39. bool isfull(Minheap h){

40. return h->size>=h->maxsize;

41. }

42. bool isempty(Minheap h){

43. if(h){

44. return h->size==0;

45. }

46. }

47.  

48. void insert(Minheap h,Ele e){

49. if(isfull(h))

50. {printf("full\n");return;}

51. int i=++h->size;

52. for(;i>1&&h->data[i/2]->weight>e->weight;i/=2){

53. h->data[i]=h->data[i/2];

54. }

55. h->data[i]=e;

56. }

57.  

58. Ele del(Minheap h){

59. if(isempty(h))

60. {printf("emtpy\n");return ERROR;}

61. Ele min=h->data[1];

62. Ele tmp=h->data[h->size--];

63. int i=1,childmin;

64. for(;2*i<=h->size;i=childmin){

65. childmin=2*i;

66. if(h->data[childmin]->weight>h->data[childmin+1]->weight)

67. childmin++;

68. if(tmp->weight<=h->data[childmin]->weight)break;

69. h->data[i]=h->data[childmin];

70. }

71. h->data[i]=tmp;

72. return min;

73. }

74.  

75. Ptnode newNode(){

76. Ptnode ptnode=(Ptnode)malloc(sizeof(struct Tnode));

77. ptnode->left=NULL;

78. ptnode->right=NULL;

79. return ptnode;

80. }

81.  

82. Huffman createHuffman(int n){

83. Huffman huff=NULL;

84. Minheap h=createMinheap(n);

85. Weight weight;

86. Ptnode leftnode,rightnode,newnode;

87. for(int i=0;i<n;i++)

88. {scanf("%d",&weight);

89. newnode=newNode();

90. newnode->weight=weight;

91. insert(h,newnode);

92. }

93. for(int i=0;i<n-1;i++){

94. leftnode=del(h);

95. rightnode=del(h);

96. newnode=newNode();

97. newnode->weight=leftnode->weight+rightnode->weight;

98. newnode->left=leftnode;

99. newnode->right=rightnode;

100. insert(h,newnode);

101. }

102. huff=del(h);

103. freeMinheap(h);

104. return huff;

105. }

106.  

107. void pr(Huffman h){

108. if(h){

109. printf("%d ",h->weight );

110. pr(h->left);

111. pr(h->right);

112. }

113. }

114.  
115.  
116.  

117. int main(){

118. int n=0;

119. scanf("%d",&n);

120. Huffman huff=createHuffman(n);

121. pr(huff);

122. }

123.