貪心算法之哈夫曼編碼

   哈夫曼編碼是廣泛地用於數據文件壓縮的十分有效的編碼方法。其壓縮率通常在20%～90%之間。哈夫曼編碼算法用字符在文件中出現的頻率表來建立一個用0，1串表示各字符的最優表示方式。

給出現頻率高的字符較短的編碼，出現頻率較低的字符以較長的編碼，可以大大縮短總碼長。

定長碼：

3*(45+13+12+16+9+5) = 300 千位

變長碼：

1*45+3*13+3*12+3*16+4*9+4*5 ＝ 224 千位

1、前綴碼

對每一個字符規定一個0,1串作為其代碼，並要求任一字符的代碼都不是其它字符代碼的前綴。這種編碼稱為前綴碼。

編碼的前綴性質可以使譯碼方法非常簡單。

表示最優前綴碼的二叉樹總是一棵完全二叉樹，即樹中任一結點都有2個兒子結點。

f(c)表示字符c出現的概率，dt(c)表示c的碼長

平均碼長定義為：

使平均碼長達到最小的前綴碼編碼方案稱為給定編碼字符集C的最優前綴碼。

2、構造哈夫曼編碼

哈夫曼提出構造最優前綴碼的貪心算法，由此產生的編碼方案稱為哈夫曼編碼。

哈夫曼算法以自底向上的方式構造表示最優前綴碼的二叉樹T。

算法以|C|個葉結點開始，執行|C|－1次的“合並”運算后產生最終所要求的樹T。

以f為鍵值的優先隊列Q用在貪心選擇時有效地確定算法當前要合並的2棵具有最小頻率的樹。一旦2棵具有最小頻率的樹合並后，產生一棵新的樹，其頻率為合並的2棵樹的頻率之和，並將新樹插入優先隊列Q。經過n－1次的合並后，優先隊列中只剩下一棵樹，即所要求的樹T。

算法huffmanTree用最小堆實現優先隊列Q。初始化優先隊列需要O(n)計算時間，由於最小堆的removeMin和put運算均需O(logn)時間，n－1次的合並總共需要O(nlogn)計算時間。因此，關於n個字符的哈夫曼算法的計算時間為O(nlogn) 。

3、哈夫曼算法的正確性

要證明哈夫曼算法的正確性，只要證明最優前綴碼問題具有貪心選擇性質和最優子結構性質。

(1)貪心選擇性質

(2)最優子結構性質

具體代碼實現：

import java.util.LinkedHashMap;
import java.util.ArrayList;
import java.util.Set;
import java.util.Iterator;

class HuffmanNode {
    char label;
    int weight;
    int parent;
    int lChild;
    int rChild;
    int frequency;//頻率主要是用來衡量字符在給定編碼字符串中出現的次數

    public HuffmanNode(char label, int weight, int parent, int lChild,
            int rChild) {
        this.label = label;
        this.weight = weight;
        this.lChild = lChild;
        this.rChild = rChild;
    }
}

class HuffmanTree {
    private LinkedHashMap<Character, Integer> charTable; //主要用hashmap來存放字符及其出現的頻率
    private Set<Character> charset;
    private ArrayList<HuffmanNode> huffmanTree;//huffman節點集合
    private ArrayList<String> huffmanCode;//huffman編碼集合

    public HuffmanTree(LinkedHashMap<Character, Integer> map) {
        charTable = map;
        charset = map.keySet();
        creatHuffmanTree();//首先創建huffman樹
        creatHuffmanCode();
    }

    private void initTree() {
        huffmanTree = new ArrayList<HuffmanNode>();
        Iterator<Character> charIter = charset.iterator();
        int i = 1;
        huffmanTree.add(0,
                new HuffmanNode((char) 0, Integer.MAX_VALUE, 0, 0, 0));
        while (charIter.hasNext()) {
            Character ch = charIter.next();
            huffmanTree.add(i, new HuffmanNode(ch, charTable.get(ch), 0, 0, 0));
            i++;
        }
        for (int j = charset.size() + 1; j < 2 * charset.size(); j++) {
            huffmanTree.add(j, new HuffmanNode((char) 0, 0, 0, 0, 0));
        }
    }

    // 創建huffman樹
    private void creatHuffmanTree() {
        initTree();
        int min_child1;
        int min_child2;
        for (int i = charset.size() + 1; i < 2 * charset.size(); i++) {
            min_child1 = 0;
            min_child2 = 0;
            for (int j = 1; j < i; j++) {
                if (huffmanTree.get(j).parent == 0) {
                    if (huffmanTree.get(j).weight < huffmanTree.get(min_child1).weight
                            || huffmanTree.get(j).weight < huffmanTree
                                    .get(min_child2).weight) {
                        if (huffmanTree.get(min_child1).weight < huffmanTree
                                .get(min_child2).weight) {
                            min_child2 = j;
                        } else {
                            min_child1 = j;
                        }
                    }
                }
            }
            huffmanTree.get(min_child1).parent = i;
            huffmanTree.get(min_child2).parent = i;

            if (min_child1 < min_child2) {
                huffmanTree.get(i).lChild = min_child1;
                huffmanTree.get(i).rChild = min_child2;
            } else {
                huffmanTree.get(i).rChild = min_child1;
                huffmanTree.get(i).lChild = min_child2;
            }

            huffmanTree.get(i).weight = huffmanTree.get(i).weight
                    + huffmanTree.get(i).weight;
        }
    }

    private void creatHuffmanCode() {
        huffmanCode = new ArrayList<String>(charset.size() + 1);
        huffmanCode.add(0, null);
        char[] tempChars = new char[charset.size() + 1];
        for (int i = 1; i < charset.size() + 1; i++) {
            int startIndex = charset.size();
            int parent = huffmanTree.get(i).parent;
            int ch = i;
            while (parent != 0) {
                if (huffmanTree.get(parent).lChild == ch) {
                    tempChars[startIndex] = '0';
                } else {
                    tempChars[startIndex] = '1';
                }
                startIndex--;
                ch = parent;
                parent = huffmanTree.get(parent).parent;
            }
            System.out.println(String.valueOf(tempChars, startIndex + 1,
                    charset.size() - startIndex));
            huffmanCode.add(i, String.valueOf(tempChars, startIndex + 1,
                    charset.size() - startIndex));
        }
    }// end method

    // huffman編碼
    public String enCodeString(String inString) {
        StringBuffer temp = new StringBuffer();
        for (int i = 0; i < inString.length(); i++) {
            int ch = inString.charAt(i);
            int j = 1;
            for (; huffmanTree.get(j).label != ch && j < charset.size() + 1; j++) {
            }
            if (j <= charset.size()) {
                temp.append(huffmanCode.get(j));
            } else {
                temp.append(ch);
            }
        }
        return temp.toString();
    }

    // huffman解碼
    public String deCodeString(String inString) {
        StringBuffer temp = new StringBuffer();
        int root = charset.size() * 2 - 1;
        for (int i = 0; i < inString.length(); i++) {
            char ch = inString.charAt(i);
            if (ch == '0') {
                root = huffmanTree.get(root).lChild;
            } else if (ch == '1') {
                root = huffmanTree.get(root).rChild;
            } else {
                temp.append(ch);
            }
            if (root <= charset.size()) {
                temp.append(huffmanTree.get(root).label);
                root = charset.size() * 2 - 1;
            }
        }
        return temp.toString();
    }

}

public class HuffmanTreeTest {
    public static void main(String[] args) {
        LinkedHashMap<Character, Integer> hasmap = new LinkedHashMap<Character, Integer>();
        hasmap.put('a', 4);
        hasmap.put('b', 5);
        hasmap.put('c', 8);
        hasmap.put('d', 10);

        HuffmanTree huffman = new HuffmanTree(hasmap);
        String temp = huffman.enCodeString("abcd");
        System.out.println(temp);
        System.out.println(huffman.deCodeString(temp));

    }

}