哈夫曼树

哈夫曼树

wpl带权路径长度最小的树

• 二叉树树的思想：

1. 创建节点，
2. 创建二叉树，
3. 其中二叉树的操作都定义在节点类里面，二叉树类里调用这些方法，其中定义方法的时候以一个节点为二叉树递归定义。因为一个节点就是一颗二叉树。

---

package binaryTree.huffmanTree;

import java.util.*;

/**
 * @Author: 白雄雄
 * @Date: 2019/9/13 16:30
 */
public class HuffmanTree {

    public static void main(String[] args) {
        int[] arrays = {13,7,4,8,29,1,5,6};
        Node huffmanTree = createHuffmanTree(arrays);
        //对生成的哈夫曼树进行遍历
        Node.preOrder(huffmanTree);
    }

    /**
     * 创建哈夫曼树
     * @param arrays
     */
    public static Node createHuffmanTree(int[] arrays) {
        List nodes = new ArrayList<Node>();
        for (int i = 0; i < arrays.length; i++) {
            nodes.add(new Node(arrays[i]));
        }
        //升序排列节点
        Collections.sort(nodes);
        //最后只剩root节点
        while (nodes.size() > 1) {
            //第一个节点一定最小作为左子树
            Node leftNode = (Node) nodes.get(0);
            Node rightNode = (Node) nodes.get(1);
            //构造父节点
            Node node = new Node(leftNode.getValue() + rightNode.getValue());
            //设置左右子树
            node.setLeftNode(leftNode);
            node.setRightNode(rightNode);
            //删除掉构建完的子树
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            nodes.add(node);
            Collections.sort(nodes);
        }
        return (Node) nodes.get(0);
    }
}

/**
 * 创建哈夫曼树节点
 */
class Node implements Comparable<Node> {

    private int value;
    //左子树
    private Node leftNode;
    //又子树
    private Node rightNode;

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

    public void setValue(int value) {
        this.value = value;
    }

    public void setLeftNode(Node leftNode) {
        this.leftNode = leftNode;
    }

    public void setRightNode(Node rightNode) {
        this.rightNode = rightNode;
    }

    public int getValue() {
        return value;
    }

    public Node getLeftNode() {
        return leftNode;
    }

    public Node getRightNode() {
        return rightNode;
    }

    /**
     * 对哈夫曼树升序排序使用
     * @param o
     * @return
     */
    @Override
    public int compareTo(Node o) {
        return this.value - o.value;
    }

    /**
     * 对生成的哈夫曼树进行前序遍历
     * @param root
     */
    public static void preOrder(Node root) {
        if (root == null) {
            System.out.println("哈夫曼树为空");
            return;
        }
        Node node = root;
        System.out.println(node.getValue());
        if (node.getLeftNode() != null) {
            preOrder(node.getLeftNode());
        }
        if (node.getRightNode() != null) {
            preOrder(node.getRightNode());
        }
    }
}