(哈夫曼树)HuffmanTree的java实现

参考自：http://blog.csdn.net/jdhanhua/article/details/6621026

哈夫曼树

哈夫曼树（霍夫曼树）又称为最优树.

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

2、结点的权及带权路径长度
若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。

3、树的带权路径长度
树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL。

代码一（树节点）：

/**

 * 树节点

 *

 * @author pang

 *

 * @param <T>

 */

public class Node<T> implements Comparable<Node<T>> {

    private T data;

    private int weight;

    private Node<T> left;

    private Node<T> right;

    public Node(T data, int weight) {

        this.data = data;

        this.weight = weight;

    }

    @Override

    public String toString() {

        // TODO Auto-generated method stub

        return "data:" + this.data + ",weight:" + this.weight + ";   ";

    }

    @Override

    public int compareTo(Node<T> o) {

        // TODO Auto-generated method stub

        if (o.weight > this.weight) {

            return 1;

        } else if (o.weight < this.weight) {

            return -1;

        }

        return 0;

    }

    public T getData() {

        return data;

    }

    public void setData(T data) {

        this.data = data;

    }

    public int getWeight() {

        return weight;

    }

    public void setWeight(int weight) {

        this.weight = weight;

    }

    public Node<T> getLeft() {

        return left;

    }

    public void setLeft(Node<T> left) {

        this.left = left;

    }

    public Node<T> getRight() {

        return right;

    }

    public void setRight(Node<T> right) {

        this.right = right;

    }

}

代码二（HuffmanTree）:

import java.util.ArrayList;

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

import java.util.Queue;

public class HuffmanTree<T> {

    public static <T> Node<T> createTree(List<Node<T>> nodes) {

        while (nodes.size() > 1) {

            Collections.sort(nodes);

            Node<T> left = nodes.get(nodes.size() - 1);

            Node<T> right = nodes.get(nodes.size() - 2);

            Node<T> parent = new Node<T>(null, left.getWeight()

                    + right.getWeight());

            parent.setLeft(left);

            parent.setRight(right);

            nodes.remove(left);

            nodes.remove(right);

            nodes.add(parent);

        }

        return nodes.get(0);

    }

    public static <T> List<Node<T>> breath(Node<T> root) {

        List<Node<T>> list = new ArrayList<Node<T>>();

        Queue<Node<T>> queue = new LinkedList<>();

        queue.add(root);

        while (!queue.isEmpty()) {

            Node<T> pNode = queue.poll();

            list.add(pNode);

            if (pNode.getLeft() != null) {

                queue.add(pNode.getLeft());

            }

            if (pNode.getRight() != null) {

                queue.add(pNode.getRight());

            }

        }

        return list;

    }

}

测试类：

import java.util.ArrayList;

import java.util.List;

public class HuffmanTreeTest {

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        List<Node<String>> nodes = new ArrayList<Node<String>>();

        nodes.add(new Node<String>("b", 5));

        nodes.add(new Node<String>("a", 7));

        nodes.add(new Node<String>("d", 2));

        nodes.add(new Node<String>("c", 4));

        Node<String> root = HuffmanTree.createTree(nodes);

        System.out.println(HuffmanTree.breath(root));

    }

}