简介
哈夫曼树是一种带权路径长度最短的二叉树，也称为最优二叉树。
定义：给定 n 个权值作为 n 个叶子节点，构造一颗二叉树，若树的带权路径长度达到最小，则这棵树称为哈夫曼树。
路径的长度：从树中的一个结点到另外一个结点之间的分支构成两个结点的路径，路径上的分支数目称为路径长度。
树的路径长度：从树根到每个结点的路径长度之和，所以我们说完全二叉树就是这种路径长度最短的二叉树。
树的带权路径长度：如果在树的每个叶子节点上赋一个权值，那么熟的带权路径长度就等于根节点到所有叶子节点的路径长度与叶子节点权值乘积的总和。
如何判断一棵树是否是最优二叉树？
带权长度分别为：
WPL1：7*2+5*2+2*2+4*2=36
WPL2：7*3+5*3+2*1+4*2=46
WPL3：7*1+5*2+2*3+4*3=35
第三棵树的带权路径最短。所以第三棵就是我们要找的 最优二叉树（哈夫曼树）。
哈夫曼树的构建
依次取权重最小的节点放在树的底部，将最小的两个连接构成新的节点（新节点的权值是两个最小节点权值之和），然后把新节点放回需要构成的树中继续进行排序，构成哈夫曼树，要存放的所有信息都在叶子节点上。
| a | b | c | d | e |
|---|---|---|---|---|
| 45 | 42 | 60 | 100 | 75 |
上表中的字母分别带有权重，将其构成哈弗曼树。
- 先对表中数据进行排序
| d | e | c | a | b |
|---|---|---|---|---|
| 100 | 75 | 60 | 54 | 42 |
取出队列中的两个权重最小的节点作为树的底部，按照左边的子树永远小于右边的原则进行构造。并将新生成的节点放在队列中进行重新排序。a=42，b=45，新节点为 87。
| d | e | c | |
|---|---|---|---|
| 100 | 87 | 75 | 60 |
然后将 87 加入队列，形成新的队列，并进行排序。
| d | e | c | |
|---|---|---|---|
| 100 | 87 | 75 | 60 |
再按照之前的方法将队列中最小的两个树作为树的底部，形成一个新节点。c=60，e=75，新节点为 135。
依次重复以上步骤就可以画出该哈夫曼树了。
| d | ||
|---|---|---|
| 135 | 100 | 87 |
87 和 d = 100 构成新节点 187。
| 322 | 135 |
Java 编码
如上就是构造哈夫曼的过程。接下来用 java 实现上面我画的那棵哈夫曼树。
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class HuffmanTreeDemo {
public static void main(String[] args) {
List<Node<String>> nodes = new ArrayList<>();
nodes.add(new Node<String>("a", 45));
nodes.add(new Node<String>("b", 42));
nodes.add(new Node<String>("c", 60));
nodes.add(new Node<String>("d", 100));
nodes.add(new Node<String>("e", 75));
Node<String> root = HuffmanTree.createTree(nodes);
HuffmanTree.levelDisplay(root);
}
static class Node<T> implements Comparable<Node<T>> {
public T data;
public int weight;
public Node<T> left;
public Node<T> right;
public Node(T data, int weight) {
super();
this.data = data;
this.weight = weight;
}
@Override
public String toString() {
return "data:" + this.data + ",weight:" + this.weight + "; ";
}
@Override
public int compareTo(Node<T> o) {
if (o.weight > this.weight) {
return 1;
} else if (o.weight < this.weight) {
return -1;
}
return 0;
}
}
static class HuffmanTree<T> {
//参数是多个节点组成的队列
public static <T> Node<T> createTree(List<Node<T>> nodes) {
while (nodes.size() > 1) {// 只剩一个节点时，退出循环
Collections.sort(nodes);
// 使用sort方法对nodes进行排序，CompareTo方法实现的是降序序列
Node<T> left = nodes.get(nodes.size() - 1);// 取两个最小的节点
Node<T> right = nodes.get(nodes.size() - 2);
// 生成新节点，新节点的权重 = 两个权重最小的节点的和
Node<T> parent = new Node<T>(null, left.weight + right.weight);
parent.left = left;
parent.right = right;
nodes.remove(left);
nodes.remove(right);
nodes.add(parent);
}
return nodes.get(0);
}
public static void levelDisplay(Node root) {
List<Node> list = new ArrayList<>();
Queue<Node> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
Node node = queue.poll();
System.out.println(node.toString());
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
}
}
}
运行结果
data:null,weight:322;
data:null,weight:135;
data:null,weight:187;
data:c,weight:60;
data:e,weight:75;
data:null,weight:87;
data:d,weight:100;
data:b,weight:42;
data:a,weight:45;
哈夫曼编码
哈夫曼编码 (Huffman Coding) 是一种编码方法，哈夫曼编码是可变字长编码(VLC)的一种。
哈夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。
哈夫曼编码的具体步骤如下：
1）将信源符号的概率按减小的顺序排队。
2）把两个最小的概率相加，并继续这一步骤，始终将较高的概率分支放在右边，直到最后变成概率 １。
3）画出由概率 １ 处到每个信源符号的路径，顺序记下沿路径的 ０ 和 １，所得就是该符号的哈夫曼码字。
4）将每对组合的左边一个指定为 0，右边一个指定为 1（或相反）。
根据哈夫曼树可以解决报文编码的问题。假设需要把一个字符串，如 “abcdabcaba” 进行编码，将它转换为唯一的二进制码，但是要求转换出来的二进制码的长度最小。
假设每个字符在字符串出现频率为 w，其编码长度为 L，编码字符 n 个，则编码后二进制的总长度为 W1L1+W2L2+…+WnLn，这恰好是哈夫曼树的处理原则。因此可以采用哈夫曼的构造原理进行二进制编码，从而使得电文长度最短。
对于 “abcdabcaba”，共有 a、b、c、d 四个字符，出现次数分别为 4、3、2、1，相当于它们的权值，将 a、b、c、d 以出现次数为权值构造哈夫曼树，得到下左图的结果。
从哈夫曼树根节点开始，对左子树分配代码 “0”，对右子树分配 “1”，一直到达叶子节点。然后，将从树根沿着每条路径到达叶子节点的代码排列起来，便得到每个叶子节点的哈夫曼编码，如下右图。
从图中可以看出，a、b、c、d 对应的编码分别为 0、10、110、111，然后将字符串 “abcdabcaba” 转换为对应的二进制码就是0101101110101100100，长度仅为 19。这也就是最短二进制编码，也称为哈夫曼编码。
