Java中的哈夫曼树

package com.ietree.basic.datastructure.tree;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

/**
 * Created by ietree
 * 2017/5/1
 */
public class HuffmanTree {

    public static class Node<E> {
        E data;
        double weight;
        Node leftChild;
        Node rightChild;

        public Node(E data, double weight) {
            this.data = data;
            this.weight = weight;
        }

        public String toString() {
            return "Node[data=" + data + ", weight=" + weight + "]";
        }
    }

    public static void main(String[] args) {

        List<Node> nodes = new ArrayList<Node>();
        nodes.add(new Node("A", 40));
        nodes.add(new Node("B", 8));
        nodes.add(new Node("C", 10));
        nodes.add(new Node("D", 30));
        nodes.add(new Node("E", 10));
        nodes.add(new Node("F", 2));

        Node root = HuffmanTree.create(nodes);
        System.out.println(breadthFirst(root));

    }

    /**
     * 构造哈夫曼树
     *
     * @param nodes 节点集合
     * @return 构造出来的哈夫曼树的根节点
     */
    private static Node create(List<Node> nodes) {

        // 只要nodes数组中还有2个以上的节点
        while (nodes.size() > 1) {
            quickSort(nodes);
            // 获取权值最小的两个节点
            Node left = nodes.get(nodes.size() - 1);
            Node right = nodes.get(nodes.size() - 2);
            // 生成新节点，新节点的权值为两个子节点的权值之和
            Node parent = new Node(null, left.weight + right.weight);
            // 让新节点作为权值最小的两个节点的父节点
            parent.leftChild = left;
            parent.rightChild = right;
            // 删除权值最小的两个节点
            nodes.remove(nodes.size() - 1);
            nodes.remove(nodes.size() - 1);
            // 将新生成的父节点添加到集合中
            nodes.add(parent);
        }
        // 返回nodes集合中唯一的节点，也就是根节点
        return nodes.get(0);
    }

    // 将指定数组的i和j索引处的元素交换
    private static void swap(List<Node> nodes, int i, int j) {
        Node tmp;
        tmp = nodes.get(i);
        nodes.set(i, nodes.get(j));
        nodes.set(j, tmp);
    }

    // 实现快速排序算法，用于对节点进行排序
    private static void subSort(List<Node> nodes, int start, int end) {

        // 需要排序
        if (start < end) {
            // 以第一个元素作为分界值
            Node base = nodes.get(start);
            // i从左边搜索，搜索大于分界值的元素的索引
            int i = start;
            // j从右边搜索，搜索小于分界值的元素的索引
            int j = end - 1;
            while (true) {
                // 找到大于分界值的元素的索引，或者i已经到了end处
                while (i < end && nodes.get(++i).weight >= base.weight) ;
                // 找到小于分界值的元素的索引，或者j已经到了start处
                while (j > start && nodes.get(--j).weight <= base.weight) ;
                if (i < j) {
                    swap(nodes, i, j);
                } else {
                    break;
                }
            }
            swap(nodes, start, j);
            // 递归左子树序列
            subSort(nodes, start, j - 1);
            // 递归右子树序列
            subSort(nodes, j + 1, end);
        }
    }

    public static void quickSort(List<Node> nodes) {
        subSort(nodes, 0, nodes.size() - 1);
    }

    // 广度优先遍历
    public static List<Node> breadthFirst(Node root) {

        Queue<Node> queue = new ArrayDeque<Node>();
        List<Node> list = new ArrayList<Node>();
        if (root != null) {
            // 将根元素入“队列”
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            // 将该队列的“队尾”的元素添加到List中
            list.add(queue.peek());
            Node p = queue.poll();
            // 如果左子节点不为null，将它加入“队列”
            if (p.leftChild != null) {
                queue.offer(p.leftChild);
            }
            // 如果右子节点不为null，将它加入“队列”
            if (p.rightChild != null) {
                queue.offer(p.rightChild);
            }
        }
        return list;

    }

}