java 二叉樹（十三） 哈夫曼樹和哈夫曼編碼
一般可以按下面步驟構建：
1，將所有左，右子樹都為空的作為根節點。
2，在森林中選出兩棵根節點的權值最小的樹作為一棵新樹的左，右子樹，且置新樹的附加根節點的權值為其左，右子樹上根節點的權值之和。注意，左子樹的權值應小於右子樹的權值。
3，從森林中刪除這兩棵樹，同時把新樹加入到森林中。
4，重複2，3步驟，直到森林中只有一棵樹為止，此樹便是哈夫曼樹。
下面是構建哈夫曼樹的圖解過程：
哈夫曼編碼
利用哈夫曼樹求得的用於通訊的二進位制編碼稱為哈夫曼編碼。樹中從根到每個葉子節點都有一條路徑，對路徑上的各分支約定指向左子樹的分支表示”0”碼，指向右子樹的分支表示“1”碼，取每條路徑上的“0”或“1”的序列作為各個葉子節點對應的字元編碼，即是哈夫曼編碼。
就拿上圖例子來說：
A，B，C，D對應的哈夫曼編碼分別為：111，10，110，0
用圖說明如下：
記住，設計電文總長最短的二進位制字首編碼，就是以n個字元出現的頻率作為權構造一棵哈夫曼樹，由哈夫曼樹求得的編碼就是哈夫曼編碼。
哈夫曼數的構造:
節點類
資料型別根據需要定義
Wight權重
Parent 父節點
Left child 左孩子
Right child右孩子
value實際值（比如是字串，字元之類的等等...）
編碼類
Bit[] 陣列的每一個元素存放每一個葉子節點的哈夫曼編碼的陣列
Start 哈夫曼編碼陣列的下標
樹類
構造樹
求編碼
解碼
測試類
權值陣列
實際值陣列
樹類： 首先要對有n個葉子節點的哈夫曼樹來說，樹共有2n-1個節點，有n-1個非葉子節點。
對所有節點初始化，節點的所有元素置-1，對n個葉子節點初始化的時候對權值和value進行賦值，
編碼：只需要對n個葉子節點進行編碼即可，對於有n個葉子節點哈夫曼編碼，每個編碼的最大長度為n-1位。
從每一個葉子節點開始，自底向上若左孩子的值為葉子節點則置當前bit的位為0，否則置1,注意對於置位是從第n-1位開始的。直到找到根節點，為止。
解碼：bit陣列的每一個元素都是一個葉子節點的二進位制編碼。從根節點（第n-1個節點為根節點）開始進行對比，從第一個元素開始，若其左孩子為
節點類：
package 哈夫曼數和哈夫曼編碼;
public class HNode {//節點類
int weight; //權值
int parent; //雙親節點
int leftChild; //左孩子
int rightChild; //右孩子
String value; //實際值
public HNode(){
}
}編碼類：
package 哈夫曼數和哈夫曼編碼;
public class HCode {//編碼類
public int bit[]; //求每一個葉子節點的哈夫曼編碼陣列
public int weight;
public int start; //編碼陣列開始的下標
public HCode(int n){
bit = new int[n];
// start = n-1;
}
}樹類：
package 哈夫曼數和哈夫曼編碼;
public class HTree { //樹類
public int maxvalue=1000; //用於比較求最小值
public int nodenum;
public HTree(int n){
this.nodenum=n; //節點個數
}
public void haffman(int[] weight,String[] value, HNode[] node){
int n = this.nodenum;
int m1,m2,x1,x2; //m1,m2表示最小河次小的權值，x1,x2,表示兩個最小權值對應的編號
//初始化所有節點，有n個葉子節點的哈夫曼樹，有2n-1個節點
for(int i=0;i<2*n-1;i++){
HNode temp = new HNode();
if(i<n){
temp.weight=weight[i];
temp.value=value[i];
}else{
temp.weight=0;
temp.value="";
}
temp.parent=-1;
temp.leftChild=-1;
temp.rightChild=-1;
node[i]=temp;
}
//迴圈構造哈夫曼樹,初始化n-1個非葉子節點，對於有n個葉子節點的哈夫曼樹來說，有2n-1個節點，除了葉子節點還有n-1個節點
for(int i=0;i<n-1;i++){
m1=m2=maxvalue;
x1=x2=0;
for(int j=0;j<n+i;j++){
if(node[j].weight<m1&&node[j].parent==-1){
m1=m2;
x2=x1;
m1=node[j].weight;
x1=j;
}else if(node[j].weight<m2&&node[j].parent==-1){
m2=node[j].weight;
x2=j;
}
}
node[x1].parent=n+i;
node[x2].parent=n+i;
node[n+i].weight=node[x1].weight+node[x2].weight;
node[n+i].leftChild=x1;
node[n+i].rightChild=x2;
//node[n+i].leftChild=node[x1].weight;
//node[n+i].rightChild=node[x2].weight;
}
/*for(int i=0;i<2*n-1;i++){
System.out.println("parent:"+node[i].parent+"\tweight:"+node[i].weight+"\tleftChild:"+node[i].leftChild+"\trightChild:"
+ ""+node[i].rightChild+"\tvalue:"+node[i].value);
}*/ //用於測試
}
//哈夫曼編碼演算法
public void haffCode(HNode[] node, HCode[] hcode){
int n=this.nodenum;
int child,parent;
HCode code = new HCode(n);
for(int i=0;i<n;i++){ //對前面的n個葉子節點進行編碼
code.start = n-1; //得到編碼的最大長度為n-1
code.weight=node[i].weight;
child=i;
parent = node[child].parent;
while(parent!=-1){
if(node[parent].leftChild == child){
code.bit[code.start]=0;
}else{
code.bit[code.start]=1;
}
code.start--; //求編碼的低一位
child = parent;
parent = node[child].parent;
}
//儲存求出的葉子節點的哈夫曼編碼和編碼的起始位
HCode temp = new HCode(n);
for(int j=code.start+1;j<n;j++){
temp.bit[j]=code.bit[j];
}
temp.weight=code.weight;
temp.start=code.start;
hcode[i] = temp;
}
//輸出以儲存的哈夫曼編碼
//printCode(node,hcode); //列印演算法，用於測試
}
public void printCode(HNode[] node, HCode[] code){
for(int i=0;i<code.length;i++){
System.out.print("value"+node[i].value+"\tWeight="+code[i].weight+"\tCode=");
for(int j=code[i].start+1;j<code.length;j++){
System.out.print(code[i].bit[j]);
}
System.out.println();
}
}
//解碼演算法
public void yima(HCode[] code, HNode[] node){
for(int i=0;i<code.length;i++){
int temp=node.length-1; //根節點
//int j=0;
boolean asd = true;
int m=0;
while(node[temp].leftChild!=-1&&node[temp].rightChild!=-1){
if(asd==true){
/*
*
*/
m=code[i].start+1;
}
if(code[i].bit[m]==0){
temp = node[temp].leftChild;
}else{
temp = node[temp].rightChild;
}
m++;
asd=false;
}
//System.out.println(node[temp].value); //輸出用於測試
}
}
}測試類：
package 哈夫曼數和哈夫曼編碼;
public class Test {
public static void main(String[] args){
int[] arr = {2,5,8,3,9,6,12};
String[] str = {"Aasda","B","D","S","R","E","C"};
HNode[] node = new HNode[arr.length*2-1];
HCode[] hcode = new HCode[arr.length];
HTree tree= new HTree(arr.length);
System.out.println("---構造哈夫曼樹---");
tree.haffman(arr, str, node);
System.out.println("---根據哈夫曼樹編碼---");
tree.haffCode(node, hcode);
System.out.println("---譯碼---");
tree.yima(hcode, node);
}
}測試結果：
經測試無誤，若有錯誤請指出，謝謝！