1.Huffman樹的基礎概念

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

路徑長度：路徑上分支的數目。

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

節點的帶權路徑長度：從該節點到樹根之間的路徑長度與節點上權的乘積。

樹的帶權路徑長度：樹中所有葉節點的帶權路徑長度之和，通常記作WPL（Weighted Path Length of Tree）。

Huffman樹：假設有n個權值{m1,m2,m3,,,,,mn}，可以構造一棵具有n個葉子節點的二叉樹，每個葉子節點帶權為mi，則其中帶權路徑長度WPL最小的二叉樹稱作Huffman樹。

根據定義，Huffman樹是帶權路徑長度最小的樹，假設一個二叉樹有4個節點，分別是A，B，C，D，其權重分別是5，7，2，13，通過這4個節點可以構成多種二叉樹。

WPL(A)=5*2 + 7*2 + 2*2 + 13*2 = 54

WPL(B)=5*1 + 7*2 + 2*3 + 13*3 = 64

WPL(C)=13*1 + 7*2 + 2*3 + 5*3 = 48

通過上面的例子，其實可以發現的規律是在構造二叉樹的時候，將權值大的節點儘量放在路徑高度小的位置，而將權值小的節點儘量放在路徑高度大的位置，這樣就可以得到最優的二叉樹。

2.Huffman樹的構造過程

(1)將給定的n個權值{m1,m2,m3,,,,,mn}作為n個根節點的權值並構造一棵具有n棵二叉樹的森林{T1，T2，T3，，，，Tn}，其中每棵二叉樹都只有一個節點。

(2)在森林中選取兩棵根節點權值最小的二叉樹，作為左右子樹並構造一棵二叉樹，新二叉樹的根節點權值為這兩棵樹根的權值之和。

(3)在森林中，將上面選擇的兩棵權值最小的二叉樹從森林中刪除，同時將上一步中新構造的二叉樹加入到森林中。

(4)重複(2)(3)步驟，直到森林中只有一棵二叉樹為止，這棵就是Huffman樹。

3.Huffman編碼

在現實中，如果要使用ASCII碼來設計電文，會浪費許多的空間，因為所有的編碼都是7位。因此為了節省空間，可以將電文設計成二進位制字首編碼，其實就是以n種字元的出現頻率作為權重，然後設計Huffman樹的過程。正是因為這個原因，所以通常將二進位制字首編碼稱為Huffman編碼。

Huffman樹的資料結構

(1).我們採用陣列的形式來儲存Huffman樹，所以在該結構父節點，左右子樹節點都儲存在陣列對應的下標位置，因此不採用指標變數，還需要定義一個字元數指標，用來指向Huffman編碼字串。

<pre name="code" class="cpp">typedef struct HuffmanTree {
        int weight ;
        int parent ;
        int left ;
        int right ;
}HuffmanTree ;

typedef char * HuffmanCode ;

<pre name="code" class="cpp">void CreateTree(HuffmanTree *HuffTree , int n , int * w) {
        int i , m = 2 * n - 1 ;
        int bt1 , bt2 ;
        if(n <= 1)
                return ;
        for(i = 1 ; 1 <= n ; ++ i) {
                HuffTree[i].weight = w[i-1] ;
                HuffTree[i].parent = 0 ;
                HuffTree[i].left = 0 ;
                HuffTree[i].right = 0 ;
        }
        for(;i <= m ; ++ i){
                HuffTree[i].weight = 0 ;
                HuffTree[i].parent = 0 ;
                HuffTree[i].left = 0 ;
                HuffTree[i].right = 0 ;
        }
        for(i = n + 1 ; i < m ; ++ i) {
                SelectNode(HuffTree , i -1 , &bt1 , &bt2) ;
                HuffTree[bt1].parent = i ;
                HuffTree[bt2].parent = i ;
                HuffTree[i].left = bt1 ;
                HuffTree[i].right = bt2 ;
                HuffTree[i].weight = HuffTree[bt1].weight + HuffTree[bt2].weight ;
        }
}

其中引數：

HuffTree :指向HuffTree樹的指標，呼叫函式申請記憶體，並得到這個指標

n :建立HuffTree樹的葉節點數量

w :是一個指標，用於傳入n個節點的權值

(3).編寫SelectNode()函式，功能是在建立Huffman樹函式CreateTree()中反覆使用，該函式用於從無父節點中選出2個權值最小節點

void SelectNode(HuffmanTree * HuffTree , int n , int * bt1 , int * bt2) {
        //從1-x個節點中選擇parent節點為0,權重最小的兩個節點
        int i ;
        HuffmanTree *HuffTree1 , *HuffTree2 , *t ;
        HuffTree1 = NULL ;
        HuffTree2 = NULL ;                  //初始化兩個節點為空
        for(i = 1 ; i <= n ; ++ i) {                    //迴圈處理1-n個節點
                if(HuffTree[i].parent = 0) {            //父節點為空

                        //找到第一個父節點為空的節點，作為HuffTree1

                        if(HuffTree1 == NULL) {
                                HuffTree1 = HuffTree + i ;              //指向第i個節點
                                continue ;                              //繼續迴圈
                        }

                        //找到第二個父節點為空的節點，作為HuffTree2

                        if(HuffTree2 == NULL) {                         //節點指標2為空
                                HuffTree2 = HuffTree + i ;              //指向第i個節點
                                if(HuffTree1 ->weight > HuffTree2 ->weight) {   //比較兩個節點的權重，使HuffTree1指向的節點權重小
                                        t = HuffTree2 ;
                                        HuffTree2 = HuffTree1 ;
                                        HuffTree1 = t ;
                                }
                                continue ;
                        }
                        if(HuffTree1 && HuffTree2) {                    //若HuffTree1,HuffTree2兩個指標都有效
                                if(HuffTree[i].weight <= HuffTree1 ->weight) {  //第i個節點權重小於HuffTree1指向的節點
                                        HuffTree2 = HuffTree1 ;                 //
                                        HuffTree1 = HuffTree + i ;              //
                                }
                                else if(HuffTree[i].weight < HuffTree2 ->weight) {      //
                                        HuffTree2 = HuffTree + i ;              //
                                }
                        }
                }
        }
        if(HuffTree1 > HuffTree2) {             //增加比較，使二叉樹左側為葉子節點
                *bt2 = HuffTree1 - HuffTree ;
                *bt1 = HuffTree2 - HuffTree ;
        }
        else {
                *bt2 = HuffTree2 - HuffTree ;
                *bt1 = HuffTree1 - HuffTree ;
        }

void HuffmanCoding(HuffmanTree *HuffTree , int n , HuffmanCode * HuffCode) {
        char * cd ;
        int start , i ;
        int current , parent ;
        cd = (char *)malloc(n * sizeof(char)) ;         //
        cd[n-1] = '\0' ;                                //
        for(i = 1 ; i <= n ; ++i) {
                start = n - 1 ;
                current = i ;
                parent = HuffTree[current].parent ;
                while(parent) {
                        if(current == HuffTree[parent].left)
                                cd[--start] = '0' ;
                        else
                                cd[--start] = '1' ;
                        current = parent ;
                        parent = HuffTree[parent].parent ;
                }
                HuffCode[i-1] = (char *)malloc((n - start) * sizeof(char)) ;
                strcpy(HuffCode[i-1] , & cd[start]) ;

        }
        free(cd) ;
}

int main(void) {
        int i , n = 4 , m ;
        char test[] = "DBDBDABDCDADBDADBDADACDBDBD" ;
        char code[100] , code1[100] ;
        char alphabte[] = { 'A' , 'B' , 'C' , 'D' } ;
        int w[] = {5 , 7 , 2 , 13} ;
        HuffmanTree *HuffTree ;
        HuffmanCode * HuffCode ;
        m = 2 * n - 1 ;
        HuffTree = (HuffmanTree *)malloc((m + 1) * sizeof(HuffmanTree)) ;
        HuffCode = (HuffmanCode *)malloc((n * sizeof(char *))) ;
        CreateTree(HuffTree , n , HuffCode) ;
        HuffmanCoding(HuffTree , n , HuffCode) ;
        for(i = 1 ; i <= n ; ++ i)
                printf("字母:%c , 權重:%d , 編碼為:%s\n" , alphabte[i - 1] , HuffTree[i].weight , HuffCode[i - 1]) ;
        return 0 ;
}

</pre><pre name="code" class="cpp">

此外，還有一種傳統的樹形結構的方法，優點是較為直觀，能夠形象的模擬出構造Huffman樹的過程，但缺點是較為浪費空間。

#include <stdio.h>
#include <stdlib.h>

typedef struct HuffTree {
        char ch ;
        int weight ;
        struct HuffTree * left ;
        struct HuffTree * right ;
}HuffTree ;

void Huffman(HuffTree ** forest , int num) {
        int min_1 , min_2 ;
        int i , j ;
        HuffTree * newNode = NULL ;
        for(i = 0 ; i < num -1 ; ++ i) {
                //找到第一個沒有父節點的二叉樹
                for(min_1 = 0 ; min_1 < num && forest[min_1] == NULL ; min_1 ++) ;
                //找到第二個沒有父節點的二叉樹
                for(min_2 = min_1 ++ ; min_2 < num && forest[min_2] == NULL ; min_2 ++) ;
                //通過一次遍歷找到權值最小和次小的兩個二叉樹
                //如果初始情況下，min_1的權值大於min_2，那麼通過第一次比較就可以交換
                for(j = min_2 ; j < num ; ++ j) {
                        //如果當前節點已經有父節點，就跳過
                        if(forest[j]) {
                                //如果當前節點比最小的節點權值更小，就把它賦給最小，把原來的最小賦給次小
                                if(forest[j] ->weight < forest[min_1] -> weight) {
                                        min_2 = min_1 ;
                                        min_1 = j ;
                                }
                                //而如果當前節點比最小大，比次小小，就把它賦給次小
                                else if(forest[j] -> weight < forest[min_2] -> weight) {
                                        min_2 = j ;
                                }
                                newNode = (HuffTree *) malloc (sizeof(HuffTree)) ;
                                newNode ->weight = forest[min_1] -> weight + forest[min_2] -> weight ;
                                newNode ->left = forest[min_1] ;
                                newNode ->right = forest[min_2] ;
                                forest[min_1] = newNode ;
                                forest[min_2] = NULL ;
                        }
                }
        }
}

int main(void) {
        int num ;
        int i ;
        printf("Input the num of codes:") ;
        scanf("%d" , num) ;
        HuffTree ** forest = (HuffTree **) malloc (num * sizeof(HuffTree *)) ;
        //initialization forest
        for(i = 0 ; i < num ; ++ i) {
                forest[i] = (HuffTree *) malloc (sizeof(HuffTree)) ;
                printf("input the No.%d HuffTree's charactor:" , i)  ;
                scanf("%c" , forest[i] -> ch) ;
                printf("input the No.%d HuffTree's charactor:" , i) ;
                scanf("%d" , forest[i] -> weight) ;
                forest[i] -> right = NULL ;
                forest[i] -> left = NULL ;
        }
        Huffman(forest , num) ;
        return 0 ;
}