哈夫曼樹的介紹

Huffman Tree，中文名是哈夫曼樹或霍夫曼樹或者赫夫曼樹，它是最優二叉樹。

定義：給定n個權值作為n個葉子結點，構造一棵二叉樹，若樹的帶權路徑長度達到最小，則這棵樹被稱為哈夫曼樹。 

(01) 路徑和路徑長度

定義：在一棵樹中，從一個結點往下可以達到的孩子或孫子結點之間的通路，稱為路徑。通路中分支的數目稱為路徑長度。若規定根結點的層數為1，則從根結點到第L層結點的路徑長度為L-1。 

(02) 結點的權及帶權路徑長度

定義：若將樹中結點賦給一個有著某種含義的數值，則這個數值稱為該結點的權。結點的帶權路徑長度為：從根結點到該結點之間的路徑長度與該結點的權的乘積。 

(03) 樹的帶權路徑長度

定義：樹的帶權路徑長度規定為所有葉子結點的帶權路徑長度之和，記為WPL。 

哈夫曼樹的解析：

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

1. 將w1、w2、…，wn看成是有n 棵樹的森林(每棵樹僅有一個結點)； 
2. 在森林中選出根結點的權值最小的兩棵樹進行合併，作為一棵新樹的左、右子樹，且新樹的根結點權值為其左、右子樹根結點權值之和； 
3. 從森林中刪除選取的兩棵樹，並將新樹加入森林； 
4. 重複(02)、(03)步，直到森林中只剩一棵樹為止，該樹即為所求得的哈夫曼樹。

以{5,6,7,8,15}為例，來構造一棵哈夫曼樹。

第1步：建立森林，森林包括5棵樹，這5棵樹的權值分別是5,6,7,8,15。 
第2步：在森林中，選擇根節點權值最小的兩棵樹(5和6)來進行合併，將它們作為一顆新樹的左右孩子(誰左誰右無關緊要，這裡，我們選擇較小的作為左孩子)，並且新樹的權值是左右孩子的權值之和。即，新樹的權值是11。 然後，將"樹5"和"樹6"從森林中刪除，並將新的樹(樹11)新增到森林中。 
第3步：在森林中，選擇根節點權值最小的兩棵樹(7和8)來進行合併。得到的新樹的權值是15。 然後，將"樹7"和"樹8"從森林中刪除，並將新的樹(樹15)新增到森林中。 
第4步：在森林中，選擇根節點權值最小的兩棵樹(11和15)來進行合併。得到的新樹的權值是26。 然後，將"樹11"和"樹15"從森林中刪除，並將新的樹(樹26)新增到森林中。 
第5步：在森林中，選擇根節點權值最小的兩棵樹(15和26)來進行合併。得到的新樹的權值是41。 然後，將"樹15"和"樹26"從森林中刪除，並將新的樹(樹41)新增到森林中。 
此時，森林中只有一棵樹(樹41)。這棵樹就是我們需要的哈夫曼樹！

哈夫曼樹的基本操作：

　在上述儲存結構上實現的哈夫曼演算法可大致描述為(設T的型別為HuffmanTree)：　(1)初始化   　 將T[0．．m-1]中2n-1個結點裡的三個指標均置為空(即置為-1)，權值置為0。　(2)輸入    　讀入n個葉子的權值存於向量的前n個分量(即T[0．．n-1])中。它們是初始森林中n個孤立的根結點上的權值。　(3)合併    　對森林中的樹共進行n-1次合併，所產生的新結點依次放人向量T的第i個分量中(n≤i≤m-1)。每次合併分兩步：    　①在當前森林T[0．．i-1]的所有結點中，選取權最小和次小的兩個根結點[p1]和T[p2]作為合併物件，這裡0≤p1，p2≤i-1。    　② 將根為T[p1]和T[p2]的兩棵樹作為左右子樹合併為一棵新的樹，新樹的根是新結點T[i]。具體操作：　　將T[p1]和T[p2]的parent置為i，　　將T[i]的lchild和rchild分別置為p1和p2　　新結點T[i]的權值置為T[p1]和T[p2]的權值之和。  注意：   　 合併後T[pl]和T[p2]在當前森林中已不再是根，因為它們的雙親指標均已指向了T[i]，所以下一次合併時不會被選中為合併物件。

哈夫曼樹的儲存結構：

<span style="font-size:18px;">/*
哈夫曼樹的儲存結構，它也是一種二叉樹結構，
這種儲存結構既適合表示樹，也適合表示森林。
*/
typedef struct Node
{
int weight;                //權值
int parent;                //父節點的序號，為-1的是根節點
int lchild,rchild;         //左右孩子節點的序號，為-1的是葉子節點
}HTNode,*HuffmanTree;          //用來儲存哈夫曼樹中的所有節點
typedef char **HuffmanCode;    //用來儲存每個葉子節點的哈夫曼編碼</span>

根據哈夫曼樹的構建步驟，寫出構建哈夫曼樹的程式碼如下：

<span style="font-size:18px;">/*
根據給定的n個權值構造一棵赫夫曼樹,wet中存放n個權值
*/
HuffmanTree create_HuffmanTree(int *wet,int n)
{
//一棵有n個葉子節點的赫夫曼樹共有2n-1個節點
int total = 2*n-1;
HuffmanTree HT = (HuffmanTree)malloc(total*sizeof(HTNode));
if(!HT)
{
printf("HuffmanTree malloc faild!");
exit(-1);
}
int i;
 
//以下初始化序號全部用-1表示，
//這樣在編碼函式中進行迴圈判斷parent或lchild或rchild的序號時，
//不會與HT陣列中的任何一個下標混淆
 
//HT[0],HT[1]...HT[n-1]中存放需要編碼的n個葉子節點
for(i=0;i<n;i++)
{
HT[i].parent = -1;
HT[i].lchild = -1;
HT[i].rchild = -1;
HT[i].weight = *wet;
wet++;
}
 
//HT[n],HT[n+1]...HT[2n-2]中存放的是中間構造出的每棵二叉樹的根節點
for(;i<total;i++)
{
HT[i].parent = -1;
HT[i].lchild = -1;
HT[i].rchild = -1;
HT[i].weight = 0;
}
 
int min1,min2; //用來儲存每一輪選出的兩個weight最小且parent為0的節點
//每一輪比較後選擇出min1和min2構成一課二叉樹,最後構成一棵赫夫曼樹
for(i=n;i<total;i++)
{
select_minium(HT,i,min1,min2);
HT[min1].parent = i;
HT[min2].parent = i;
//這裡左孩子和右孩子可以反過來，構成的也是一棵赫夫曼樹，只是所得的編碼不同
HT[i].lchild = min1;
HT[i].rchild = min2;
HT[i].weight =HT[min1].weight + HT[min2].weight;
}
return HT;
}</span>

上述程式碼中呼叫到了select_minium（）函式，它表示從集合中選出兩個最小的二叉樹，下面列出兩種求兩個最小值的方法。

方法一程式碼如下：

<span style="font-size:18px;">/*
從HT陣列的前k個元素中選出weight最小且parent為-1的兩個，分別將其序號儲存在min1和min2中
*/
void select_minium(HuffmanTree HT,int k,int &min1,int &min2)
{
   min1 = min(HT,k);
   min2 = min(HT,k);
}</span>

這裡呼叫到的min（）函式程式碼如下：

<span style="font-size:18px;">/*
從HT陣列的前k個元素中選出weight最小且parent為-1的元素，並將該元素的序號返回
*/
int min(HuffmanTree HT,int k)
{
   int i = 0;
   int min;        //用來存放weight最小且parent為-1的元素的序號
   int min_weight; //用來存放weight最小且parent為-1的元素的weight值
 
//先將第一個parent為-1的元素的weight值賦給min_weight,留作以後比較用。
//注意，這裡不能按照一般的做法，先直接將HT[0].weight賦給min_weight，
//因為如果HT[0].weight的值比較小，那麼在第一次構造二叉樹時就會被選走，
//而後續的每一輪選擇最小權值構造二叉樹的比較還是先用HT[0].weight的值來進行判斷，
//這樣又會再次將其選走，從而產生邏輯上的錯誤。
   while(HT[i].parent != -1)
   i++;
   min_weight = HT[i].weight;
   min = i;
 
//選出weight最小且parent為-1的元素，並將其序號賦給min
   for(;i<k;i++)
  {
     if(HT[i].weight<min_weight && HT[i].parent==-1)
      {
        min_weight = HT[i].weight;
        min = i;
      }
  }
 
   //選出weight最小的元素後，將其parent置1，使得下一次比較時將其排除在外。
   HT[min].parent = 1;
   return min;
}</span>

方法二程式碼如下：

<span style="font-size:18px;">/*
從HT陣列的前k個元素中選出weight最小且parent為-1的兩個，分別將其序號儲存在min1和min2中
*/
void select_minium(HuffmanTree HT,int k,int &min1,int &min2)
{
int i = 0;
   Int tempMin;
while(HT[i].parent != -1)
i++;
min1 = HT[i].weight;
while(HT[i].parent != -1)
i++;
min2 = HT[i].weight;
if(min1>min2)
{
tempMin = min1;
min1=min2;
Min2=tempMin;
}
//選出weight最小且parent為-1的元素，並將其序號賦給min
for(;i<k;i++)
{
if(HT[i].weight<min1 && HT[i].parent==-1)//min1始終儲存最小的，min2儲存第二小的資料
{
min2 = min1;
min1 = HT[i].weight;
}else if(HT[i].weight<min2 && HT[i].parent==-1)
{
Min2 = HT[i].weight;
}
}
}</span>

構建了赫夫曼樹，便可以進行赫夫曼編碼了，要求赫夫曼編碼，就需要遍歷出從根節點到葉子節點的路徑，下面給出兩種遍歷赫夫曼樹求編碼的方法。

1、 採用從葉子節點到根節點逆向遍歷求每個字元的赫夫曼編碼，程式碼如下：

<span style="font-size:18px;">/*
從葉子節點到根節點逆向求赫夫曼樹HT中n個葉子節點的赫夫曼編碼，並儲存在HC中
*/
void HuffmanCoding(HuffmanTree HT,HuffmanCode &HC,int n)
{
//用來儲存指向每個赫夫曼編碼串的指標
HC = (HuffmanCode)malloc(n*sizeof(char *));
if(!HC)
{
printf("HuffmanCode malloc faild!");
exit(-1);
}
 
//臨時空間，用來儲存每次求得的赫夫曼編碼串
//對於有n個葉子節點的赫夫曼樹，各葉子節點的編碼長度最長不超過n-1
//外加一個'\0'結束符，因此分配的陣列長度最長為n即可
char *code = (char *)malloc(n*sizeof(char));
if(!code)
{
printf("code malloc faild!");
exit(-1);
}
 
code[n-1] = '\0';  //編碼結束符，亦是字元陣列的結束標誌
//求每個字元的赫夫曼編碼
int i;
for(i=0;i<n;i++)
{
int current = i;           //定義當前訪問的節點
int father = HT[i].parent; //當前節點的父節點
int start = n-1;           //每次編碼的位置，初始為編碼結束符的位置
//從葉子節點遍歷赫夫曼樹直到根節點
while(father != -1)
{
if(HT[father].lchild == current)   //如果是左孩子，則編碼為0
code[--start] = '0';   
else                              //如果是右孩子，則編碼為1      
code[--start] = '1';
current = father;
father = HT[father].parent;
}
 
//為第i個字元的編碼串分配儲存空間
HC[i] = (char *)malloc((n-start)*sizeof(char));
if(!HC[i])
{
printf("HC[i] malloc faild!");
exit(-1);
}
//將編碼串從code複製到HC
strcpy(HC[i],code+start);
}
 
free(code); //釋放儲存編碼串的臨時空間
}</span>

2、採用從根節點到葉子節點無棧非遞迴遍歷赫夫曼樹，求每個字元的赫夫曼編碼，程式碼如下：

<span style="font-size:18px;">/*
從根節點到葉子節點無棧非遞迴遍歷赫夫曼樹HT，求其中n個葉子節點的赫夫曼編碼，並儲存在HC中
*/
void HuffmanCoding2(HuffmanTree HT,HuffmanCode &HC,int n)
{
//用來儲存指向每個赫夫曼編碼串的指標
HC = (HuffmanCode)malloc(n*sizeof(char *));
if(!HC)
{
printf("HuffmanCode malloc faild!");
exit(-1);
}
 
//臨時空間，用來儲存每次求得的赫夫曼編碼串
//對於有n個葉子節點的赫夫曼樹，各葉子節點的編碼長度最長不超過n-1
//外加一個'\0'結束符，因此分配的陣列長度最長為n即可
char *code = (char *)malloc(n*sizeof(char));
if(!code)
{
printf("code malloc faild!");
exit(-1);
}
 
int cur = 2*n-2;    //當前遍歷到的節點的序號，初始時為根節點序號
int code_len = 0;   //定義編碼的長度
 
//構建好赫夫曼樹後，把weight用來當做遍歷樹時每個節點的狀態標誌
//weight=0表明當前節點的左右孩子都還沒有被遍歷
//weight=1表示當前節點的左孩子已經被遍歷過，右孩子尚未被遍歷
//weight=2表示當前節點的左右孩子均被遍歷過
int i;
for(i=0;i<cur+1;i++)
{
HT[i].weight = 0;  
}
 
//從根節點開始遍歷，最後回到根節點結束
//當cur為根節點的parent時，退出迴圈
while(cur != -1)
{
//左右孩子均未被遍歷，先向左遍歷
if(HT[cur].weight == 0)  
{
HT[cur].weight = 1;    //表明其左孩子已經被遍歷過了
if(HT[cur].lchild != -1) 
{   //如果當前節點不是葉子節點，則記下編碼，並繼續向左遍歷
code[code_len++] = '0';
cur = HT[cur].lchild;
}
else
{   //如果當前節點是葉子節點，則終止編碼，並將其儲存起來
code[code_len] = '\0';
HC[cur] = (char *)malloc((code_len+1)*sizeof(char));
if(!HC[cur])
{
printf("HC[cur] malloc faild!");
exit(-1);
}
strcpy(HC[cur],code);  //複製編碼串
}
}
 
//左孩子已被遍歷，開始向右遍歷右孩子
else if(HT[cur].weight == 1)  
{
HT[cur].weight = 2;   //表明其左右孩子均被遍歷過了
if(HT[cur].rchild != -1)
{   //如果當前節點不是葉子節點，則記下編碼，並繼續向右遍歷
code[code_len++] = '1';
cur = HT[cur].rchild;
}
}
 
//左右孩子均已被遍歷，退回到父節點，同時編碼長度減1
else
{
HT[cur].weight = 0;
cur = HT[cur].parent;
--code_len;
}
 
}
free(code);
}</span>