一：什麼是最優二叉樹？

最優二叉樹就是從已給出的目標帶權結點(單獨的結點) 經過一種方式的組合形成一棵樹.使樹的權值最小. 最優二叉樹是帶權路徑長度最短的二叉樹。根據結點的個數，權值的不同，最優二叉樹的形狀也各不相同。它們的共同點是：帶權值的結點都是葉子結點。權值越小的結點，其到根結點的路徑越長。

官方定義：

在權為w_l，w₂，…，w_n的n個葉子所構成的所有二叉樹中，帶權路徑長度最小(即代價最小)的二叉樹稱為最優二叉樹或哈夫曼樹。

二：下面先弄清幾個幾個概念：

1.路徑長度

在樹中從一個結點到另一個結點所經歷的分支構成了這兩個結點間的路徑上的分支數稱為它的路徑長度。

2．樹的路徑長度

三：用一個例子來理解一下以上概念

【例】給定4個葉子結點a，b，c和d，分別帶權7，5，2和4。構造如下圖所示的三棵二叉樹(還有許多棵)，它們的帶權路徑長度分別為：

        (a)WPL=7*2+5*2+2*2+4*2=36
        (b)WPL=7*3+5*3+2*1+4*2=46
        (c)WPL=7*1+5*2+2*3+4*3=35

其中(c)樹的WPL最小，可以驗證，它就是哈夫曼樹。

注意：
    ① 葉子上的權值均相同時，完全二叉樹一定是最優二叉樹，否則完全二叉樹不一定是最優二叉樹。
    ② 最優二叉樹中，權越大的葉子離根越近。
    ③ 最優二叉樹的形態不唯一，WPL最小。

四.哈夫曼演算法

對於給定的葉子數目及其權值構造最優二叉樹的方法，由於這個演算法是哈夫曼提出來的，故稱其為哈夫曼演算法。其基本思想是：
　　(1)根據給定的n個權值w_l，w₂，…，w_n構成n棵二叉樹的森林F={T₁，T₂，…，T_n}，其中每棵二叉樹T_i中都只有一個權值為w_i的根結點，其左右子樹均空。
　　(2)在森林F中選出兩棵根結點權值最小的樹(當這樣的樹不止兩棵樹時，可以從中任選兩棵)，將這兩棵樹合併成一棵新樹，為了保證新樹仍是二叉樹，需 要增加一個新結點作為新樹的根，並將所選的兩棵樹的根分別作為新根的左右孩子(誰左，誰右無關緊要)，將這兩個孩子的權值之和作為新樹根的權值。
　　(3)對新的森林F重複(2)，直到森林F中只剩下一棵樹為止。這棵樹便是哈夫曼樹。 
  注意：
    ① 初始森林中的n棵二叉樹，每棵樹有一個孤立的結點，它們既是根，又是葉子
    ② n個葉子的哈夫曼樹要經過n-1次合併，產生n-1個新結點。最終求得的哈夫曼樹中共有2n-1個結點。
    ③ 哈夫曼樹是嚴格的二叉樹，沒有度數為1的分支結點。

五：最優二叉樹演算法具體實現思路

在構造哈夫曼樹時，可以設定一個結構陣列HuffNode儲存哈夫曼樹中各結點的資訊，根據二叉樹的性質可知，具有n個葉子結點的哈夫曼樹共有2n－1個結點，所以陣列HuffNode的大小設定為2n－1，陣列元素的結構形式如下：  

其中，weight域儲存結點的權值，lchild和rchild域分別儲存該結點的左、右孩子結點在陣列HuffNode中的序號，從而建立起結 點之間的關係。為了判定一個結點是否已加入到要建立的哈夫曼樹中，可通過parent域的值來確定。初始時parent的值為－1，當結點加入到樹中時， 該結點parent的值為其雙親結點在陣列HuffNode中的序號，就不會是－1了。構造哈夫曼樹時，首先將由n個字元形成的n個葉結點存放到陣列HuffNode的前n個分量中，然後根據前面介紹的哈夫曼方法的基本思想，不斷將兩個小子樹合併為一個較大的子樹，每次構成的新子樹的根結點順序放到HuffNode陣列中的前n個分量的後面。

/*霍夫曼編碼的C語言實現二*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAXBIT 100
#define MAXVALUE 10000
#define MAXLEAF 30
#define MAXNODE MAXLEAF*2 -1
 
//編碼結構體
typedef struct 
{
    int bit[MAXBIT]; //MAXBIT = 100  最多存放100個編碼
    int start;
	
}HCodeType;        

//結點結構體
typedef struct
{
    int weight; //權
    int parent;  //父節點
    int lchild;  //左孩子節點
    int rchild;  //右孩子節點
    int value; //實際值
}HNodeType;        
 
/* 構造一顆哈夫曼樹 */
void HuffmanTree(HNodeType HuffNode[MAXNODE], int n)  //MAXNODE = 30*2 -1 = 59
{ 
    /* i、j： 迴圈變數，m1、m2：構造哈夫曼樹不同過程中兩個最小權值結點的權值，
      x1、x2：構造哈夫曼樹不同過程中兩個最小權值結點在陣列中的序號。*/
    int i, j, m1, m2, x1, x2;
	
    /* 初始化存放哈夫曼樹陣列 HuffNode[] 中的結點 */
    for (i=0; i<2*n-1; i++)
    {
        HuffNode[i].weight = 0;//權值 
        HuffNode[i].parent =-1;
        HuffNode[i].lchild =-1;
        HuffNode[i].rchild =-1;
        HuffNode[i].value=i; //實際值，可根據情況替換為字母  
    }
 
    //輸入 n 個葉子結點的權值 
    for (i=0; i<n; i++)
    {
        printf("輸入第%d個節點的權值:\n", i);
        scanf("%d", &HuffNode[i].weight);
    }
 
    /* 迴圈構造 Huffman 樹 */
    for (i=0; i<n-1; i++)
    {
        m1 = m2 = MAXVALUE; /* MAXVALUE = 10000 //m1、m2中存放兩個無父結點且結點權值最小的兩個結點 */
        x1 = x2 = 0;
		
        /* 找出所有結點中權值最小、無父結點的兩個結點，併合並之為一顆二叉樹 */
        for (j=0; j<n+i; j++)
        {
            if (HuffNode[j].weight < m1 && HuffNode[j].parent == -1)
            {
                m2 = m1; 
                x2 = x1; 
                m1 = HuffNode[j].weight;
                x1 = j;
            }
            else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1)
            {
                m2=HuffNode[j].weight;
                x2=j;
            }
        } /* end for */
            /* 設定找到的兩個子結點 x1、x2 的父結點資訊 */
        HuffNode[x1].parent  = n+i;
        HuffNode[x2].parent  = n+i;
        HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
        HuffNode[n+i].lchild = x1;
        HuffNode[n+i].rchild = x2;
 
        printf ("第%d次==》左節點和右節點的權值為: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight);  /* 用於測試 */
        printf ("\n");
    } /* end for */
  /*  for(i=0;i<n+2;i++)
    {
        printf(" Parents:%d,lchild:%d,rchild:%d,value:%d,weight:%d\n",HuffNode[i].parent,HuffNode[i].lchild,HuffNode[i].rchild,HuffNode[i].value,HuffNode[i].weight);
                  }*///測試 
} /* end HuffmanTree */
 
//解碼 
void decodeing(char string[],HNodeType Buf[],int Num)
{
  int i,tmp=0,code[1024];
  int m=2*Num-1;
  char *nump;
  char num[1024];
  for(i=0;i<strlen(string);i++)
  {
	if(string[i]=='0')
		num[i]=0;        
	else
		num[i]=1;                    
  } 
  
	i=0;
	nump=&num[0];
  
	while(nump<(&num[strlen(string)]))
	{
		tmp=m-1;
		while((Buf[tmp].lchild!=-1)&&(Buf[tmp].rchild!=-1))
		{
			if(*nump==0)
			{
				tmp=Buf[tmp].lchild ;          
			} 
			else 
			{
				tmp=Buf[tmp].rchild;
			}
		nump++;     
		} 
		printf("%d",Buf[tmp].value);                                  
	}
	printf("\n");
}
 
int main(void)
{ 
    HNodeType HuffNode[MAXNODE];            /* 定義一個結點結構體陣列 */
    HCodeType HuffCode[MAXLEAF],  cd;       /* 定義一個編碼結構體陣列， 同時定義一個臨時變數來存放求解編碼時的資訊 */
    int i, j, c, p, n;
    char pp[100];
    printf ("輸入編碼數量:");
    scanf ("%d", &n);
    HuffmanTree (HuffNode, n);
     
    for (i=1; i < n; i++)
    {
        cd.start = n-1;
        c = i;
        p = HuffNode[c].parent;
        while (p != -1)   /* 父結點存在 */
        {
            if (HuffNode[p].lchild == c)
                cd.bit[cd.start] = 0;
            else
                cd.bit[cd.start] = 1;
            cd.start--;        /* 求編碼的低一位 */
            c=p;                    
            p=HuffNode[c].parent;    /* 設定下一迴圈條件 */
        } /* end while */
        
        /* 儲存求出的每個葉結點的哈夫曼編碼和編碼的起始位 */
        for (j=cd.start+1; j<n; j++)
        { 
			HuffCode[i].bit[j] = cd.bit[j];
		}
        HuffCode[i].start = cd.start;
    } /* end for */
    
    /* 輸出已儲存好的所有存在編碼的哈夫曼編碼 */
    for (i=0; i<n; i++)
    {
        printf ("%d '的哈夫曼編碼是: ", i);
        for (j=HuffCode[i].start+1; j < n; j++)
        {
            printf ("%d", HuffCode[i].bit[j]);
        }
        printf(" start:%d",HuffCode[i].start);
        printf ("\n");  
    }
/*  for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			printf ("%d", HuffCode[i].bit[j]);           
		}
        printf("\n");
    }*/
    printf("解碼（輸入二進位制編碼）:\n");
    scanf("%s", pp);
	decodeing(pp, HuffNode, n);
    getchar();
	
    return 0;
}