霍夫曼樹

一、哈夫曼樹的概念和定義

　　什么是哈夫曼樹？讓我們先舉一個例子。

　　判定樹：在很多問題的處理過程中，需要進行大量的條件判斷，這些判斷結構的設計直接影響着程序的執行效率。例如，編制一個程序，將百分制轉換成五個等級輸出。大家可能認為這個程序很簡單，並且很快就可以用下列形式編寫出來：

if(score<60)
    cout<<"Bad"<<endl;
else if(score<70)
    cout<<"Pass"<<endl
else if(score<80)
    cout<<"General"<<endl;
else if(score<90)
        cout<<"Good"<<endl;
else
        cout<<"Very good!"<<endl;
    

　　若考慮上述程序所耗費的時間，就會發現該程序的缺陷。在實際中，學生成績在五個等級上的分布是不均勻的。當學生百分制成績的錄入量很大時，上述判定過程需要反復調用，此時程序的執行效率將成為一個嚴重問題。 但在實際應用中，往往各個分數段的分布並不是均勻的。下面就是在一次考試中某門課程的各分數段的分布情況： 

 

 

　　下面我們就利用哈夫曼樹尋找一棵最佳判定樹，即總的比較次數最少的判定樹。第一種構造方式：

 

 

 

　　第二種構造方式：

 

 

 

　　這兩種方式，顯然后者的判定過程的效率要比前者高。在也沒有別地判定過程比第二種方式的效率更高。我們稱判定過程最優的二叉樹為最優二叉樹

　　定義哈夫曼樹之前先說明幾個與哈夫曼樹有關的概念：

　　路徑： 樹中一個結點到另一個結點之間的分支構成這兩個結點之間的路徑。

　　路徑長度：路徑上的分枝數目稱作路徑長度。

　　樹的路徑長度：從樹根到每一個結點的路徑長度之和。

　　結點的帶權路徑長度：在一棵樹中，如果其結點上附帶有一個權值，通常把該結點的路徑長度與該結點上的權值之積稱為該結點的帶權路徑長度（weighted path length）

  什么是權值?( From 百度百科 )

    計算機領域中（數據結構）權值就是定義的路徑上面的值。可以這樣理解為節點間的距離。通常指字符對應的二進制編碼出現的概率。至於霍夫曼樹中的權值可以理解為：權值大表明出現概率大！一個結點的權值實際上就是這個結點子樹在整個樹中所占的比例.abcd四個葉子結點的權值為7,5,2,4. 這個7,5,2,4是根據實際情況得到的,比如說從一段文本中統計出abcd四個字母出現的次數分別為7,5,2,4. 說a結點的權值為7,意思是說a結點在系統中占有7這個份量.實際上也可以化為百分比來表示,但反而麻煩,實際上是一樣的.

　　樹的帶權路徑長度：如果樹中每個葉子上都帶有一個權值，則把樹中所有葉子的帶權路徑長度之和稱為樹的帶權路徑長度。

　　設某二叉樹有n個帶權值的葉子結點，則該二叉樹的帶權路徑長度記為：

                                  

公式中，Wk為第k個葉子結點的權值；Lk為該結點的路徑長度。

　　示例：

 

　　一般來說，用n（n>0）個帶權值的葉子來構造二叉樹，限定二叉樹中除了這n個葉子外只能出現度為2的結點。那么符合這樣條件的二叉樹往往可構造出許多顆， 其中帶權路徑長度最小的二叉樹就稱為最優二叉樹

  二、哈夫曼樹的構造

　　根據哈弗曼樹的定義，一棵二叉樹要使其WPL值最小，必須使權值越大的葉子結點越靠近根結點，而權值越小的葉子結點越遠離根結點。哈弗曼依據這一特點提出了一種構造最優二叉樹的方法，其基本思想如下：

 　　注意：如果有幾棵樹根節點權值相等，並且存在一棵樹只有一個節點，應該講這課節點較小的樹先出隊列。

　　下面演示了用Huffman算法構造一棵Huffman樹的過程：

三、哈夫曼樹的在編碼中的應用

　　在電文傳輸中，需要將電文中出現的每個字符進行二進制編碼。在設計編碼時需要遵守兩個原則：

　　（1）發送方傳輸的二進制編碼，到接收方解碼后必須具有唯一性，即解碼結果與發送方發送的電文完全一樣；

　　（2）發送的二進制編碼盡可能地短。下面我們介紹兩種編碼的方式。

1. 等長編碼

　　這種編碼方式的特點是每個字符的編碼長度相同（編碼長度就是每個編碼所含的二進制位數）。假設字符集只含有4個字符A，B，C，D，用二進制兩位表示的編 碼分別為00，01，10，11。若現在有一段電文為：ABACCDA，則應發送二進制序列：00010010101100，總長度為14位。當接收方接收到這段電文后，將按兩位一段進行譯碼。這種編碼的特點是譯碼簡單且具有唯一性，但編碼長度並不是最短的。

2. 不等長編碼

　　在傳送電文時，為了使其二進制位數盡可能地少，可以將每個字符的編碼設計為不等長的，使用頻度較高的字符分配一個相對比較短的編碼，使用頻度較低的字符分配一個比較長的編碼。例如，可以為A，B，C，D四個字符分別分0，00，1，01，並可將上述電文用二進制序列：000011010發送，其長度只有 9個二進制位，但隨之帶來了一個問題，接收方接到這段電文后無法進行譯碼，因為無法斷定前面4個0是4個A，1個B、2個A，還是2個B，即譯碼不唯一， 因此這種編碼方法不可使用。

　　因此，為了設計長短不等的編碼，以便減少電文的總長， 還必須考慮編碼的 唯一性，即在建立不等長編碼時必須使任何一個字符的編碼都不是另一個字符的前綴，這宗編碼稱為前綴編碼（prefix  code）

　　（1）利用字符集中每個字符的使用頻率作為權值構造一個哈夫曼樹；

　　（2）從根結點開始，為到每個葉子結點路徑上的左分支賦予0，右分支賦予1，並從根到葉子方向形成該葉子結點的編碼

例題：

　　假設一個文本文件TFile中只包含7個字符{A，B，C，D，E，F，G}，這7個字符在文本中出現的次數為{5，24，7，17，34，5，13}

　　利用哈夫曼樹可以為文件TFile構造出符合前綴編碼要求的不等長編碼

具體做法：

　　1. 將TFile中7個字符都作為葉子結點，每個字符出現次數作為該葉子結點的權值

　　2. 規定哈夫曼樹中所有左分支表示字符0，所有右分支表示字符1,將依次從根結點到每個葉子結點所經過的分支的二進制位的序列作為該結點對應的字符編碼

　　3. 由於從根結點到任何一個葉子結點都不可能經過其他葉子，這種編碼一定是前綴編碼，哈夫曼樹的帶權路徑長度正好是文件TFile編碼的總長度

　　通過哈夫曼樹來構造的編碼稱為哈弗曼編碼（huffman code）

import java.util.PriorityQueue;

public class HuffMan {
    private static int[] count = { 5, 24, 7, 17, 34, 5, 13 };
    private static int N = count.length;
    private static char[] chars = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
    private static PriorityQueue<Node> priorityQueue = new PriorityQueue<Node>();

    private static class Node implements Comparable {
        Character c = null;
        double w;
        Node left;
        Node right;

        @Override
        public int compareTo(Object o) {
            Node n = (Node) o;
            if (this.w - n.w > 0)
                return 1;
            else if (this.w - n.w < 0) {
                return -1;
            } else {
                //如果兩個Node的權值相等，將是由其他節點合並而來的節點設置為較小值，先出隊列構建霍夫曼樹
                if (n.c == null) {
                    return 1;
                } else if (this.c == null) {
                    return -1;
                } else {
                    return 0;
                }
            }
        }

        public Node(char c, double w, Node left, Node right) {
            super();
            this.c = c;
            this.w = w;
            this.left = left;
            this.right = right;
        }

        public Node(double w, Node left, Node right) {
            super();
            this.w = w;
            this.left = left;
            this.right = right;
        }

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

    }

    public static Node create() {
        for (int i = 0; i < N; i++) {
            priorityQueue.add(new Node(chars[i], count[i], null, null));
        }
        while (priorityQueue.size() > 1) {
            Node left = priorityQueue.poll();
            Node right = priorityQueue.poll();

            Node newNode = new Node(left.w + right.w, left, right);
            priorityQueue.add(newNode);

        }
        return priorityQueue.poll();
    }

    public static void print(Node node, StringBuilder builder) {
        if (node.left == null && node.right == null) {
            System.out.println(node.c + ":" + builder);

        } else {
            print(node.left, builder.append('0'));
            builder.deleteCharAt(builder.length() - 1);
            print(node.right, builder.append('1'));
            builder.deleteCharAt(builder.length() - 1);
        }
    }
    public static void main(String[] args) {
        Node root = create();
        print(root, new StringBuilder());
    }
}