哈夫曼树学习------java实现

一、基本介绍

给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的**带权路径长度(WPL)**达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)

**路径：**在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径
路径长度： 通路中分支的数目
**权值：**树中结点具有的某种含义的数值
**带权路径长度：**从根结点到该结点之间的路径长度与该结点的权值的乘积
树的带权路径长度：即一个树的所有叶子节点的带权路径长度之和（WPL），权值越大的节点距离根节点越近的二叉树为最优二叉树（哈夫曼树）

二、创建HuffmanTree的基本步骤

1.将给定的n个数据从小到大排序，将每个节点看做是一个最简单的二叉树
2.选取两个根节点最小的二叉树，组成一个新的二叉树，新的二叉树的根节点为两个二叉树的权值的和，两个二叉树为新的二叉树的左右节点
3.将原来的两个二叉树删除掉，再将新的二叉树加入到原来的数据集合中，重复以上步骤，最终得到的就是一个哈夫曼树

三、过程演示

如：给定一组数据：{3,44,22,13,12,21，1}
第一步： 将最小的 1 和 3两个选出来组成新的二叉树，根节点为两个数据权值的和：4

第二步：将新的节点4加入到原来的数据中：{44,22,13,12,21,4}
继续选取权值最小的两个节点：4,12，组成新的节点 -> 16

第三步：将新的节点16加入到原来的数据中：{44,22,13,16,21}
继续选取权值最小的两个节点：13,16，组成新的节点 -> 29

第四步：将新的节点29加入到原来的数据中：{44,22,29,21}
继续选取权值最小的两个节点：21,22，组成新的节点 ->43

第五步：将新的节点43加入到原来的数据中：{44,29,43}
继续选取权值最小的两个节点：29,43，组成新的节点 ->72

最后再和44组合

四、代码实现

4.1 定义节点类

实现Comparable方便根据权值排序

class Node implements Comparable<Node>{
    /**
     * 节点权值
     */
    int value;

    /**
     * 左子节点
     */

    Node left;
    /**
     * 右子节点
     */
    Node right;

    public Node (int value){
        this.value=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 +
                '}';
    }

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

4.2创建HuffmanTree

public static Node createHuffmanTree(int[] arr){
        //1.将arr的构建成Node集合
        List<Node> nodes=new ArrayList<>();
        for (int value:arr){
            nodes.add(new Node(value));
        }
        //2.从小到大排序，结束条件为剩余节点为1个，因为创建成哈夫曼树后只剩下一个根节点
        while (nodes.size()>1){
        	//从小到大排序
            Collections.sort(nodes);

            //3.取出权值最小的节点
            Node left=nodes.get(0);
            Node right=nodes.get(1);
            //构建新的二叉树
            Node parentNode=new Node(left.value+right.value);
            parentNode.left=left;
            parentNode.right=right;
            //删除处理过的二叉树
            nodes.remove(left);
            nodes.remove(right);
            //新的二叉树添加到nodes中
            nodes.add(parentNode);
        }
		//返回根节点
        return nodes.get(0);


    }

测试：

 int[] arr={3,44,22,13,12,21,1};
        Node huffmanTree = createHuffmanTree(arr);
        huffmanTree.preOrder();

前序遍历结果：

Node{value=116}
Node{value=44}
Node{value=72}
Node{value=29}
Node{value=13}
Node{value=16}
Node{value=4}
Node{value=1}
Node{value=3}
Node{value=12}
Node{value=43}
Node{value=21}
Node{value=22}