哈夫曼树

哈夫曼树（赫夫曼树/霍夫曼树）是最优二叉树，树的带权路径最短，即WPL（weighted path leanght），说哈夫曼树之前先说几个概念：
1.路径：一个节点到达孩子节点和孙子节点的路径

举例：三层L的树（算上根节点），从根节点到L层节点的路径为L-1=2 

2.路径长度：
权：节点的值
节点的带权路径：根节点到该节点的路径*值
举例：

三层树，叶子结点的值为10，那么这个节点的带权路径为10*2(路径)=20

树的带权路径长度：所有的叶子结点的值和 带权路径长度 之和WPL（weighted path leanght）
权值越大的节点距离树根越近的二叉树才是最优二叉树即哈夫曼树。
来个图：

代码实现：

	package tree;

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

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


    }

    //遍历树的方法
    public static void preOrder(Node node){
        if(node!=null) node.preOrder();
        else System.out.println("空树");

    }

    //创建赫夫曼树方法
    public static Node createHuffmanTree(int[] arr) {
        Node n = null;
        //把元素构建成node放入集合
        List<Node> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) list.add(new Node(arr[i]));

        //循环处理
        while (list.size() > 1) {
            Collections.sort(list);
            //取出根节点最小的两棵二叉树
            Node left = list.get(0);
            Node right = list.get(1);
            //构建新的二叉树
            Node parent = new Node(left.val + right.val);
            //节点赋值
            parent.left = left;
            parent.right = right;
            //从集合里删除创建过的元素
            list.remove(left);
            list.remove(right);
            //将新的二叉树++集合
            list.add(parent);


        }


        return list.get(0);


    }


}

class Node implements Comparable<Node> {
    int val;
    Node left;
    Node right;

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

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

    public void preOrder(){
        System.out.println(this);
        if(this.left!=null)this.left.preOrder();
        if(this.right!=null)this.right.preOrder();
    }




    @Override
    public int compareTo(Node node) {
        //升序
        return this.val - node.val;
    }
}

打印结果（前序遍历）：