Huffman編碼及譯碼

1．掌握二叉樹的二叉連結串列存貯結構。

2．掌握Huffman演算法。

要求：

使用檔案儲存初始的文字資料及最終的結果。

1. 檔名為inputfile1.txt的檔案儲存的是一段英文短文；
2. 檔名為inputfile2.txt的檔案儲存01形式的編碼段；
3. 檔名為outputfile1.txt的檔案儲存各字元的出現次數和對應的編碼；
4. 檔名為outputfile2.txt的檔案儲存對應於inputfile2.txt的譯碼結果。

統計inputfile1.txt中各字元的出現頻率，並據此構造Huffman樹，編制Huffman 碼；根據已經得到的編碼，對01形式的編碼段進行譯碼。

具體的要求：

1．將給定字元檔案編碼，生成編碼，輸出每個字元出現的次數和編碼；

2．將給定編碼檔案譯碼，生成字元，輸出編碼及其對應字元。

輸入資料格式：

詳見要求部分。

輸出資料格式：

outputfile1.txt檔案中：

字元  出現次數  對應的編碼

 a      37         010

 b      130        00

outputfile2.txt檔案中：

This is a example.

分析（如何構造哈夫曼樹）：

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

(1) 將w1、w2、…，wn看成是有n 棵樹的森林(每棵樹僅有一個結點)；

(2) 在森林中選出兩個根結點的權值最小的樹合併，作為一棵新樹的左、右子樹，且新樹的根結點權值為其左、右子樹根結點權值之和；

(3)從森林中刪除選取的兩棵樹，並將新樹加入森林；

(4)重複(2)、(3)步，直到森林中只剩一棵樹為止，該樹即為所求得的哈夫曼樹。

 如：對 下圖中的六個帶權葉子結點來構造一棵哈夫曼樹，步驟如下（借用一下他人好看的圖）：

程式碼如下（vs2012）：

#include<iostream>
#include<fstream>
#include<string>
using namespace std;
struct Huffmannode {
	int parent;
	int lc;
	int rc;
	int weight;
};
class Huffmantree {
private:
	Huffmannode*node;
	char* letter;
	int leafnum;
public:
	Huffmantree();
	~Huffmantree();
	Huffmannode*Initialization(int sum, char z[], int w[]);
	void Encord(Huffmannode*node, char tree[], int sum, char z[], int w[]);
	void Decord(Huffmannode*node, int sum, char z[]);
};
Huffmantree::Huffmantree() {
	node = NULL;
	letter = NULL;
	leafnum = 0;
}
Huffmantree::~Huffmantree() {
	delete[]node;
	delete[]letter;
}
Huffmannode*Huffmantree::Initialization(int sum, char z[], int w[]) {
	int min1, min2;
	int loc1, loc2;
	node = new Huffmannode[2 * sum - 1];
	letter = new char[2 * sum - 1];
	for (int i = 0; i<sum; i++) {
		letter[i] = z[i];
		node[i].weight = w[i];
		node[i].parent = -1;
		node[i].lc = -1;
		node[i].rc = -1;
	}
	for (int i = sum; i<2 * sum - 1; i++) {
		loc1 = -1;
		loc2 = -1;
		min1 = 32767;
		min2 = 32767;
		for (int j = 0; j<i; j++) {
			if (node[j].parent == -1) {
				if (node[j].weight<min1) {
					min2 = min1;
					min1 = node[j].weight;
					loc2 = loc1;
					loc1 = j;
				}
				else {
					if (node[j].weight<min2) {
						min2 = node[j].weight;
						loc2 = j;
					}
				}
			}
		}
		node[loc1].parent = i;
		node[loc2].parent = i;
		node[i].lc = loc1;
		node[i].rc = loc2;
		node[i].parent = -1;
		node[i].weight = node[loc1].weight + node[loc2].weight;
	}
	return node;
}
void Huffmantree::Encord(Huffmannode*node, char t[], int sum, char z[], int w[]) {
	char* code;
	code = new char[sum];
	int m = 0;
	int i, n = 0;
	ofstream shuchu;
	shuchu.open("outputfile1.txt", ios::app);
	while (z[n] != '\0') {
		int r, k = 0, q;
		r = n;
		q = n;
		shuchu << z[n] << "   " << w[n] << "   ";
		while (node[r].parent != -1) {
			r = node[r].parent;
			if (node[r].lc == q) {
				code[k] = '0';
				k++;
			}
			else {
				code[k] = '1';
				k++;
			}
			q = r;
		}
		code[k] = '\0';
		k -= 1;
		while (k >= 0) {
			shuchu << code[k];
			k--;
		}
		shuchu << '\n';
		n++;
	}
	shuchu.close();
	ofstream out;
	out.open("inputfile2.txt", ios::app);
	while (t[m] != '\0') {
		int j, s = 0;
		for (i = 0; i<sum; i++) {
			if (t[m] == z[i])break;
		}
		j = i;
		while (node[j].parent != -1) {
			j = node[j].parent;
			if (node[j].lc == i) {
				code[s] = '0';
				s++;
			}
			else {
				code[s] = '1';
				s++;
			}
			i = j;
		}
		code[s] = '\0';
		s -= 1;
		while (s >= 0) {
			out << code[s];
			s--;
		}
		m++;
	}
	out.close();
}
void Huffmantree::Decord(Huffmannode *node, int sum, char z[]) {
	ifstream tree("inputfile2.txt");
	int k = 0;
	char *code = new char[1000];
	while (!tree.eof()) {
		tree >> code[k];
		k++;
	}
	code[k] = '\0';
	tree.close();
	ofstream yima("outputfile2.txt", ios::app);
	k = 0;
	int j = 2 * sum - 1 - 1;
	while (code[k + 1] != '\0') {
		if (code[k] == '0') {
			j = node[j].lc;
		}
		if (code[k] == '1') {
			j = node[j].rc;
		}
		if (node[j].lc == -1) {
			yima << z[j];
			j = 2 * sum - 1 - 1;
		}
		k++;
	}
	yima.close();
}
int main() {
	ifstream in("inputfile1.txt", ios::app);
	char tree[1000] = { 0 };
	char letter[100];
	int count[100] = { 0 };
	int i = 0, t = 0;
	while (!in.eof()) {
		tree[t] = in.get();
		t++;
	}
	tree[t] = '\0';
	int k = 0;
	in.close();
	while (tree[i] != '\0') {
		int m = 0;
		for (int j = 0; j<k; j++) {
			if (tree[i] == letter[j]) {
				count[j]++;
				m = 1;
			}
		}
		if (m == 0) {
			letter[k] = tree[i];
			count[k]++;
			k++;
		}
		i++;
	}
	count[k] = '\0';
	letter[k] = '\0';
	Huffmantree tree1;
	Huffmannode*node = tree1.Initialization(k, letter, count);
	tree1.Encord(node, tree, k, letter, count);
	tree1.Decord(node, k, letter);
}