定義

我們現在來學習一種能夠大幅壓縮自然語言檔案空間（以及許多其他型別檔案）的資料壓縮技術。

它的主要思想是放棄文字檔案的普通儲存方式：不在使用7位或8位二進位制數表示每一個字元，而是用較少的位元表示出現頻率高的字元，用較多的位元表示出現頻率低的字元。

簡而言之，不在用ASCII編碼表示，而是用較短的字首碼錶示。

字首碼

什麼是字首碼？如果所有字元編碼都不會成為其他字元編碼的字首，符合這種規則的叫字首碼。

比如，如果A的編碼為0，R的編碼為00，那麼A的編碼是R的字首，這不屬於字首碼。那麼字首碼的例子是什麼樣的呢？如下：

所有的字首碼的解碼方式都和它一樣，是唯一的。因此字首碼被廣泛應用於實際生產中。注意，像7位ASCII編碼編碼這樣的定長編碼也是字首碼。

霍夫曼單詞查詢樹

表示字首碼的一種簡便方法就是使用單詞查詢樹。

任意含有M個空連結的單詞查詢樹都沒M個字元定義了一種字首碼方法：我們將空連結替換為指向葉子結點（含有兩個空連結的結點）的連結，每個葉子結點都含有一個需要編碼的字元。這樣，沒個字元的編碼都是從根結點到該結點的路徑表示的位元字串，其中左連結表示0，右連結表示1.

如果構造這樣一棵樹？

首先，樹的結點包含left和right，和一個字元頻率變數freq，以及字元ch。以下為構造一顆霍夫曼單詞查詢樹的過程：

1. 將需要被編碼的字元放在葉子結點中並在每個結點中維護了一個名為freq的例項變數來表示以它為根結點的子樹種的所有字元出現的頻率。
2. 建立一片由許多隻有一個結點（即葉子結點）的樹所組成的森林。每棵樹都表示輸入流的一個字元，每個結點中的freq表示它在輸入流中的出現頻率。
3. 找到兩個頻率最小的結點，然後建立一個以二者為子結點的新結點（新結點的頻率為它的兩個子結點的頻率之和）。
4. 不斷重複第3過程，最終所有的結點會被合併為一顆單獨的單詞查詢樹。

特點：

• 樹的葉子結點包含freq和字元。
• 頻率高的離根結點最近，頻率低的在樹的底層。
• 根結點頻率值等於輸入中的字元數量。
• 該樹表示的編碼壓縮比其他樹更多，是一種最優的字首碼

壓縮

對於任意單詞查詢樹，都能產生一張將樹中的字元和位元字串（用由0和1組成的String字串表示）相對應的編譯表

然後，壓縮就很簡單了，只需要在其中找到輸入字元所對應的編碼即可。

上圖字串ABRACADABRA!的編碼為：首先是0（A的編碼），然後是111（B的編碼），然後是110（R的編碼），最後得到完整編碼為0111110010110100011111001010.

解壓

首先readTrie()將霍夫曼單詞查詢樹編碼為的位元流構造為霍夫曼查詢樹。然後讀取霍夫曼壓縮碼，根據該編碼從根結點向下移動（讀取一個位元，為0移動到左結點，為1移動到右結點）。當遇到葉子結點後，輸出該結點的字元並重新回到根結點。

例如壓縮ABRACADABRA!後的編碼為：0111110010110100011111001010，其單詞查詢樹的位元流為：01010000010010100010001001000011010000110101010010101000010。

首先由樹的位元流構造霍夫曼查詢樹（得如下樹），然後解碼編碼。第一個為0，所以移動到左子結點，輸出A；回到根，然後連續三個1，即向右移動3次，輸出B；回到根，然後兩個1，一個0，即向右移動兩次，向左移動一次，輸出R。如此重複，最後得到ABRACADABRA!

實現程式碼

/**
 * 霍夫曼壓縮
 * @author nicholas.tang
 *
 */
public class Huffman 
{
    public static int R = 256;
    public static final int asciiLength = 8;//ascii碼，一個字元等於8個bit
    public static String bitStreamOfTrie = "";//使用前序遍歷將霍夫曼單詞查詢樹編碼為位元流
    public static int lengthOfText = 0;//要壓縮文字的長度

    private static String next = "";//讀取霍夫曼單詞查詢樹用到的next字串，它指向下一個位元流的子字串，用了遍歷位元流

    /**
     * 霍夫曼單詞查詢樹中的結點
     * @author nicholas.tang
     *
     */
    private static class Node implements Comparable<Node>
    {
        private char ch;    //內部結點不會使用該變數
        private int freq;   //展開過程不會使用該變數
        private final Node left, right;

        Node(char ch, int freq, Node left, Node right)
        {
            this.ch = ch;
            this.freq = freq;
            this.left = left;
            this.right = right;
        }

        public boolean isLeaf()
        {
            return left == null && right == null;
        }

        public int compareTo(Node that)
        {
            return this.freq - that.freq;
        }
    }

    /**
     * 解壓
     * @param bitSteam 霍夫曼單詞查詢樹編碼為的位元流
     * @param length 文字長度
     * @param huffmanCode 霍夫曼編碼
     * @return 解壓後的文字
     */
    public static String expand(String bitSteam, int length, String huffmanCode)
    {   
        Node root = null;
        if(bitSteam == "")
        {
            return "";
        }
        else
        {
            root = readTrie(bitSteam);  
        }

        int j = 0;
        String text = "";
        for(int i = 0; i < length; i++)
        {
            Node x = root;
            while(!x.isLeaf())
            {
                if(huffmanCode.substring(j, j+1).equals("1"))
                {
                    x = x.right;
                }
                else
                {
                    x = x.left;
                }
                j++;
            }
            text +=x.ch;
        }   
        return text;
    }

    /**
     * 壓縮
     * @param s 要壓縮的文字
     * @return 壓縮後，反饋的霍夫曼編碼
     */
    public static String compress(String s)
    {
        //讀取輸入
        char[] input = s.toCharArray();

        //統計頻率
        int[] freq = new int[R];
        for(int i = 0; i < input.length; i++)
        {
            freq[input[i]]++;
        }

        //構造霍夫曼編碼樹
        Node root = buildTrie(freq);

        //遞迴地構造編譯表
        String[] st = new String[R];
        buildCode(st, root, "");

        //遞迴地列印解碼用的單詞查詢樹，即位元流
        writeTrie(root);

        //列印字元總數
        lengthOfText = input.length;

        //使用霍夫曼編碼處理輸入
        String codeOfHuffman = "";
        for(int i = 0; i < input.length; i ++)
        {
            String code = st[input[i]];         
            for(int j = 0; j < code.length(); j++)
            {
                if(code.charAt(j) == '1')
                {
                    codeOfHuffman += '1';
                }
                else
                {
                    codeOfHuffman += '0';
                }
            }
        }
        return codeOfHuffman;//返回霍夫曼編碼
    }

    /**
     * 構建霍夫曼單詞查詢樹
     * @param freq 字元在文字出現的頻率
     * @return 霍夫曼單詞查詢樹
     */
    private static Node buildTrie(int[] freq)
    {
        MinPQ<Node> pq = new MinPQ<Node>(R);
        for(char c = 0; c < R; c++)
        {
            if(freq[c] > 0)
            {
                pq.insert(new Node(c, freq[c], null, null));
            }
        }
        while(pq.size() > 1)
        {//合併兩顆頻率最小的樹
            Node x = pq.delMin();
            Node y = pq.delMin();
            Node parent = new Node('\0', x.freq + y.freq, x, y);
            pq.insert(parent);
        }
        return pq.delMin();
    }

    /**
     * 構造編譯表
     * @param st 編譯表
     * @param x 霍夫曼單詞查詢樹中的結點
     * @param s 編譯表內容
     */
    private static void buildCode(String[] st, Node x, String s)
    {
        if(x.isLeaf())
        {
            st[x.ch] = s;
            return;
        }
        buildCode(st, x.left, s + '0');
        buildCode(st, x.right, s + '1');
    }

    /**
     * 使用前序遍歷將霍夫曼單詞查詢樹編碼為位元流
     * @param x 霍夫曼單詞查詢樹
     */
    private static void writeTrie(Node x)
    {//輸出單詞查詢樹的位元字串
        if(x.isLeaf())
        {
            bitStreamOfTrie += '1';
            String temp = Integer.toBinaryString(x.ch);
            int n = asciiLength - temp.length();
            temp = repeatStrings("0", n) + temp;
            bitStreamOfTrie += temp;
            return ;
        }
        bitStreamOfTrie += '0';
        writeTrie(x.left);
        writeTrie(x.right);
    }   

    /**
     * 用位元流構造霍夫曼單詞查詢樹
     * @param s 位元流
     * @return 霍夫曼單詞查詢樹
     */
    private static Node readTrie(String s)
    {           
        if(s.substring(0, 1).equals("1"))
        {  
            int value = Integer.parseInt(s.substring(1, 1 + asciiLength),2);
            next = s.substring(1 + asciiLength);
            return new Node((char)value, 0, null, null);            
        }
        else
        {           
            next = s.substring(1);
            return new Node('\0', 0, readTrie(next), readTrie(next));
        }       
    }

    /**
     * 重複字串
     * @param s 需要重複的字串
     * @param n 重複次數
     * @return 重複後的字串
     */
    private static String repeatStrings(String s , int n)
    {
          String temp = "";
          for(int i = 0; i < n;i++)
          {
              temp += s;
          }
          return temp;
    }

    public static void main(String[] args) 
    {
        String text = "ABRACADABRA!";
        System.out.println("Input text: " + text);

        String HuffmanCode = Huffman.compress(text);
        int bitsOfText = Huffman.lengthOfText * Huffman.asciiLength;
        String bitStream = Huffman.bitStreamOfTrie;
        double compressionRatio = 1.0 * HuffmanCode.length() / bitsOfText;

        System.out.println("Huffman Code: " + HuffmanCode);     
        System.out.println("BitStream: " + bitStream);
        System.out.println("Huffman Code length(bit): " + HuffmanCode.length());
        System.out.println("Length of text(bit): " + bitsOfText);
        System.out.println("Compression ratio: " + compressionRatio * 100 + "%");

        String expandText = Huffman.expand(bitStream, lengthOfText, HuffmanCode);
        System.out.println("Expand text: " + expandText);
    }
}

輸出：

Input text: ABRACADABRA!
Huffman Code: 0111110010110100011111001010
BitStream: 01010000010010100010001001000011010000110101010010101000010
Huffman Code length(bit): 28
Length of text(bit): 96
Compression ratio: 29.166666666666668%
Expand text: ABRACADABRA!