題目描述

1、問題描述

給定n個字元及其對應的權值，構造Huffman樹，並進行huffman編碼和譯（解）碼。

構造Huffman樹時，要求左子樹根的權值小於、等於右子樹根的權值。

進行Huffman編碼時，假定Huffman樹的左分支上編碼為‘0’，右分支上編碼為‘1’。

2、演算法

構造Huffman樹演算法：

⑴ 根據給定的n個權值(w1, w2, …, wn)構成n棵二叉樹的集合F={T1, T2, …, Tn}，其中每棵二叉樹Ti中只有一個權值為wi的根結點。

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

⑶ 在F中刪除這兩棵樹，同時將新得到的二叉樹加入F中。

(4) 重複⑵, ⑶，直到F只含一棵樹為止。

3、Huffman編碼演算法：

⑴ 從Huffman樹的每一個葉子結點開始。

⑵ 依次沿結點到根的路徑，判斷該結點是父親結點的左孩子還是右孩子，如果是左孩子則得到編碼‘0’，否則得到編碼‘1’，先得到的編碼放在後面。

⑶ 直到到達根結點，編碼序列即為該葉子結點對應的Huffman編碼。

4、Huffman譯（解）碼演算法：

⑴ 指標指向Huffman樹的根結點，取第一個Huffman碼。

⑵ 如果Huffman碼為‘0’，將指標指向當前結點的左子樹的根結點；如果Huffman碼為‘1’，將指標指向當前結點的右子樹的根結點。

⑶ 如果指標指向的當前結點為葉子結點，則輸出葉子結點對應的字元；否則，取下一個Huffman碼，並返回⑵。

⑷ 如果Huffman碼序列未結束，則返回⑴繼續譯碼。

輸入

第一行測試次數

第2行：第一組測試資料的字元個數n，後跟n個字元

第3行：第一組測試資料的字元權重

待編碼的字串s1

編碼串s2

其它組測試資料類推

輸出

第一行~第n行,第一組測試資料各字元編碼值

第n+1行，串s1的編碼值

第n+2行，串s2的解碼值，若解碼不成功，輸出error!

其它組測試資料類推

樣例輸入

2 5 A B C D E 15 4 4 3 2 ABDEC 00000101100 4 A B C D 7 5 2 4 ABAD 1110110

樣例輸出

A :1 B :010 C :011 D :001 E :000 1010001000011 error! A :0 B :10 C :110 D :111 0100111 DAC

#include <iostream>
#include <string>
#include <cstring>
#include <stack>
using namespace std;

const int maxw = 9999;

class HuffNode{
public:
	int weight;
	int parent;
	int leftchild;
	int rightchile;
};

class HuffMan{
private:
	void MakeTree()
	{
		int i, s1, s2;
		for (i = lnum + 1; i <= len; i++)
		{
			SelectMin(i - 1, &s1, &s2);
			hufftree[s1].parent = i;
			hufftree[s2].parent = i;
			hufftree[i].leftchild = s1;
			hufftree[i].rightchile = s2;
			hufftree[i].weight = hufftree[s1].weight + hufftree[s2].weight;
		}
	}
	void SelectMin(int pos, int *s1, int *s2)
	{
		int w1, w2, i;
		w1 = w2 = maxw;
		*s1 = *s2 = 0;
		for (i = 1; i <= pos; i++)
		{
			if (hufftree[i].weight < w1 && hufftree[i].parent == 0)
			{
				*s2 = *s1;
				w2 = w1;
				w1 = hufftree[i].weight;
				*s1 = i;
			}
			else if (hufftree[i].weight < w2 && hufftree[i].parent == 0)
			{
				w2 = hufftree[i].weight;
				*s2 = i;
			}
		}
	}
public:
	int len;
	int lnum;
	HuffNode *hufftree;
	string *huffCode;
	char *message;
	void MakeTree(int n, int wt[], char c[])
	{
		int i;
		lnum = n;
		len = 2 * n - 1;
		hufftree = new HuffNode[2 * n];
		huffCode = new string[lnum + 1];
		message = new char[lnum + 1];
		for (i = 1; i <= n; i++) 
            hufftree[i].weight = wt[i - 1];
		for (i = 1; i <= n; i++)
            message[i] = c[i - 1];
		for (i = 1; i <= len; i++)
		{
			if (i > n)
                hufftree[i].weight = 0;
			hufftree[i].parent = 0;
			hufftree[i].leftchild = 0;
			hufftree[i].rightchile = 0;
		}
		MakeTree();
	}
	void Coiding()
	{
		char *cd = new char[lnum];
		int i, c, f, start;
		cd[lnum - 1] = '\0';
		for (i = 1; i <= lnum; i++)
		{
			start = lnum - 1;
			for (c = i, f = hufftree[i].parent; f != 0; c = f, f = hufftree[f].parent)
			{
				if (hufftree[f].leftchild == c)
					cd[--start] = '0';
				else
					cd[--start] = '1';
			}
			huffCode[i].assign(&cd[start]);
		}
	}
	void Destory()
	{
		len = 0;
		lnum = 0;
		delete[]hufftree;
		delete[]huffCode;
	}
	int Decode(const string codestr, string &teststr){
		int i, k, c;
		char ch;
		c = len;
		k = 0;
		string a = "";
		for (i = 0; i < codestr.length(); i++)
		{
			ch = codestr[i];
			a += ch;
			if (ch == '0') c = hufftree[c].leftchild;
			else
                if (ch == '1') 
                    c = hufftree[c].rightchile;
                else 
                    return 0;
			if (hufftree[c].leftchild == 0 && hufftree[c].rightchile == 0)
			{
				for (int j = 1; j <= lnum; j++)
					if (hufftree[c].weight == hufftree[j].weight && a == huffCode[j])
						teststr += message[j];
				c = len;
				a = "";
			}
			else ch = '\0';
		}
		if (ch == '\0') return 0;
		return 1;
	}
};

int main()
{
	int t, n, i, j;
	int wt[800];
	char c[800];
	string teststr = "";
	string codestr;
	HuffMan huff;
	cin >> t;
	while (t--)
	{
		cin >> n;
		for (i = 0; i < n; i++) cin >> c[i];
		for (i = 0; i < n; i++) cin >> wt[i];
		huff.MakeTree(n, wt, c);
		huff.Coiding();
		for (i = 1; i <= n; i++)
		{
			cout << c[i - 1] << " :" << huff.huffCode[i] << endl;
		}
		cin >> codestr;
		for (i = 0; i < codestr.length(); i++)
		{
			for (j = 1; j <= n; j++)
				if (codestr[i] == c[j - 1]) cout << huff.huffCode[j];
		}
		cout << endl;
		cin >> codestr;
		if (huff.Decode(codestr, teststr)) cout << teststr << endl;
		else cout << "error!" << endl;
		teststr = "";
		huff.Destory();
	}
	return 0;
}