datastructure：霍夫曼树

树的带权路径长度：所有叶子结点的带权路径长度之和，记为WPL(weighted path length)
权值越大的结点离根结点越近的二叉树才是最优二叉树
WPL最小的是哈夫曼树

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class HuffmanTree {
    public static void main(String[] args) {
        int[] arr = {13, 7, 8, 3, 29, 6, 1};
        HuffmanNode root = huffmanTree(arr);
        preOrder(root);
    }

    /**
     * 创建哈夫曼树的方法
     * @param arr 存放结点权值的数组
     * @return 哈夫曼树的根结点
     */
    public static HuffmanNode huffmanTree(int[] arr) {
        List<HuffmanNode> huffmanNodes = new ArrayList<>();
        // 遍历arr数组，将数组中每个元素构成HuffmanNode放入ArrayList中
        for (int value : arr) {
            huffmanNodes.add(new HuffmanNode(value));
        }

        while (huffmanNodes.size() > 1) {
            // 从小到大排序
            Collections.sort(huffmanNodes);

            // 取出根节点权值最小的结点(二叉树)
            HuffmanNode leftHuffmanNode = huffmanNodes.get(0);
            // 取出根节点权值次小的结点(二叉树)
            HuffmanNode rightHuffmanNode = huffmanNodes.get(1);

            // 构建一颗新的二叉树
            HuffmanNode parentHuffmanNode = new HuffmanNode(leftHuffmanNode.value + rightHuffmanNode.value);
            parentHuffmanNode.left = leftHuffmanNode;
            parentHuffmanNode.right = rightHuffmanNode;

            // 从ArrayList中删除处理过的二叉树
            huffmanNodes.remove(leftHuffmanNode);
            huffmanNodes.remove(rightHuffmanNode);

            // 将parentHuffmanNode加入到HuffmanNodes
            huffmanNodes.add(parentHuffmanNode);
        }
        // 返回哈夫曼树的root结点
        return huffmanNodes.get(0);
    }

    // 前序遍历
    public static void preOrder(HuffmanNode root) {
        if (root != null) {
            root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历!");
        }
    }
}

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

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

    @Override
    public int compareTo(HuffmanNode o) {
        // 表示升序
        return this.value - o.value;
    }

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

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