哈夫曼树【Java实现】

一、相关概念

1. 路径和路径长度

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

2. 节点的权及带权路径长度

如果将树中节点赋给一个有着某种意义的数值，则这个数值称为该节点的权。
从根节点到该节点之间的路径长度与该节点的权的乘积称为该节点的带权路径长度。

3. 树的带权路径长度

树所有叶子节点的带权路径之和为树的带权路径长度，记为WPL（Weighted Path Length）。

二、哈夫曼树

1. 概念

给定 n 个权值作为 n 个叶子节点，构造一棵二叉树，如果该树的带权路径长度达到最小（权值越大的节点离根节点越近），则称这样的树为哈夫曼树。

图示：

2. 构建哈夫曼树

1. 思路

1. 将给定的序列从小到大排序，每个数据都是一个节点，可以将每个节点看成是一棵最简单的二叉树（即没有子节点）
2. 取出根节点权值最小的两棵二叉树
3. 组成一棵新的二叉树，该树根节点的权值是前面两棵二叉树根节点权值的和
4. 再将这棵新的二叉树，以根节点的权值再次排序
5. 不断重复 1 - 2 - 3 - 4 的步骤，直到序列中所有数据都被处理，即可得到一棵哈夫曼树

思路图示：

2. 代码实现

代码如下：

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


    /**
     * 调用节点类中的先序遍历方法进行先序遍历
     *
     * @param root 先序遍历根节点
     */
    public static void preOrder(Node root) {
        if (root == null) {
            System.out.println("当前二叉树为空，无法进行先序遍历！");
        } else {
            //调用节点类中的先序遍历方法进行先序遍历
            root.preOrder();
        }
    }

    /**
     * 构建哈夫曼树
     *
     * @param arr 待构建哈夫曼树的无序序列
     * @return 构建好的哈夫曼树根节点
     */
    public static Node huffmanTree(int[] arr) {
        //初始化一个 list 集合用来保存节点
        List<Node> nodes = new ArrayList<>();
        //遍历数组，并将其元素作为权值创建节点，保存在 list 集合中
        for (int value : arr) {
            nodes.add(new Node(value));
        }
        //当 list 集合中只剩下一个元素时，哈夫曼树创建成功
        while (nodes.size() > 1) {
            //调用 Collections 工具类的排序方法，对节点集合排序（从小到大）
            Collections.sort(nodes);
            //获取排序后集合中的前两个元素（权值最小的两个节点）
            Node leftNode = nodes.get(0);
            Node rightNode = nodes.get(1);
            //以权值最小的两个节点分别作为左子节点和右子节点
            //创建新的二叉树，其根节点权值为其子节点权值之和
            Node root = new Node(leftNode.getValue() + rightNode.getValue());
            root.setLeft(leftNode);
            root.setRight(rightNode);
            //从集合中移除已经创建完的两棵二叉树
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            //将新的二叉树放入集合中
            nodes.add(root);
        }
        //返回集合中最后剩下节点（即为哈夫曼树根节点）
        return nodes.get(0);
    }
}

/**
 * 节点类
 * 实现 Comparable 接口，方便存入集合类排序
 */
class Node implements Comparable<Node> {
    //节点权值
    private int value;
    //左子节点
    private Node left;
    //右子节点
    private Node right;

    /**
     * 构造方法
     * 通过传入权值创建新的节点
     *
     * @param value 传入节点权值
     */
    public Node(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public void setRight(Node right) {
        this.right = right;
    }

    /**
   	 * 实现从小到大的排序
   	 * 
     * @param o 被比较的节点
     * @return 如果等于 0，则两个节点权值相等
     *         如果小于 0，则当前节点权值小于传入节点权值
     *         如果大于 0，则当前节点权值大于传入节点权值
     */
    @Override
    public int compareTo(Node o) {
        return this.value - o.value;
    }

    /**
     * 先序遍历二叉树
     */
    public void preOrder() {
        System.out.print(this.value + "\t");
        if (this.left != null) {
            this.left.preOrder();
        }
        if (this.right != null) {
            this.right.preOrder();
        }
    }
}

测试结果：

67	29	38	15	7	8	23	10	4	1	3	6	13