29-赫夫曼树

1. 几个重要概念

1.1 路径和路径长度

• 路径：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路；
• 路径长度：通路中分支的数目；若规定根结点的层数为 1，则从根结点到第 L 层结点的路径长度为 L-1。

1.2 结点的权及带权路径长度

• 结点的权：将树中结点赋给一个有着某种含义的数值；
• 带权路径长度 (Weighted Path Length，简称 WPL)
  • 结点的带权路径长度：从 {根结点到该结点之间的路径长度} 与 {该结点的权} 的乘积；
  • 树的带权路径长度：树的带权路径长度规定为 {所有叶子结点} 的带权路径长度之和。

1.3 赫夫曼树

• 给定 n 个权值作为 n 个叶子结点，构造一棵二叉树，若该树的带权路径长度 WPL 达到最小 ，则称这样的二叉树为最优二叉树，也称为赫夫曼树(Huffman Tree)。
• WPL 最小的树就是赫夫曼树
• 举例 // 让权值越大的结点离根结点越近，才能达到 WPL 越小
  

2. 案例 - 构建赫夫曼树

Quiz：将数列 {13, 7, 8, 3, 29, 6, 1} 转成一颗赫夫曼树。

2.1 步骤

1. 从小到大进行排序，将每一个数据看作一个结点， 每个结点又可以看成是一颗最简单的二叉树；
2. 取出根结点权值最小的两颗二叉树，组成一颗新的二叉树，该新的二叉树的根结点的权值是前面两颗二叉树根结点权值的和；
3. 再将这颗新的二叉树，以根结点的权值大小再次排序；
4. 不断重复 {2-3} 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树。

2.2 图解

a few years later...

2.3 代码实现

public class HuffmanTreeDemo {
    public static void main(String[] args) {
        int[] arr = {13, 7, 8, 3, 29, 6, 1};
        HuffmanTree huffman = new HuffmanTree(arr);
        System.out.println(huffman.root);
        huffman.root.preOrder();
    }
}

class HuffmanTree {
    public Node root;

    public HuffmanTree(int[] arr) {
        ArrayList<Node> nodes = new ArrayList<>();
        // 1. 遍历数组, 将数组元素封装成 Node, 将其放入 ArrayList
        for (int val : arr)
            nodes.add(new Node(val));
        // 2. 干掉 2 个就加回来 1 个, 直到只剩下 1 个, 那便是赫夫曼树的根结点
        while (nodes.size() > 1) {
            // 2.1 排序
            Collections.sort(nodes);
            // 2.2 取权值最小的两颗二叉树
            Node leftNode = nodes.get(0);
            Node rightNode = nodes.get(1);
            // 2.3 构建一颗新的二叉树
            Node parent = new Node(leftNode.value + rightNode.value);
            parent.left = leftNode;
            parent.right = rightNode;
            // 2.4 从 ArrayList 中删除处理过的二叉树
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            // 2.5 将新二叉树添加到 ArrayList 中
            nodes.add(parent);
        }
        this.root = nodes.get(0);
    }

    public void preOrder() {
        if (root != null) root.preOrder();
        else System.out.println("空树");
    }
}

class Node implements Comparable<Node> {
    public int value; // 结点权值
    public Node left;
    public Node right;

    public Node(int value) {
        this.value = value;
    }

    public void preOrder() {
        System.out.print(this.value + " ");
        if (this.left != null)
            this.left.preOrder();
        if (this.right != null)
            this.right.preOrder();
    }

    @Override
    public int compareTo(Node node) {
        return this.value - node.value; // 从小到大排序
    }

    @Override
    public String toString() {
        return "[value=" + value + "]";
    }
}