哈夫曼树

8 哈夫曼树

哈夫曼（Huffman）树又称为最优二叉树，它是一种带权路径长度最短的树，在信息检索中非常有用。本文主要介绍哈夫曼树的概念、哈夫曼编码、哈夫曼树的实现。

8.1 哈夫曼树的概念

1. 节点之间的路径长度：从一个节点到另外一个节点之间的分支数量称为两个节点之间的路径长度
2. 树的路径长度：从树的根节点到每一个节点的路径长度之和
3. 节点的带权路径长度：该节点到根节点的路径长度与节点山权的乘积
4. 树的带权路径长度：树中所有叶子节点的带权路径长度之和
   带权路径最小的二叉树被称为哈夫曼树或者最优二叉树。

哈夫曼树的一个重要的定理：

对于具有n个叶子节点的哈夫曼树，一共需要2 * n -1个节点。

对于二叉树来说，一共有三种节点，即度数为2的节点、度数为1的节点、度数为0的节点，而哈夫曼树的非叶子节点都是由两个节点合并产生，所以不会产生度数为1的节点。而生成的非叶子节点的个数为叶子节点的个数-1，因此具有n个叶子节点的哈夫曼树一共需要2*n-1个节点。

8.2 哈夫曼树的构造

哈夫曼树的构造方法如下：

1. 根据给定的n 个权值{w1,w2,……..,wn}构造n棵二叉树的集合F={T1,T2…….,Tn}，F集合中每棵二叉树只有一个节点
2. 选取F集合中两个权值最小的根节点作为二叉树的左右子节点，构造新的二叉树，将新的二叉树的根节点的权值设为左右子树上根节点的权值之和
3. 将新的二叉树添加到F集合中，并且删除F中被（2）选中的两棵二叉树
4. 重复（2）和（3），直到F中只剩下一棵二叉树，这课二叉树就是哈夫曼树。

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

public class HuffmanTree {

    /**
     * 哈夫曼树的节点
     * @author Administrator
     *
     * @param <E>
     */
    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;
        }

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

    /**
     * 广度优先遍历
     * @param root
     * @return
     */
    private static List<Node> breadthFirst(Node root) {

        Queue<Node> queue = new ArrayDeque<Node>();
        List<Node> list = new ArrayList<Node>();
        if(root != null){
            //将根元素如队列
            queue.offer(root);
        }
        //将队列的元素通过queue过滤
        while(!queue.isEmpty()){
            list.add(queue.peek());
            Node p = queue.poll();
            //如果左子节点不为空，将其加入队列
            if(p.leftChild != null){
                queue.offer(p.leftChild);
            }
            //如果节点的右子节点不为空
            if(p.rightChild != null){
                queue.offer(p.rightChild);
            }
        }
        return list;
    }

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

        //只要数组中含有两个以上的节点，持续合并
        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);
        }
        //返回集合中唯一的节点，即根节点
        return nodes.get(0);
    }

    /**
     * 对节点的元素进行快速排序
     * @param nodes 节点的集合
     */
    private static void quickSort(List<Node> nodes) {
        subSort(nodes,0,nodes.size() - 1);
    }

    /**
     * 快速排序，对节点进行排序
     * @param nodes
     * @param start
     * @param end
     */
    private static void subSort(List<Node> nodes, int start, int end) {

        //需要排序
        if(start < end){
            //以第一个元素作为分解值
            Node base = nodes.get(0);
            //从左边搜索，搜索权值大于分界值的元素
            int i = start;
            //从右边搜索，搜索小于分界值的元素
            int j = end + 1;
            while(true){
                //找到大于分界值的元素
                while(i < end && nodes.get(++i).weight >= base.weight);
                //找到小于分界值的元素
                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);
            }
        }
    }

    /**
     * 交换元素
     * @param nodes
     * @param i
     * @param j
     */
    private static void swap(List<Node> nodes, int i, int j) {

        Node tem = nodes.get(i);
        nodes.set(i, nodes.get(j));
        nodes.set(j, tem);
    }
    public static void main(String[] args) {
        List<Node> nodes = new ArrayList<Node>();
        nodes.add(new Node("A",40.0));
        nodes.add(new Node("B",8.0));
        nodes.add(new Node("C",10.0));
        nodes.add(new Node("D",30.0));
        nodes.add(new Node("E",10.0));
        nodes.add(new Node("F",2.0));

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

8.3 哈夫曼树的构造编码简介

哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码(有时也称为霍夫曼编码)。

哈夫曼编码有一个规律：假设有N个叶子节点需要编码，最终得到的哈夫曼树一定有N层，哈夫曼编码得到的二进制编码的最大长度为N-1.