定義：
給定n個權值作爲n個葉子結點，構造一棵二叉樹，若帶權路徑長度達到最小，稱這樣的二叉樹爲最優二叉樹，也稱爲哈夫曼樹(Huffman tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。
構造：
1.構成初始集合
對給定的n個權值{W1,W2,W3,...,Wi,...,Wn}構成n棵二叉樹的初始集合F={T1,T2,T3,...,Ti,...,Tn}，其中每棵二叉樹Ti中只有一個權值爲Wi的根結點，它的左右子樹均爲空。（爲方便在計算機上實現算法，一般還要求以Ti的權值Wi的升序排列。）
2.選取左右子樹
在F中選取兩棵根結點權值最小的樹作爲新構造的二叉樹的左右子樹，新二叉樹的根結點的權值爲其左右子樹的根結點的權值之和。
3.刪除左右子樹
從F中刪除這兩棵樹，並把這棵新的二叉樹同樣以升序排列加入到集合F中。
4.重複二和三兩步，直到集合F中只有一棵二叉樹爲止。
對給定的n個權值{W1,W2,W3,...,Wi,...,Wn}構成n棵二叉樹的初始集合F={T1,T2,T3,...,Ti,...,Tn}，其中每棵二叉樹Ti中只有一個權值爲Wi的根結點，它的左右子樹均爲空。（爲方便在計算機上實現算法，一般還要求以Ti的權值Wi的升序排列。）
2.選取左右子樹
在F中選取兩棵根結點權值最小的樹作爲新構造的二叉樹的左右子樹，新二叉樹的根結點的權值爲其左右子樹的根結點的權值之和。
3.刪除左右子樹
從F中刪除這兩棵樹，並把這棵新的二叉樹同樣以升序排列加入到集合F中。
4.重複二和三兩步，直到集合F中只有一棵二叉樹爲止。
c++代碼實現
#include<iostream>
#include<stdlib.h>
using namespace std;
const int MaxValue =10000;//初始設定的權值最大值
const int MaxBit =4;//初始設定的最大編碼位數
const int MaxN=10;//初始設定的最大結點個數
struct HaffNode//哈夫曼樹的結點結構
{
int weight;//權值
int flag;//標記
int parent;//雙親結點下標
int leftChild;//左孩子下標
int rightChild;//右孩子下標
};
struct Code//存放哈夫曼編碼的數據元素結構
{
int bit[MaxBit];//數組
int start;//編碼的起始下標
int weight;//字符的權值
};
//weight[]:由小到大排序
void Haffman(int weight[], int n, HaffNode haffTree[])
//建立葉結點個數爲n權值爲weight的哈夫曼樹haffTree
{
int j,m1,m2,x1,x2;
//哈夫曼樹haffTree初始化。n個葉結點的哈夫曼樹共有2n-1個結點
for(int i=0;i<2*n-1;i++)
{
if(i<n)
haffTree[i].weight=weight[i];
else
haffTree[i].weight=0;
//注意這裏沒打else那{}，故無論是n個葉子節點還是n-1個非葉子節點都會進行下面4步的初始化
haffTree[i].parent=0;
haffTree[i].flag=0;
haffTree[i].leftChild=-1;
haffTree[i].rightChild=-1;
}
//構造哈夫曼樹haffTree的n-1個非葉結點
for(int i=0;i<n-1;i++)
{
m1=m2=MaxValue;//Maxvalue=10000;(就是一個相當大的數)
x1=x2=0;//x1、x2是用來保存最小的兩個值在數組對應的下標
for(j=i;j<n+i;j++)//循環找出所有權重中，最小的二個值--morgan
{
if(haffTree[j].weight<m1&&haffTree[j].flag==0)
{
m2=m1;
x2=x1;
m1=haffTree[j].weight;
x1=j;
}
else if(haffTree[j].weight<m2&&haffTree[j].flag==0)
{
m2=haffTree[j].weight;
x2=j;
}
}
cout<<"i="<<i<<" "<<m1<<" "<<m2<<endl;
//將找出的兩棵權值最小的子樹合併爲一棵子樹
haffTree[x1].parent=n+i;
haffTree[x2].parent=n+i;
haffTree[x1].flag=1;
haffTree[x2].flag=1;
haffTree[n+i].weight=haffTree[x1].weight+haffTree[x2].weight;
haffTree[n+i].leftChild=x1;
haffTree[n+i].rightChild=x2;
}
}
void HaffmanCode(HaffNode haffTree[],int n,Code haffCode[])
//由n個結點的哈夫曼樹haffTree構造哈夫曼編碼haffCode
{
Code*cd=new Code;
int child, parent;
//求n個葉結點的哈夫曼編碼
for(int i=0;i<n;i++)
{
//cd->start=n-1;//不等長編碼的最後一位爲n-1,
cd->start=0;//,----修改從0開始計數--morgan
cd->weight=haffTree[i].weight;//取得編碼對應權值的字符
child=i;
parent=haffTree[child].parent;
//由葉結點向上直到根結點
while(parent!=0)
{
if(haffTree[parent].leftChild==child)
cd->bit[cd->start]=0;//左孩子結點編碼0
else
cd->bit[cd->start]=1;//右孩子結點編碼1
//cd->start--;
cd->start++;//改成編碼自增--morgan
child=parent;
parent=haffTree[child].parent;
}
//保存葉結點的編碼和不等長編碼的起始位
//for(intj=cd->start+1;j<n;j++)
for(int j=cd->start-1;j>=0;j--)//重新修改編碼，從根節點開始計數--morgan
haffCode[i].bit[cd->start-j-1]=cd->bit[j];
haffCode[i].start=cd->start;
haffCode[i].weight=cd->weight;//保存編碼對應的權值
}
}
int main()
{
int i, j, n=4,m=0;
int weight[]={2,4,5,7};
//int weight[]={7,5,4,2};
HaffNode*myHaffTree=new HaffNode[2*n-1];
Code*myHaffCode=new Code[n];
if(n>MaxN)
{
cout<<"定義的n越界，修改MaxN!"<<endl;
exit(0);
}
Haffman(weight,n,myHaffTree);
HaffmanCode(myHaffTree,n,myHaffCode);
//輸出每個葉結點的哈夫曼編碼
for(i=0;i<n;i++)
{
cout<<"Weight="<<myHaffCode[i].weight<<" Code=";
//for(j=myHaffCode[i].start+1;j<n;j++)
for(j=0;j<myHaffCode[i].start;j++)
cout<<myHaffCode[i].bit[j];
m=m+myHaffCode[i].weight*myHaffCode[i].start;
cout<<" 長度："<<myHaffCode[i].start<<endl;
}
cout<<"huffman'sWPLis:";
cout<<m;
cout<<endl;
return 0;
}c代碼實現：
/*-------------------------------------------------------------------------
* Name: 哈夫曼編碼源代碼。
* Date: 2011.04.16
* Author: Jeffrey Hill+Jezze(解碼部分)
* 在 Win-TC 下測試通過
* 實現過程：着先通過 HuffmanTree() 函數構造哈夫曼樹，然後在主函數 main()中
* 自底向上開始(也就是從數組序號爲零的結點開始)向上層層判斷，若在
* 父結點左側，則置碼爲 0,若在右側,則置碼爲 1。最後輸出生成的編碼。
*------------------------------------------------------------------------*/
#include <stdio.h>
#include<stdlib.h>
#define MAXBIT 100
#define MAXVALUE 10000
#define MAXLEAF 30
#define MAXNODE MAXLEAF*2 -1
typedef struct
{
int bit[MAXBIT];
int start;
} HCodeType; /* 編碼結構體 */
typedef struct
{
int weight;
int parent;
int lchild;
int rchild;
int value;
} HNodeType; /* 結點結構體 */
/* 構造一顆哈夫曼樹 */
void HuffmanTree (HNodeType HuffNode[MAXNODE], int n)
{
/* 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; //實際值，可根據情況替換爲字母
} /* end for */
/* 輸入 n 個葉子結點的權值 */
for (i=0; i<n; i++)
{
printf ("Please input weight of leaf node %d: \n", i);
scanf ("%d", &HuffNode[i].weight);
} /* end for */
/* 循環構造 Huffman 樹 */
for (i=0; i<n-1; i++)
{
m1=m2=MAXVALUE; /* 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 ("x1.weight and x2.weight in round %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);
}
}
int main(void)
{
HNodeType HuffNode[MAXNODE]; /* 定義一個結點結構體數組 */
HCodeType HuffCode[MAXLEAF], cd; /* 定義一個編碼結構體數組， 同時定義一個臨時變量來存放求解編碼時的信息 */
int i, j, c, p, n;
char pp[100];
printf ("Please input n:\n");
scanf ("%d", &n);
HuffmanTree (HuffNode, n);
for (i=0; 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 's Huffman code is: ", 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("Decoding?Please Enter code:\n");
scanf("%s",&pp);
decodeing(pp,HuffNode,n);
getch();
return 0;
}參考：