赫夫曼树

基本介绍

给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为赫夫曼树(Huffman Tree)，为啥加赫夫曼树，因为是赫夫曼大叔发明的。

只凭上面这句话肯定是不能理解什么是赫夫曼树的

1. 赫夫曼大叔说了，从树的一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。如图1所示加粗的线条就是从根节点到节点C的路径

图1：图中的加粗连线就是从根节点到节点C的一条路径

2. 路径中分支的数目称为路径长度。
如 图1 所示的二叉树中，根节点到节点C的路径长度就是3；到节点E的路径长度就是4。

3.树的路径长度：树的路径长度就是从树的根节点到每一个节点的路径长度之和
如 图1 所示的二叉树，树的路径长度就是 1+1+2+2+3+3+4+4=20。

4.节点的权：若给树中的节点赋予一个有着某种意义的数值，则这个数值就是该节点的权，如图2

图2：节点的权

5.节点的带权路径长度：节点的带权路径长度 =（该节点到树根之间的路径长度）* （节点上权的乘积）
如 图2 节点C的戴荃路径长度就是3 * 15 = 45。

6.树的带权路径长度（记做WPL）：树的带权路径长度 = 树的所有叶子节点的带权按路径长度之和
如 图2 ，WPL = 1*30 + 2*20 + 3*15 + 4*5 + 4*10 = 175。

tips：是所有叶子节点的带权路径之和，是叶子节点。

7.WPL最小的二叉树就是赫夫曼树
赫夫曼树中，权值越大的节点离根节点越近。

说了以上那些，你应该明白啥事赫夫曼树了，那么怎么构建赫夫曼树呢

步骤如下：

1. 将树中的每一个节点按权值升序排列，每个节点可以看成是一颗最简单的二叉树。
2. 取出权值最小的两个节点，组成一颗新的二叉树，权值小的作为左子树，权值大的作为右孩子，这颗二叉树的权值为取出的两个节点的权值之和。
3. 将新组成的这棵树，以根节点的权值大小再次进行升序排列，然后回到第2步，不断重复2-3的步骤，直到所有的节点都为处理完毕。

代码实现

/**
 * @author chenzhiyuan
 * @date 2019-10-20 18:12
 */
public class HuffmanTree {
    private BiTNode root;

    /**
     * 把nums构建成一个赫夫曼树
     *
     * @param nums
     */
    public void buildHuffmanTree(int[] nums) {
        // 将nums放到一个list中
        List<BiTNode> nodes = new ArrayList<>(10);
        for (int num : nums) {
            BiTNode node = new BiTNode();
            node.value = num;
            nodes.add(node);
        }
        // 只要nodes中的元素个数大于1，说明数据都还没有处理完
        while (nodes.size() > 1) {
            // 排序
            Collections.sort(nodes);
            // 取出最小的两个子树，组成一个新的子树，并加入到nodes中，参与下一轮的排序
            BiTNode left = nodes.get(0);
            BiTNode right = nodes.get(1);
            BiTNode parent = new BiTNode(left, left.value + right.value, right);
            nodes.remove(left);
            nodes.remove(right);
            nodes.add(parent);
        }
        // 最后nodes中剩下的这个节点就是赫夫曼树的根节点
        root = nodes.get(0);
    }

    /**
     * 前序遍历
     */
    public void preOrderTraverse(BiTNode node) {
        if (node == null) {
            return;
        }
        System.out.println(node.value);
        preOrderTraverse(node.lChild);
        preOrderTraverse(node.rChild);
    }

    /**
     * 二叉链表的节点定义，实现Comparable接口定义排序规则
     */
    private class BiTNode implements Comparable<BiTNode> {
        private BiTNode lChild;
        private Integer value;
        private BiTNode rChild;

        public BiTNode() {
        }

        public BiTNode(BiTNode lChild, Integer value, BiTNode rChild) {
            this.lChild = lChild;
            this.value = value;
            this.rChild = rChild;
        }

        @Override
        public int compareTo(BiTNode o) {
            return this.value - o.value;
        }
    }

    public static void main(String[] args) {
        int[] nums = new int[]{8,5,1,20,10,3,1};
        HuffmanTree huffmanTree = new HuffmanTree();
        huffmanTree.buildHuffmanTree(nums);
        // 前序遍历一把，构建好的赫夫曼树如图3所示
        huffmanTree.preOrderTraverse(huffmanTree.root);
    }
}

控制台输出

48
20
28
10
5
5
2
1
1
3
18
8
10

图3：由 8,5,1,20,10,3,1 构建好的赫夫曼树