看到的講解huffman樹的一篇比較好懂的部落格

出處:http://blog.csdn.net/wtfmonking/article/details/17150499#

1、基本概念

a、路徑和路徑長度

若在一棵樹中存在著一個結點序列 k1，k2，……，kj， 使得 ki是ki+1 的雙親（1<=i<j），則稱此結點序列是從 k1 到 kj 的路徑。

從 k1 到 kj 所經過的分支數稱為這兩點之間的路徑長度，它等於路徑上的結點數減1.

b、結點的權和帶權路徑長度

在許多應用中，常常將樹中的結點賦予一個有著某種意義的實數，我們稱此實數為該結點的權，(如下面一個樹中的藍色數字表示結點的權)

結點的帶權路徑長度規定為從樹根結點到該結點之間的路徑長度與該結點上權的乘積。

c、樹的帶權路徑長度

樹的帶權路徑長度定義為樹中所有葉子結點的帶權路徑長度之和，公式為：

其中，n表示葉子結點的數目，wi 和 li 分別表示葉子結點 ki 的權值和樹根結點到 ki 之間的路徑長度。

如下圖中樹的帶權路徑長度 WPL = 9 x 2 + 12 x 2 + 15 x 2 + 6 x 3 + 3 x 4 + 5 x 4  =  122

d、哈夫曼樹

哈夫曼樹又稱最優二叉樹。它是 n 個帶權葉子結點構成的所有二叉樹中，帶權路徑長度 WPL 最小的二叉樹。

如下圖為一哈夫曼樹示意圖。

2、構造哈夫曼樹

假設有n個權值，則構造出的哈夫曼樹有n個葉子結點。 n個權值分別設為 w1、w2、…、wn，則哈夫曼樹的構造規則為：

(1) 將w1、w2、…，wn看成是有n 棵樹的森林(每棵樹僅有一個結點)；

(2) 在森林中選出兩個根結點的權值最小的樹合併，作為一棵新樹的左、右子樹，且新樹的根結點權值為其左、右子樹根結點權值之和；

(3)從森林中刪除選取的兩棵樹，並將新樹加入森林；

(4)重複(2)、(3)步，直到森林中只剩一棵樹為止，該樹即為所求得的哈夫曼樹。

 如：對 下圖中的六個帶權葉子結點來構造一棵哈夫曼樹，步驟如下：

注意：為了使得到的哈夫曼樹的結構儘量唯一，通常規定生成的哈夫曼樹中每個結點的左子樹根結點的權小於等於右子樹根結點的權。

具體演算法如下：

1. //2、根據陣列 a 中 n 個權值建立一棵哈夫曼樹，返回樹根指標
2. struct BTreeNode* CreateHuffman(ElemType a[], int n)  
3. {  
4.     int i, j;  
5.     struct BTreeNode **b, *q;  
6.     b = malloc(n*sizeof(struct BTreeNode));  
7.     for (i = 0; i < n; i++) //初始化b指標陣列，使每個指標元素指向a陣列中對應的元素結點
8.     {  
9.         b[i] = malloc(sizeof(struct BTreeNode));  
10.         b[i]->data = a[i];  
11.         b[i]->left = b[i]->right = NULL;  
12.     }  
13.     for (i = 1; i < n; i++)//進行 n-1 次迴圈建立哈夫曼樹
14.     {  
15.         //k1表示森林中具有最小權值的樹根結點的下標，k2為次最小的下標
16.         int k1 = -1, k2;  
17.         for (j = 0; j < n; j++)//讓k1初始指向森林中第一棵樹，k2指向第二棵
18.         {  
19.             if (b[j] != NULL && k1 == -1)  
20.             {  
21.                 k1 = j;  
22.                 continue;  
23.             }  
24.             if (b[j] != NULL)  
25.             {  
26.                 k2 = j;  
27.                 break;  
28.             }  
29.         }  
30.         for (j = k2; j < n; j++)//從當前森林中求出最小權值樹和次最小
31.         {  
32.             if (b[j] != NULL)  
33.             {  
34.                 if (b[j]->data < b[k1]->data)  
35.                 {  
36.                     k2 = k1;  
37.                     k1 = j;  
38.                 }  
39.                 elseif (b[j]->data < b[k2]->data)  
40.                     k2 = j;  
41.             }  
42.         }  
43.         //由最小權值樹和次最小權值樹建立一棵新樹，q指向樹根結點
44.         q = malloc(sizeof(struct BTreeNode));  
45.         q->data = b[k1]->data + b[k2]->data;  
46.         q->left = b[k1];  
47.         q->right = b[k2];  
48.         b[k1] = q;//將指向新樹的指標賦給b指標陣列中k1位置
49.         b[k2] = NULL;//k2位置為空
50.     }  
51.     free(b); //刪除動態建立的陣列b
52.     return q; //返回整個哈夫曼樹的樹根指標
53. }  

3、哈夫曼編碼

在電報通訊中，電文是以二進位制的0、1序列傳送的，每個字元對應一個二進位制編碼，為了縮短電文的總長度，採用不等長編碼方式，構造哈夫曼樹，

將每個字元的出現頻率作為字元結點的權值賦予葉子結點，每個分支結點的左右分支分別用0和1編碼，從樹根結點到每個葉子結點的路徑上

所經分支的0、1編碼序列等於該葉子結點的二進位制編碼。如上文所示的哈夫曼編碼如下：

a 的編碼為：00

b 的編碼為：01

c 的編碼為：100

d 的編碼為：1010

e 的編碼為：1011

f 的編碼為：11

4、哈夫曼樹的操作運算

以上文的哈夫曼樹作為具體例項，用詳細的程式展示哈夫曼樹的操作運算

1. #include<stdio.h>
2. #include<stdlib.h>
3. typedefint ElemType;  
4. struct BTreeNode  
5. {  
6.     ElemType data;  
7.     struct BTreeNode* left;  
8.     struct BTreeNode* right;  
9. };  
10. //1、輸出二叉樹，可在前序遍歷的基礎上修改。採用廣義表格式，元素型別為int
11. void PrintBTree_int(struct BTreeNode* BT)  
12. {  
13.     if (BT != NULL)  
14.     {  
15.         printf("%d", BT->data); //輸出根結點的值
16.         if (BT->left != NULL || BT->right != NULL)  
17.         {  
18.             printf("(");  
19.             PrintBTree_int(BT->left); //輸出左子樹
20.             if (BT->right != NULL)  
21.                 printf(",");  
22.             PrintBTree_int(BT->right); //輸出右子樹
23.             printf(")");  
24.         }  
25.     }  
26. }  
27. //2、根據陣列 a 中 n 個權值建立一棵哈夫曼樹，返回樹根指標
28. struct BTreeNode* CreateHuffman(ElemType a[], int n)  
29. {  
30.     int i, j;  
31.     struct BTreeNode **b, *q;  
32.     b = malloc(n*sizeof(struct BTreeNode));  
33.     for (i = 0; i < n; i++) //初始化b指標陣列，使每個指標元素指向a陣列中對應的元素結點
34.     {  
35.         b[i] = malloc(sizeof(struct BTreeNode));  
36.         b[i]->data = a[i];  
37.         b[i]->left = b[i]->right = NULL;  
38.     }  
39.     for (i = 1; i < n; i++)//進行 n-1 次迴圈建立哈夫曼樹
40.     {  
41.         //k1表示森林中具有最小權值的樹根結點的下標，k2為次最小的下標
42.         int k1 = -1, k2;  
43.         for (j = 0; j < n; j++)//讓k1初始指向森林中第一棵樹，k2指向第二棵
44.         {  
45.             if (b[j] != NULL && k1 == -1)  
46.             {  
47.                 k1 = j;  
48.                 continue;  
49.             }  
50.             if (b[j] != NULL)  
51.             {  
52.                 k2 = j;  
53.                 break;  
54.             }  
55.         }  
56.         for (j = k2; j < n; j++)//從當前森林中求出最小權值樹和次最小
57.         {  
58.             if (b[j] != NULL)  
59.             {  
60.                 if (b[j]->data < b[k1]->data)  
61.                 {  
62.                     k2 = k1;  
63.                     k1 = j;  
64.                 }  
65.                 elseif (b[j]->data < b[k2]->data)  
66.                     k2 = j;  
67.             }  
68.         }  
69.         //由最小權值樹和次最小權值樹建立一棵新樹，q指向樹根結點
70.         q = malloc(sizeof(struct BTreeNode));  
71.         q->data = b[k1]->data + b[k2]->data;  
72.         q->left = b[k1];  
73.         q->right = b[k2];  
74.         b[k1] = q;//將指向新樹的指標賦給b指標陣列中k1位置
75.         b[k2] = NULL;//k2位置為空
76.     }  
77.     free(b); //刪除動態建立的陣列b
78.     return q; //返回整個哈夫曼樹的樹根指標
79. }  
80. //3、求哈夫曼樹的帶權路徑長度
81. ElemType WeightPathLength(struct BTreeNode* FBT, int len)//len初始為0
82. {  
83.     if (FBT == NULL) //空樹返回0
84.         return 0;  
85.     else
86.     {  
87.         if (FBT->left == NULL && FBT->right == NULL)//訪問到葉子結點
88.             return FBT->data * len;  
89.         else//訪問到非葉子結點，進行遞迴呼叫，返回左右子樹的帶權路徑長度之和，len遞增
90.             return WeightPathLength(FBT->left,len+1)+WeightPathLength(FBT->right,len+1);  
91.     }  
92. }  
93. //4、哈夫曼編碼（可以根據哈夫曼樹帶權路徑長度的演算法基礎上進行修改）
94. void HuffManCoding(struct BTreeNode* FBT, int len)//len初始值為0
95. {  
96.     staticint a[10];//定義靜態陣列a，儲存每個葉子的編碼，陣列長度至少是樹深度減一
97.     if (FBT != NULL)//訪問到葉子結點時輸出其儲存在陣列a中的0和1序列編碼
98.     {  
99.         if (FBT->left == NULL && FBT->right == NULL)  
100.         {  
101.             int i;  
102.             printf("結點權值為%d的編碼：", FBT->data);  
103.             for (i = 0; i < len; i++)  
104.                 printf("%d", a[i]);  
105.             printf("\n");  
106.         }  
107.         else//訪問到非葉子結點時分別向左右子樹遞迴呼叫，並把分支上的0、1編碼儲存到陣列a
108.         {   //的對應元素中，向下深入一層時len值增1
109.             a[len] = 0;  
110.             HuffManCoding(FBT->left, len + 1);  
111.             a[len] = 1;  
112.             HuffManCoding(FBT->right, len + 1);  
113.         }  
114.     }  
115. }  
116. //主函式
117. void main()  
118. {  
119.     int n, i;  
120.     ElemType* a;  
121.     struct BTreeNode* fbt;  
122.     printf("從鍵盤輸入待構造的哈夫曼樹中帶權葉子結點數n：");  
123.     while(1)  
124.     {  
125.         scanf("%d", &n);  
126.         if (n > 1)  
127.             break;  
128.         else
129.             printf("重輸n值：");  
130.     }  
131.     a = malloc(n*sizeof(ElemType));  
132.     printf("從鍵盤輸入%d個整數作為權值：", n);  
133.     for (i = 0; i < n; i++)  
134.         scanf(" %d", &a[i]);  
135.     fbt = CreateHuffman(a, n);  
136.     printf("廣義表形式的哈夫曼樹：");  
137.     PrintBTree_int(fbt);  
138.     printf("\n");  
139.     printf("哈夫曼樹的帶權路徑長度：");  
140.     printf("%d\n", WeightPathLength(fbt, 0));  
141.     printf("樹中每個葉子結點的哈夫曼編碼：\n");  
142.     HuffManCoding(fbt, 0);  
143. }