数据结构——赫夫曼树

基本介绍：

• 1）、给定n个权值作为n个叶子节点，构造一棵二叉树，若该树的带权路径长度（wpl）达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树（Huffman Tree)，有的译为霍夫曼树。
• 2）、赫夫曼树是带权路径长短最短的树，权值较大的节点离根较近。

重要概念：

• 1）、路径：在一棵树中，从一个节点往下可以达到的孩子或孩子节点之间的通路，称为路径。
• 2）、路径长度：通路中分支的数目称为路径长度。若规定根节点的层数为1，则从根节点到第L层节点的路径长度为L-1。
• 3）、节点的权：若将树中的节点赋给一个有着某种含义的数值，则这个数值称为该节点的权。
• 4）、节点的带权路径长度：从根节点到该节点之间的路径长度与该节点权的乘积。
• 5）、树的带权路径长度：树的带权路径长度规定为所有叶子节点的带权路径长度之和，记为WPL（weighted path length），权值越大的节点离根节点越近的二叉树才是最优二叉树。
• 6）、WPL最小的就是赫夫曼树。
  

基本思路：

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

举例图解：

示例代码

public class HuffmanTreeDemo {
    public static void main(String[] args) {
        int[] arr = {13, 7, 8, 3, 29, 6, 1};
        Node node = creatHuffmanTree(arr);
        preOrder(node);
    }

    private static Node creatHuffmanTree(int[] arr) {
        List<Node> nodeList = getNodeList(arr);
        while (nodeList.size() > 1) {
            Collections.sort(nodeList);
            /*从小到大取第一、二个元素，如果是从大到小的排序，就取第size-1、size-2个元素*/
            Node leftNode = nodeList.get(0);
            Node rightNode = nodeList.get(1);
            Node parent = new Node(leftNode.getValue() + rightNode.getValue());
            parent.setLeft(leftNode);
            parent.setRight(rightNode);
            nodeList.remove(leftNode);
            nodeList.remove(rightNode);
            nodeList.add(parent);
        }
        return nodeList.get(0);
    }

    private static List<Node> getNodeList(int[] arr) {
        if (arr.length == 0) {
            return Lists.newArrayList();
        }
        List<Node> nodes = Lists.newArrayList();
        for (int item : arr) {
            nodes.add(new Node(item));
        }
        return nodes;
    }

    private static void preOrder(Node root) {
        if (root == null) {
            System.out.println("这是一棵空的赫夫曼树");
            return;
        }
        root.preOrder();
    }

}

@Data
class Node implements Comparable<Node> {
    private int value;

    private Node left;

    private Node right;

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

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

    /**
     * 前序遍历
     */
    public void preOrder() {
        System.out.println(this);
        if (this.left != null) {
            this.left.preOrder();
        }
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }
}