冲击初赛之哈夫曼编码

哈夫曼编码，又称为 Huffman Coding

是一种可变长编码（ VLC, variable length coding)）方式，比起定长编码的 ASCII 编码来说，哈夫曼编码能节省很多的空间，因为每一个字符出现的频率不是一致的；

是一种用于无损数据压缩的熵编码算法，通常用于压缩重复率比较高的字符数据。

如果我们通过转换成ASCII码对应的二进制数据将字符串 BCAADDDCCACACAC 通过二进制编码进行传输，那么一个字符传输的二进制位数为 8bits，那么总共需要 120 个二进制位；而如果使用哈夫曼编码，该串字符可压缩至 28位。

哈夫曼编码方法

哈夫曼编码首先会使用字符的频率创建一棵树，然后通过这个树的结构为每个字符生成一个特定的编码，出现频率高的字符使用较短的编码，出现频率低的则使用较长的编码，这样就会使编码之后的字符串平均长度降低，从而达到数据无损压缩的目的。

1. 计算字符串中每个字符的频率：

2. 按照字符出现的频率进行排序，组成一个队列 Q 
出现频率最低的在前面，出现频率高的在后面。

3. 把这些字符作为叶子节点开始构建一颗哈夫曼树
哈夫曼树又称为最优二叉树，是一种带权路径长度最短的二叉树。

（1）首先创建一个空节点 z，将最小频率的字符分配给 z 的左侧，并将频率排在第二位的分配给 z 的右侧，然后将 z 赋值为两个字符频率的和；然后从队列 Q 中删除 B 和 D，并将它们的和添加到队列中，上图中 * 表示的位置。

（2）紧接着，重新创建一个空的节点 z，并将 4 作为左侧的节点，频率为 5 的 A 作为右侧的节点，4 与 5 的和作为父节点，并把这个和按序加入到队列中，再根据频率从小到大构建树结构（小的在左）。

（3）继续按照之前的思路构建树，直到所有的字符都出现在树的节点中，哈弗曼树构建完成。

节点的带权路径长度为从根节点到该节点的路径长度与节点权值的乘积。

该二叉树的带权路径长度 WPL = 6 * 1 + 5 * 2 + 3 * 3 + 1 * 3 = 28。

4. 对字符进行编码：
哈夫曼树构建完成，下面我们要对各个字母进行编码，编码原则是：对于每个非叶子节点，将 0 分配给连接线的左侧，1 分配给连接线的右侧，最终得到字符的编码就是从根节点开始，到该节点的路径上的 0 1 序列组合。

因此各个字母的编码分别为：

A	B	C	D
11	100	0	101

在没有经过哈夫曼编码之前，字符串“BCAADDDCCACACAC”的二进制为：

10000100100001101000001010000010100010001000100010001000100001101000011010000010100001101000001010000110100000101000011

也就是占了 120 比特；

编码之后为：

1000111110110110100110110110

占了 28 比特。

5. 确定发送的数据
哈夫曼编码将发送字符串的数据长度极大压缩，考虑到接收方的编码，还需要把哈夫曼树的结构也传递过去。

即字符占用的 32 比特和 频率占用的 15 比特也需要传递过去。

总体上，编码后比特数为32 + 15 + 28 = 75，比 120 比特少了 45 个，效率还是非常高的。

从本质上讲，哈夫曼编码是将最宝贵的资源（最短的编码）给出现概率最多的数据。

在上面的例子中，C 出现的频率最高，它的编码为 0，就省下了不少空间。

特点
哈夫曼树和编码都不唯一！只有树的WPL(带权路径长度)才是唯一的！

Huffman编码效果的唯一性
判断是否为哈夫曼编码（编程题）

哈夫曼编码有两个特点：

带权路径长度WPL最短且唯一；
编码互不为前缀（一个编码不是另一个编码的开头）。
为什么通过哈夫曼编码后得到的二进制码不会有前缀的问题呢？
这是因为在哈夫曼树中，每个字母对应的节点都是叶子节点，而他们对应的二进制码是由根节点到各自节点的路径所决定的，正因为是叶子节点，每个节点的路径不可能和其他节点有前缀的关系。

为什么通过哈夫曼编码获得的二进制码短呢？
因为哈夫曼树是带权路径长度最短的树，权值较大的节点离根节点较近。而带权路径长度是指：树中所有的叶子节点的权值乘上其到根节点的路径长度，这与最终的哈夫曼编码总长度成正比关系的。

参考资料：
图解霍夫曼编码

哈夫曼编码（Huffman Coding）多图详细解析

哈夫曼编码的算法实现 

算法描述：

1. void CreatHuffmanCode(HuffmanTree HT, HuffmanCode &HC, int n)

2. {

3. //从叶子到根逆向求每个字符的赫夫曼编码，存储在编码表HC中

4. int i, start, c, f;

5. HC = new char*[n + 1]; // 分配n个字符编码的头指针矢量

6. char *cd = new char[n]; // 分配临时存放编码的动态数组空间

7. cd[n - 1] = '\0'; // 编码结束符

9. for (i = 1; i <= n; ++i)

10. { // 逐个字符求赫夫曼编码

11. start = n - 1; // start开始时指向最后，即编码结束符位置

12. c = i;

13. f = HT[i].parent; // f指向结点c的双亲结点

14. while (f != 0)

15. { // 从叶子结点开始向上回溯，直到根结点

16. --start; // 回溯一次start向前指一个位置

17. if (HT[f].lchild == c)

18. cd[start] = '0'; // 结点c是f的左孩子，则生成代码0

19. else

20. cd[start] = '1'; // 结点c是f的右孩子，则生成代码1

21. c = f;

22. f = HT[f].parent; // 继续向上回溯

23. }

24. // 求出第i个字符的编码

25. HC[i] = new char[n - start]; // 为第i 个字符编码分配空间

26. strcpy(HC[i], &cd[start]); // 将求得的编码从临时空间cd复制到HC的当前行中

27. }

29. delete cd; // 释放临时空间

30. }

代码实现：

1. #include <iostream>

2. #include <cstdlib>

3. #include <string>

5. using namespace std;

7. typedef struct

8. {

9. int weight;

10. int parent, lchild, rchild;

11. }HTNode, *HuffmanTree;

13. typedef char **HuffmanCode;

15. void Select(HuffmanTree HT, int len, int &s1, int &s2)

16. {

17. int i, min1 = 0x3f3f3f3f, min2 = 0x3f3f3f3f; // 先赋予最大值

18. for (i = 1; i <= len; i++)

19. {

20. if (HT[i].weight < min1 && HT[i].parent == 0)

21. {

22. min1 = HT[i].weight;

23. s1 = i;

24. }

25. }

26. int temp = HT[s1].weight; // 将原值存放起来，然后先赋予最大值，防止s1被重复选择

27. HT[s1].weight = 0x3f3f3f3f;

28. for (i = 1; i <= len; i++)

29. {

30. if (HT[i].weight < min2 && HT[i].parent == 0)

31. {

32. min2 = HT[i].weight;

33. s2 = i;

34. }

35. }

37. HT[s1].weight = temp;// 恢复原来的值

38. }

40. void CreatHuffmanTree(HuffmanTree &HT, int n)

41. {

42. //构造赫夫曼树HT

43. int m, s1, s2, i;

44. if (n <= 1)

45. return;

46. m = 2 * n - 1;

47. HT = new HTNode[m + 1]; // 0号单元未用，所以需要动态分配m+1个单元，HT[m]表示根结点

48. for (i = 1; i <= m; ++i) // 将1~m号单元中的双亲、左孩子，右孩子的下标都初始化为0

49. {

50. HT[i].parent = 0; HT[i].lchild = 0; HT[i].rchild = 0;

51. }

52. cout << "请输入叶子结点的权值：\n";

53. for (i = 1; i <= n; ++i) // 输入前n个单元中叶子结点的权值

54. cin >> HT[i].weight;

56. /*――――――――――初始化工作结束，下面开始创建赫夫曼树――――――――――*/

57. // 通过n-1次的选择、删除、合并来创建赫夫曼树

58. for (i = n + 1; i <= m; ++i)

59. {

60. Select(HT, i - 1, s1, s2); // 在HT[k](1≤k≤i-1)中选择两个其双亲域为0且权值最小的结点,并返回它们在HT中的序号s1和s2

61. HT[s1].parent = i;

62. HT[s2].parent = i;

63. // 得到新结点i，从森林中删除s1，s2，将s1和s2的双亲域由0改为i

64. HT[i].lchild = s1;

65. HT[i].rchild = s2; // s1,s2分别作为i的左右孩子

66. HT[i].weight = HT[s1].weight + HT[s2].weight; //i 的权值为左右孩子权值之和

67. }

68. }

70. void CreatHuffmanCode(HuffmanTree HT, HuffmanCode &HC, int n)

71. {

72. //从叶子到根逆向求每个字符的赫夫曼编码，存储在编码表HC中

73. int i, start, c, f;

74. HC = new char*[n + 1]; // 分配n个字符编码的头指针矢量

75. char *cd = new char[n]; // 分配临时存放编码的动态数组空间

76. cd[n - 1] = '\0'; // 编码结束符

78. for (i = 1; i <= n; ++i)

79. { // 逐个字符求赫夫曼编码

80. start = n - 1; // start开始时指向最后，即编码结束符位置

81. c = i;

82. f = HT[i].parent; // f指向结点c的双亲结点

83. while (f != 0)

84. { // 从叶子结点开始向上回溯，直到根结点

85. --start; // 回溯一次start向前指一个位置

86. if (HT[f].lchild == c)

87. cd[start] = '0'; // 结点c是f的左孩子，则生成代码0

88. else

89. cd[start] = '1'; // 结点c是f的右孩子，则生成代码1

90. c = f;

91. f = HT[f].parent; // 继续向上回溯

92. }

93. // 求出第i个字符的编码

94. HC[i] = new char[n - start]; // 为第i 个字符编码分配空间

95. strcpy(HC[i], &cd[start]); // 将求得的编码从临时空间cd复制到HC的当前行中

96. }

98. delete cd; // 释放临时空间

99. }

101. void show(HuffmanTree HT, HuffmanCode HC)

102. {

103. for (int i = 1; i <= sizeof(HC) + 1; i++)

104. cout << HT[i].weight << "编码为" << HC[i] << endl;

105. }

107. int main()

108. {

109. HuffmanTree HT;

110. HuffmanCode HC;

111. int n;

112. cout << "请输入叶子结点的个数：\n";

113. cin >> n; //输入赫夫曼树的叶子结点个数

114. CreatHuffmanTree(HT, n);

115. CreatHuffmanCode(HT, HC, n);

116. show(HT, HC);

118. system("pause");

120. return 0;

121. }