huffman树（java）

huffman树

huffman树是带权路径长度最短的树，权值较大的节点离根很近。

路径长度：根节点层数为1，从根节点到第L层节点的路径长度为L-1

带权路径长度：从根节点到该节点之间的路径长度与该节点

__树的带权路径长度__为所有叶子节点的带权路径长度之和，称为WPL（weighted path length），WPL最小就是huffman树。

权值越大的节点离根节点越近的二叉树才是最优二叉树。

huffmanTree思路分析

1. 从小到大进行排序，每个节点可以看成是一颗最简单的二叉树
2. 取出根节点权值最小的两个二叉树，组成一颗新二叉树，新二叉树的根节点是两个二叉树根节点权的和
3. 将新的二叉树以根节点的权值大小，再次排序。
4. 不断重复上述过程，直到所有数据都被处理，即可得到huffmanTree

代码思路：

1. 将数组传入函数中，并遍历数组，将数组的每个元素构成一个Node，组成一个ArrayList nodes，
2. while循环，当nodes.size>1时：
   1. 将nodes排序
   2. 取出根节点权值最小的两个树
   3. 构建一个新的二叉树（要记得设置新的二叉树的指针指向上面取出的两个二叉树）
   4. 从ArrayList中删除处理过的两个节点
   5. 将新的树加入nodes中
3. 返回huffman树的root节点

package com.tree;

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

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

    public static void preOrder(Node root) {
        if (root != null) {
            root.preOrder();
        } else {
            System.out.println("null root!");
        }
    }

    public static Node createHuffmanTree(int[] arr) {
        List<Node> nodes = new ArrayList<Node>();
        for (int value : arr) {
            nodes.add(new Node(value));
        }

        while (nodes.size() > 1) {
            Collections.sort(nodes);
            Node newLeft = nodes.get(0);
            Node newright = nodes.get(1);
            Node parent = new Node(newLeft.value + newright.value);
            parent.left = newLeft;
            parent.right = newright;
            nodes.remove(newLeft);
            nodes.remove(newright);
            nodes.add(parent);
        }
        //这时候，nodes中仅剩一个元素
        return nodes.get(0);

    }
}


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

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

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

    @Override
    public String toString() {
        return "Node[value=" + value + "]";
    }

    @Override
    public int compareTo(Node o) {
        return this.value - o.value;
    }

}