huffman coding

继上一节树和二叉树的介绍，本文详细介绍一种特殊的二叉树，叫huffman tree（赫夫曼树）。如果读者是初学者的话，请思考几个问题。

为什么需要这样一种二叉树？这种数据结构有什么优点？如何实现？应用实例？

huffman coding

大家都知道huffman树，却很少提到huffman编码，但huffman编码是介绍huffman树绕不过的一道坎。

首先，说说编码的事。就像谍战片中常出现的编解码问题，没份电报通过编码加密之后发出去，收到电报的一份用约定好的解码规则将电报内容还原，这不仅是一种信息的传递方式，还有传递安全的重要意义。抛开安全不说，回到最初的编码问题。那么人们对编码最初的要求有哪些？

• 译码结果唯一，无歧义
• 编码后的电文尽可能短

就ABCD编码而言，你可能会想到编码成0、00、1、01，虽然编码是短了，但译码结果却不唯一了，比如“0000”就可以译为“AAAA”、“BB”、“AAB”、“BAA”、“ABA”多种电文，显然这种编码是不合格的。能保证任意字符的编码都不是其他字符编码的前缀的编码，就叫作前缀编码。

借助二叉树编码，如何确保译码结果唯一？

如果非叶子节点保存字符信息的话，那么就会出现歧义的现象。相反地，只要保证只在叶子节点上存储字符信息，就可以避免这种现象。

定义叶子的编码对应规则：从根节点出发，选择左子树代表编码0，右子树编码1，那么从根节点到叶子的过程中进行的一系列选择唯一对应了叶子的编码。还是以ABCD编码为例说明，图如下：

借助二叉树编码，如何使得电文最短？

在满足条件一的情况下，考虑电文最短问题。不同字符出现的概率不同，电文最短问题，就是在保证为前缀编码的前提下，使得出现频率越高的字符对应的编码越短。假设字符出现的概率为w_i,其对应的叶子节点到根的路径长度为l_i,则求min∑w_il_i  ，也叫作带权路径长度。

huffman树就是这样一种数据结构，可以满足以上要求。即概率越大的字符叶子离节点越近，且为前缀编码。为何满足从其构造过程可见一斑。构造过程如下：

1. 构造两个队列A和B，分别存放叶子节点和子树。
2. 选择A和B中概率最小的两个节点m和n
3. 构造一个新的二叉树o，新子树的概率为m和n的概率之和，m和n为其左右子树
4. 将o加入B中，判断是否满足A为空且B中只有一颗子树，若不满足返回步骤2，满足进入步骤5
5. 返回B中唯一的一颗子树作为huffman树

由其构造过程可知，huffman树是严格二叉树，也即其节点只有两个孩子或者没有孩子。又忍不住问两个问题：

为什么huffman树得是严格二叉树？

假如存在只有一个子节点的节点，那么该节点的子节点取代其之后，∑w_il_i比之前更小，这样的树不满足电文最短的要求。

huffman树唯一吗？

可能不唯一，举个例子。

图I 和 图II 为相同字符集的不同huffman树结构，可以证明，它们的带权路径长度∑w_il_i相同。

huffman coding 实现

好吧，说到这里也该给出huffman coding的实现代码了，鄙人不才，代码是自己实现的，大部分接口是《数据结构从应用到实现（JAVA）版》中设计。给出代码之前，说明几点：

1. 类中设置了七个变量，symbols[] probs[]为输入变量，存放字符集和对应的概率，要注意输入的字符集要按出现的概率大小升序排列。
2. locations存放与输入字符索引一一对应的叶子节点的引用，编码的时候特别有用不需要遍历整个树匹配字符了。
3. leaves和trees为存放叶子节点和子树的队列。leaves和trees使用的队列结构，小编电脑里只实现过循环队列，所以偷了个懒，哈哈。为什么是队列？leaves里的叶子节点自然是按照概率升序排列，只会减少不会增加，可以保证队头元素概率最小。那trees呢？因为新增的子树是由本轮两个队列概率最小的节点构成，其肯定比前轮的子树构成节点概率大，所以trees里保存的子树概率也是升序排列，也即队头子树概率最小。
4. 输出变量是huffman和codes，分别是构建好的huffman树 和 与输入字符索引一一对应的字符编码，codes作用和locations相同，是locations的生成物，使用其编码比locations更方便。
5. huffman 中叶子保存的是symbols[]里字符的索引，类型为float，非叶子节点保存的是其概率数值。
6. 其实，可以不用这么麻烦，直接定制节点数据结构就能解决，但这么编写代码无疑耦合性较低。

package com.structures.tree;

import com.structures.linear.CircularQueue;

import java.util.ArrayList;

/**
 * Created by wx on 2017/11/4.
 * Implement huffman encode and decode function.
 */
public class Huffman {
    // input variables
    private char[] symbols;
    private float[] probs;

    // process variables
    private ArrayList<BinaryTree<Float>> locations; // Save the pointer of binary node. Array is okay,too.
    private CircularQueue<BinaryTree<Float>> leaves;
    private CircularQueue<BinaryTree<Float>> subTrees;

    // output variables
    private BinaryTree<Float> huffmanTree;
    private String[] codes; // It is not necessary but useful when encode.

    // initializer of huffman tree
    public Huffman(char[] symbols, float[] probs){
        this.symbols = symbols;
        this.probs = probs;
        leaves = new CircularQueue<BinaryTree<Float>>(symbols.length);
        subTrees = new CircularQueue<BinaryTree<Float>>(symbols.length/2 + 1);
        locations = new ArrayList<BinaryTree<Float>>();
        codes = new String[symbols.length];

        if(symbols.length==0)
            throw new TreeViolationException("Error input parameters!");
        else if(symbols.length==1){ // If there are only one node, use it as root.
            buildLeaves();
            huffmanTree = leaves.dequeue();
            storeCodes();
            return;
        }

        buildLeaves();
        buildAll();
        huffmanTree = subTrees.dequeue();
        storeCodes();
    }

    // create binary tree for each input char with its index
    private void buildLeaves(){
        for(int i=0; i<symbols.length; i++){
            BinaryTree<Float> leaf = new BinaryTree<Float>();
            leaf.makeRoot((float)i);    // The binary tree saves the index of char
            leaves.enqueue(leaf);
            locations.add(leaf);
        }
    }

    // create a new binary tree with input trees
    private BinaryTree<Float> buildTree(BinaryTree<Float> first, BinaryTree<Float> second){
        BinaryTree<Float> newTree = new BinaryTree<Float>();
        newTree.makeRoot(getProb(first)+getProb(second));
        newTree.attachLeft(first);
        newTree.attachRight(second);

        return newTree;
    }

    // return the tree's prob
    private float getProb(BinaryTree<Float> tree){
        if(tree.left==null && tree.right==null)
            return probs[(int)((float)tree.getData())];
        else
            return tree.getData();
    }

    // get the trees with the lowest probability.
    // Caution! Only queue of leaves is not empty need this operation.
    private BinaryTree<Float> getMin(){
        BinaryTree<Float> first = leaves.first();
        BinaryTree<Float> second;

        if(subTrees.isEmpty()){
           return leaves.dequeue();
        }else{
            second = subTrees.first();
            if(getProb(first) > getProb(second))
                return subTrees.dequeue();
            else
                return leaves.dequeue();
        }
    }

    // create the whole huffman tree
    private void buildAll(){
        // Stage one
        while(!leaves.isEmpty()){
            BinaryTree<Float> first = getMin();
            BinaryTree<Float> second;
            if(!leaves.isEmpty())
                second = getMin();
            else
                second = subTrees.dequeue();
            subTrees.enqueue(buildTree(first, second));
        }
        // Stage two
        while (subTrees.size()>1){
            subTrees.enqueue(buildTree(subTrees.dequeue(), subTrees.dequeue()));
        }
    }

    // return the height of this tree
    private int treeHeight(BinaryTree<Float> tree){
        if(tree==null)
            return -1;
        else
            return Math.max(treeHeight(tree.left), treeHeight(tree.right)) + 1 ;
    }

    // store each codes of total chars
    private void storeCodes(){
        char[] codeString = new char[treeHeight(huffmanTree)];

        // judge whether symbols.length equals 1
        if(symbols.length==1) {
            codes[0] = "0";
            return;
        }

        for(int i=0; i<symbols.length; i++){
            BinaryTree<Float> node = locations.get(i);
            int index = treeHeight(huffmanTree)-1;

            while(node.parent!=null){
                if(node.parent.left==node)
                    codeString[index] = '0';
//                    codeString[index] = ((Integer) 0).toString().charAt(0);
                else
                    codeString[index] = '1';
                index--;
                node = node.parent;
            }
            codes[i] = new String(codeString, index+1, codeString.length-1-index);
//            int codeLen =treeHeight(huffmanTree)-1-index;
//            char[] newArray = new char[codeLen];
//            System.arraycopy(codeString, 0, newArray, 0, codeLen);
//            codes[i] = newArray.toString();
        }
    }

    // encode the input String
    public String encode(String originalString){
        int len = originalString.length();
        StringBuffer encodedString = new StringBuffer();

        for(int i=0; i<len; i++){   // encode char in order
            char origin = originalString.charAt(i);

            for(int j=symbols.length-1; j >= 0; j--){
                if(symbols[j]==origin){
                    encodedString.append(codes[j]);
                    break;
                }
            }
        }
        return encodedString.toString();
    }

    // decode the input String
    public String decode(String encodedCode){
        StringBuffer originalString = new StringBuffer();
        int pointer = 0;

        while(pointer<encodedCode.length()){    // Go through input code
            BinaryTree<Float> node = huffmanTree;

            while(node.left!=null && node.right!=null) {    // Match the sub code
                char code = encodedCode.charAt(pointer);
                if (code == '0')
                    node = node.left;
                else
                    node = node.right;
                pointer++;
            }
            float fIndex = node.getData();
            int index = (int)fIndex;
            originalString.append(symbols[index]);
        }

        return originalString.toString();
    }
}

经测试，表现良好！