哈弗曼树详解

转自：http://c.biancheng.net/view/3398.html

赫夫曼树，别名“哈夫曼树”、“最优树”以及“最优二叉树”。学习哈夫曼树之前，首先要了解几个名词。

哈夫曼树相关的几个名词

路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。图 1 中，从根结点到结点 a 之间的通路就是一条路径。

路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。图 1 中从根结点到结点 c 的路径长度为 3。

结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权。例如，图 1 中结点 a 的权为 7，结点 b 的权为 5。

结点的带权路径长度：指的是从根结点到该结点之间的路径长度与该结点的权的乘积。例如，图 1 中结点 b 的带权路径长度为 2 * 5 = 10 。

树的带权路径长度为树中所有叶子结点的带权路径长度之和。通常记作 “WPL” 。例如图 1 中所示的这颗树的带权路径长度为：

WPL = 7 * 1 + 5 * 2 + 2 * 3 + 4 * 3

图1 哈夫曼树

什么是哈夫曼树

当用 n 个结点（都做叶子结点且都有各自的权值）试图构建一棵树时，如果构建的这棵树的带权路径长度最小，称这棵树为“最优二叉树”，有时也叫“赫夫曼树”或者“哈夫曼树”。

在构建哈弗曼树时，要使树的带权路径长度最小，只需要遵循一个原则，那就是：权重越大的结点离树根越近。在图 1 中，因为结点 a 的权值最大，所以理应直接作为根结点的孩子结点。

构建哈夫曼树的过程

对于给定的有各自权值的 n 个结点，构建哈夫曼树有一个行之有效的办法：

1. 在 n 个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权值的和；
2. 在原有的 n 个权值中删除那两个最小的权值，同时将新的权值加入到 n–2 个权值的行列中，以此类推；
3. 重复 1 和 2 ，直到所以的结点构建成了一棵二叉树为止，这棵树就是哈夫曼树。

图 2 哈夫曼树的构建过程
 

图 2 中，（A）给定了四个结点a，b，c，d，权值分别为7，5，2，4；第一步如（B）所示，找出现有权值中最小的两个，2 和 4 ，相应的结点 c 和 d 构建一个新的二叉树，树根的权值为 2 + 4 = 6，同时将原有权值中的 2 和 4 删掉，将新的权值 6 加入；进入（C），重复之前的步骤。直到（D）中，所有的结点构建成了一个全新的二叉树，这就是哈夫曼树。

哈弗曼树中结点结构

构建哈夫曼树时，首先需要确定树中结点的构成。由于哈夫曼树的构建是从叶子结点开始，不断地构建新的父结点，直至树根，所以结点中应包含指向父结点的指针。但是在使用哈夫曼树时是从树根开始，根据需求遍历树中的结点，因此每个结点需要有指向其左孩子和右孩子的指针。

所以，哈夫曼树中结点构成用代码表示为：

1. //哈夫曼树结点结构
2. typedef struct {
3. int weight;//结点权重
4. int parent, left, right;//父结点、左孩子、右孩子在数组中的位置下标
5. }HTNode, *HuffmanTree;

构建哈弗曼树的算法实现

构建哈夫曼树时，需要每次根据各个结点的权重值，筛选出其中值最小的两个结点，然后构建二叉树。

查找权重值最小的两个结点的思想是：从树组起始位置开始，首先找到两个无父结点的结点（说明还未使用其构建成树），然后和后续无父结点的结点依次做比较，有两种情况需要考虑：

• 如果比两个结点中较小的那个还小，就保留这个结点，删除原来较大的结点；
• 如果介于两个结点权重值之间，替换原来较大的结点；

实现代码：

1. //HT数组中存放的哈夫曼树，end表示HT数组中存放结点的最终位置，s1和s2传递的是HT数组中权重值最小的两个结点在数组中的位置
2. void Select(HuffmanTree HT, int end, int *s1, int *s2)
3. {
4. int min1, min2;
5. //遍历数组初始下标为 1
6. int i = 1;
7. //找到还没构建树的结点
8. while(HT[i].parent != 0 && i <= end){
9. i++;
10. }
11. min1 = HT[i].weight;
12. *s1 = i;
14. i++;
15. while(HT[i].parent != 0 && i <= end){
16. i++;
17. }
18. //对找到的两个结点比较大小，min2为大的，min1为小的
19. if(HT[i].weight < min1){
20. min2 = min1;
21. *s2 = *s1;
22. min1 = HT[i].weight;
23. *s1 = i;
24. }else{
25. min2 = HT[i].weight;
26. *s2 = i;
27. }
28. //两个结点和后续的所有未构建成树的结点做比较
29. for(int j=i+1; j <= end; j++)
30. {
31. //如果有父结点，直接跳过，进行下一个
32. if(HT[j].parent != 0){
33. continue;
34. }
35. //如果比最小的还小，将min2=min1，min1赋值新的结点的下标
36. if(HT[j].weight < min1){
37. min2 = min1;
38. min1 = HT[j].weight;
39. *s2 = *s1;
40. *s1 = j;
41. }
42. //如果介于两者之间，min2赋值为新的结点的位置下标
43. else if(HT[j].weight >= min1 && HT[j].weight < min2){
44. min2 = HT[j].weight;
45. *s2 = j;
46. }
47. }
48. }

注意：s1和s2传入的是实参的地址，所以函数运行完成后，实参中存放的自然就是哈夫曼树中权重值最小的两个结点在数组中的位置。

构建哈弗曼树的代码实现如下：

1. //HT为地址传递的存储哈夫曼树的数组，w为存储结点权重值的数组，n为结点个数
2. void CreateHuffmanTree(HuffmanTree *HT, int *w, int n)
3. {
4. if(n<=1) return; // 如果只有一个编码就相当于0
5. int m = 2*n-1; // 哈夫曼树总节点数，n就是叶子结点
6. *HT = (HuffmanTree) malloc((m+1) * sizeof(HTNode)); // 0号位置不用
7. HuffmanTree p = *HT;
8. // 初始化哈夫曼树中的所有结点
9. for(int i = 1; i <= n; i++)
10. {
11. (p+i)->weight = *(w+i-1);
12. (p+i)->parent = 0;
13. (p+i)->left = 0;
14. (p+i)->right = 0;
15. }
16. //从树组的下标 n+1 开始初始化哈夫曼树中除叶子结点外的结点
17. for(int i = n+1; i <= m; i++)
18. {
19. (p+i)->weight = 0;
20. (p+i)->parent = 0;
21. (p+i)->left = 0;
22. (p+i)->right = 0;
23. }
24. //构建哈夫曼树
25. for(int i = n+1; i <= m; i++)
26. {
27. int s1, s2;
28. Select(*HT, i-1, &s1, &s2);
29. (*HT)[s1].parent = (*HT)[s2].parent = i;
30. (*HT)[i].left = s1;
31. (*HT)[i].right = s2;
32. (*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;
33. }
34. }

注意，如果使用此程序，对权重值分别为 2、8、7、6、5 的节点构建哈夫曼树，最终效果如图 4(A) 所示。但其实，图 4(B) 中显示的哈夫曼树也满足条件，这两棵树的带权路径长度相同。

图 4 两种哈夫曼树

之所以使用此程序构建的哈夫曼树，是图 4(A) 而不是 4(B)，是因为在构建哈夫曼树时，结点 2 和结点 5 构建的新的结点 7 存储在动态树组中位置，比权重值为 7 节点的存储位置还靠后，所以，在程序继续选择两个权值最小的结点时，直接选择了的叶子结点 6 和 7 。