首先介紹下Huffman演算法：

哈夫曼編碼(Huffman Coding)是一種編碼方式，哈夫曼編碼是可變字長編碼(VLC)的一種。Huffman於1952年提出一種編碼方法，該方法完全依據字元出現概率來構造異字頭的平均長 度最短的碼字，有時稱之為最佳編碼，一般就叫作Huffman編碼。

明確幾個概念：（主要來自高教出版的資料結構與演算法，不想看的這裡可以直接跳過，點這裡）

結點路徑長：如果n1,n2,n3,...,nk是樹中的節點序列，並且ni是ni+1(1=<i<=k-1)的父結點，這節點序列n1,n2,n3,...,nk稱為n1~nk的一天路徑，路徑長度就是k-1個長度之和。

樹的路徑長度：從樹的根到樹中每一個結點的路徑長度之和。

如上圖所示，假如每個相鄰結點之間長度為1，從A到C之間的路徑長度即為2

擴充二叉樹：每當在原來的二叉樹出現空子樹時，就加上一個特殊的結點，如下圖

外結點：上圖方形的結點；

內結點：圓形的結點；

外路長：根結點到每個外節點的路長之和；

內路長：根結點到每個內結點的路長之和；

加權路長：設有m個實數w1,w2,w3,...,wm，構造一棵有m個外結點的擴充二叉樹，並按一定的方法將數w1,w2,w3,...,wm與這m個外結點聯絡起來，稱SUM(wjlj)為二叉樹額加權路長，其中lj為某個外結點外路長，wj是與此結點相對應的實數，如上圖的實數；

顯然，上圖的加權路長為2 * 3 + 1 * 3 + 3 * 2 + 6 * 3 + 7 * 4 + 4 * 4 + 5 * 3 + 8 * 3，但是，你發現了嗎？將1、2和7、4的未知替換之後，加權路長會減少，對，我麼離Huffman不遠了。

現在，我們需要構造這樣一棵二叉樹，它的出現使我們有最小的加權路長，因而我們能用這個原理來壓縮資訊。

至於怎麼用，且聽我慢慢說來：

計算機裡檔案的最小單位是位元組Byte，8位，採用等長編碼，共256個碼，於是我們將他們構成一顆二叉樹，每個碼都對應一個二叉樹的葉結點，這棵樹有511個結點，共9層。由於是等長編碼，這棵二叉樹的擴充二叉樹的每個權值的大小相同，不妨定為1/256，於是，這顆擴充二叉樹的加權路長為1/256*8*256=8，剛好是每個位元組有的位數。但是，大家知道，檔案中每個字元出現的頻率是不一樣的，比如26個字母的出現的頻率不一致造成了你現在的鍵盤佈局。

於是，我們不妨統計一下每個字元的頻率，將頻率作為上面提到的256個碼擴充二叉樹的權值，這樣，只要通過一定的演算法構造一課最優的擴充二叉樹，我們就可以達到資訊壓縮的目的。

可能看得有點迷糊，不要緊，看下面的例子，順便提下字首性編碼：

假如一種資訊由a,b,c,d組成，各字元出現的頻率是0.12、0.4、0.15、0.33，用一個二進位制數字串，對每個字元進行編碼，使任意一個字元的編碼不會是任何其他字元編碼的字首。通常把編碼的這種特性佳作“字首性”，“字首性”使任意兩個字元之間不需要加分隔符。

如上圖所示，等長編碼的編碼長度為2（上面提到過，加權路長即為編碼位數），而哈夫曼編碼長度為：0.12 * 3 + 0.15 * 3 + 0.33 * 2 + 0.4 * 1 = 1.87，顯然，我們達到了資訊壓縮的目的。

好了，說到這裡，我們以256個數碼（對應一個位元組）為例，正式開始講解Huffman演算法：

1、給出256個數碼的統計頻率，即權值，構造具有256棵擴充二叉樹的森林，其中，每棵擴充二叉樹只有一個帶權值的根結點，其左右子樹均為空。

2、在森林中選取兩課根結點權值最小的二叉樹，作為左右子樹構造一棵新的二叉樹，且置新的二叉樹的權值為其左右子樹上根結點的權值之和。

3、刪去這倆二叉樹，加入新得到的二叉樹

4、重複2和3，直到森林中只剩下一顆二叉樹

Huffman編碼構成過程 下面幾個圖可以看到Huffman編碼的構造過程是一個反覆比較的過程，它總是選擇兩個使用頻率較小的結點進行合併，生成出一個樹，這個樹經過編碼後就會得到Huffman編碼。 在上圖中各點中的數字代表各點的使用次數，您可以把這幾個方塊想成A，B，C，D，它們在某一文章中的使用頻率為7次，5次，1次等等。 選擇使用率小的兩個點1，3構成新點4。 在狀態1圖中選擇5，4（也是兩個最小的，注意不是1，3，因為1，3現在已經歸在4裡面了）進行合併。 在狀態2表中的最小兩個點已經變為7，6了，這時合併它們兩個生成新點13。 只剩兩個點了，不管多少它們也是最小的了，合併了算了。 請注意這個編碼，每個點下面有兩個分枝，分別編碼為0，1，當然這是為了方便計算機及其它數字裝置使用，您也可以編碼為“張三”和“李四”。至此編碼結束，所得到編碼即從最上面的點延線下行，至所要編碼的點，將沿路經過的0和1記錄下來就是了。現在您應該明白為什麼總是先把小的合併了吧，因為先合併的會在最下面，編碼長度最長，而先合併的也是最不常使用的，因此編碼長度最長也是應該的。 7 11 6 10 5 00 3 011 1 010

好了，說到這裡還是迷糊的話，不要緊，看看程式碼吧~來自我寫的一個huffman_tree類中，只放上來編碼這部分的，檔案操作這部分的就不獻醜了，其中用到的ProgressBar類在這裡 。

另外由於哈夫曼編碼和解碼都需要哈夫曼樹，我們在檔案壓縮的時候必須把哈夫曼樹存到壓縮後的檔案中去。

/* * File: huffman_tree.h * Author: xizhibei * * Created on December 31, 2010, 1:43 PM */ #ifndef HUFFMAN_TREE_H #define HUFFMAN_TREE_H #include <string> using namespace std; typedef unsigned int uint; typedef unsigned short ushort; typedef unsigned char uchar; typedef unsigned long ulong; typedef unsigned long long int max_type; //huffman #define TreeLeafNum 256 #define TreeNodeNum 511 class huffman_tree { public: huffman_tree(); void built_tree(); void en_code(); void de_code(); virtual ~huffman_tree(); private: struct HT_node//tree node define { uchar data; int parent; int lchild; int rchild; float weight;//權值 }; //functions void select_min(int n, int& p1, int& p2); HT_node tree[TreeNodeNum]; int root; protected: void built_huffman_tree(float *frequent); uchar *content;//存放輸入字元流 long src_file_size;//字元流大小 max_type bin_code_size;//壓縮後得到的位元組數 max_type bits_size;//壓縮後得到的位數bit float *frequent; //256個數碼的頻率 uchar *bin_code;//壓縮後的字元流 }; #endif /* HUFFMAN_TREE_H */  

然後是每個函式：

1、構造和析構，不解釋了~

huffman_tree::huffman_tree() { root = TreeNodeNum - 1; this->bin_code = NULL; this->frequent = NULL; } huffman_tree::~huffman_tree() { delete bin_code; delete frequent; delete content; }  

2、挑選頻率最小的兩個根結點的標號

void huffman_tree::select_min(int n, int& p1, int& p2) { int i, j; for (i = 0; i < n; i++) if (tree[i].parent == -1) { p1 = i; break; } for (j = i + 1; j < n; j++) if (tree[j].parent == -1) { p2 = j; break; } for (i = 0; i < n; i++) if ((tree[p1].weight > tree[i].weight) && (tree[i].parent == -1) && (p2 != i)) p1 = i; for (j = 0; j < n; j++) if ((tree[p2].weight > tree[j].weight) && (tree[j].parent == -1) && (p1 != j)) p2 = j; } 

3、統計數碼頻率

void huffman_tree::built_tree() { printf("Building huffman tree.../n/n"); ProgressBar pg; int i_percent = 0; float f_percent; long int count[TreeLeafNum + 1];//字元統計 float *frequent = new float[TreeLeafNum + 1]; memset(count, 0, sizeof (count)); long i = 0; while (i < src_file_size)//count the characters { count[content[i]]++; i++; f_percent = float(i) / src_file_size; if (int(f_percent * 100) == i_percent)//用作進度條 { pg.set(i_percent / 2); i_percent += 2; } } i = 0; while (i < TreeLeafNum + 1)//頻率統計characher's frequent { frequent[i] = (float) count[i] / src_file_size; i++; } built_huffman_tree(frequent); } 

4、正式建裡哈夫曼樹，可能你說為什麼要分兩步，因為我為了縮小檔案大小，之後存入壓縮後的檔案只存256個float頻率，當然，對於大檔案沒什麼意義~

void huffman_tree::built_huffman_tree(float* frequent) { ProgressBar pg; int i_percent = 0; float f_percent; for (int i = 0; i < TreeNodeNum; i++)//inilization { tree[i].weight = 0.0; tree[i].data = 0; tree[i].lchild = -1; tree[i].rchild = -1; tree[i].parent = -1; } for (int i = 0; i < TreeLeafNum + 1; i++)// + TreeLeafNum - 1 { tree[i].data = i; tree[i].weight = frequent[i]; } int p1, p2; for (int i = TreeLeafNum; i < TreeNodeNum; i++)//核心建樹演算法 { select_min(i, p1, p2); tree[p1].parent = tree[p2].parent = i; tree[i].lchild = p1; tree[i].rchild = p2; tree[i].weight = tree[p1].weight + tree[p2].weight; f_percent = float(i - TreeLeafNum) / (TreeNodeNum - TreeLeafNum); if (int(f_percent * 100) == i_percent) { pg.set(i_percent / 2 + 50); i_percent += 2; } } this->frequent = frequent; pg.set(100); //Done } 

5、編碼

void huffman_tree::en_code() { printf("Begin to encode.../n/n"); ProgressBar pg; int i_percent = 0; float f_percent; max_type bits_index = 0, content_index = 0; bin_code = new uchar[src_file_size]; //for swap uchar *cur_byte = bin_code; uint tmp; int bit_index = 0; //the index of a bit in a byte int code_tmp[256];//用來存放每個數碼經過哈夫曼編碼後所產生的編碼，因為找到的數碼存放在二叉樹的葉結點，我們需要從二叉樹低端向上查詢，如果當前結點是父結點的左子樹，則為0，右子樹為1，這樣一來就可以找到每個數碼的對應編碼了。但是，之後的解碼需要從頂向下查詢數碼，於是，我們必須將code_tmp顛倒過來存入壓縮後的字元流中去 int code_tmp_index; while (content_index < src_file_size) { tmp = content[content_index]; code_tmp_index = 0; while (tree[tmp].parent != -1)//向上查詢 { if (tmp == tree[tree[tmp].parent].lchild) code_tmp[code_tmp_index++] = 0; else code_tmp[code_tmp_index++] = 1; tmp = tree[tmp].parent; } while (code_tmp_index--)//顛倒過來存入字元流中 { if (code_tmp[code_tmp_index]) (*cur_byte) |= (1 << (bit_index)); //set 1 else (*cur_byte) &= ~(1 << (bit_index)); //set 0 bits_index++; bit_index = bits_index % 8; if (!bit_index)//is 0 cur_byte++; } content_index++; f_percent = float(content_index) / src_file_size; if (int(f_percent * 100) == i_percent) { pg.set(i_percent); i_percent++; } } bits_size = bits_index; bin_code_size = bits_index % 8 == 0 ? bits_index / 8 : bits_index / 8 + 1; } 

6、解碼：

解碼是編碼的相反過程，只要一個一個地讀入壓縮後的字元流的中的每一個位，然後是1的話就向向右子樹查詢，0的話就左，直到找到葉結點，將找到的葉結點中存放的數碼存入字元流即可

void huffman_tree::de_code() { content = new uchar[src_file_size]; int tmp = root; //root long content_index = 0; for (int i = 0; i < bin_code_size; i++) { for (int j = 0; j < 8 && ((i * 8 + j) < bits_size); j++) { if ((((bin_code[i]) >> (j))&1))//is 1 { if (tree[tmp].rchild != -1) { tmp = tree[tmp].rchild; if (tree[tmp].rchild == -1) { content[content_index++] = tree[tmp].data; tmp = root; } } } else// is 0 { if (tree[tmp].lchild != -1) { tmp = tree[tmp].lchild; if (tree[tmp].lchild == -1) { content[content_index++] = tree[tmp].data; tmp = root; } } } } } }  

上面有用到C的位操作，只是不知道我這樣用效率高不高，應該還有別的更高校的位操作方法，下次找個試試

x|=(1<<y) //將X的第Y位置1 x&=~(1<<y)//將X的第Y位置0 ((x >> y)&1) //x的第y位是否為1 

因為我編碼和解碼都是一個函式直接完成的，速度還是不錯的~

好了，先寫這些吧，歡迎各位批評指正~