霍夫曼编码

在数据通信中，需要将传送的文字转换成二进制的字符串，用0，1码的不同排列来表示字符。例如，需传送的报文为“AFTER DATA EAR ARE ART AREA”，这里用到的字符集为“A，E，R，T，F，D”，各字母出现的次数为{8，4，5，3，1，1}。现要求为这些字母设计编码。要区别6个字母，最简单的二进制编码方式是等长编码，固定采用3位二进制，可分别用000、001、010、011、100、101对“A，E，R，T，F，D”进行编码发送，当对方接收报文时再按照三位一分进行译码。显然编码的长度取决报文中不同字符的个数。若报文中可能出现26个不同字符，则固定编码长度为5。然而，传送报文时总是希望总长度尽可能短。在实际应用中，各个字符的出现频度或使用次数是不相同的，如A、B、C的使用频率远远高于X、Y、Z，自然会想到设计编码时，让使用频率高的用短码，使用频率低的用长码，以优化整个报文编码。

  为使不等长编码为前缀编码(即要求一个字符的编码不能是另一个字符编码的前缀)，可用字符集中的每个字符作为叶子结点生成一棵编码二叉树，为了获得传送报文的最短长度，可将每个字符的出现频率作为字符结点的权值赋予该结点上，显然字使用频率越小权值越小，权值越小叶子就越靠下，于是频率小编码长，频率高编码短，这样就保证了此树的最小带权路径长度效果上就是传送报文的最短长度。因此，求传送报文的最短长度问题转化为求由字符集中的所有字符作为叶子结点，由字符出现频率作为其权值所产生的哈夫曼树的问题。利用哈夫曼树来设计二进制的前缀编码，既满足前缀编码的条件，又保证报文编码总长最短。

  本题要求从键盘输入若干电文所用符号及其出现的频率，然后构造哈夫曼树，从而输出哈夫曼编码。

  注意,为了保证得到唯一的哈夫曼树，本题规定在构造哈夫曼树时，左孩子结点权值不大于右孩子结点权值。如权值相等，则先选优先级队列中先出队的节点作为左孩子。编码时，左分支取“0”，右分支取“1”。

输入格式:

首先输入n，表示有n个字符。
然后是n行字符和频率(整数)
再然后是读入一行字符串（由前面字符组成）
最后是一串01编码的字符串

输出格式:

首先输出字符的霍夫曼编码
然后是字符串的霍夫曼编码
最后是解码后的字符串

输入样例:

5
 :2
a:3
b:8
c:38
d:12
abcd a
01001100110010

输出样例:

霍夫曼的字符编码:
 :0100
a:0101
b:011
c:1
d:00

abcd a编码后:
010101110001000101

01001100110010解码后:
 ccdccdc

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <cstring>
#include <map>
#include <queue>
#include <string>
#define MAXSIZE 100

using namespace std;

//哈夫曼树的存储结构 
typedef struct HaffmanTree {
	int weight;					//权值
	char data;
	int parent, lChild, rChild;	//结点的双亲、左孩子、右孩子的下标 
}HTNode, * HuffmanTree;			//动态分配数组储存哈夫曼树 

typedef char** HuffmanCode;		//动态分配数组储存哈夫曼编码表 


//寻找最小的两个元素           
void Select(HuffmanTree& HT, int n, int& s1, int& s2) {
	int i, flag = 0;
	for (i = 1; i <= n; i++) {//求出前两个parent为零的i
		if (HT[i].parent == 0 && flag == 0) {
			s1 = i;
			flag = 1;
		}
		else if (HT[i].parent == 0 && flag == 1) {
			s2 = i;
			break;
		}
	}
	if (HT[s1].weight > HT[s2].weight) {//使s1<s2
		flag = s1;
		s1 = s2;
		s2 = flag;
	}
	for (i++; i <= n; i++) {
		if (HT[i].parent == 0 && HT[i].weight < HT[s1].weight) {
			s2 = s1;
			s1 = i;
		}
		else if (HT[i].parent == 0 && HT[i].weight < HT[s2].weight) {
			s2 = i;
		}
	}
}

//功能一：初始化，并建立哈夫曼树
void Initialization(HuffmanTree& HT, int n,string *a,string *b) {
	int m;
	if (n <= 1) {
		printf("字符个数不足！\n");
		return;
	}
	m = 2 * n - 1;//一共有m=2n-1个节点
	HT = new HTNode[m + 1];		//从1开始，0未用，需要动态分配 m+1 个单元，HT[m]表示根节点 
	for (int i = 1; i <= m; i++) {  //将双亲、左孩子、右孩子的下标初始化为0 
		HT[i].parent = 0;
		HT[i].lChild = 0;
		HT[i].rChild = 0;
	}

	//初始化n个字符及其权值
	int  freq = 0;
	for (int i = 0; i < n + 1; i++) {
		string in;
		getline(cin, in);
		char character = in[0];
		for (int k = 2; k < in.length(); k++) {
			freq = freq * 10 + int(in[k] - '0');
		}
		HT[i].data = character;
		HT[i].weight = freq;
		freq = 0;
	}
	getline(cin,*a);
	getline(cin, *b);
	//创建哈夫曼树
	int s1, s2;
	for (int i = n + 1; i <= m; i++) {	//通过n-1次的选择、删除、合并来创建哈夫曼树 
		Select(HT, i - 1, s1, s2);		//找出权值最小的两个
		HT[s1].parent = i;
		HT[s2].parent = i;			//将双亲设为i

		HT[i].lChild = s1;
		HT[i].rChild = s2;		  //将其作为左右孩子
		HT[i].weight = HT[s1].weight + HT[s2].weight;	//双亲的权值为左右孩子权值之和 
	}
}

//功能二：编码
void Encoding(HuffmanTree HT, HuffmanCode& HC, int n) {
	int start, child, parent;
	HC = new char* [n + 1];	 			//分配n个字符编码的编码表空间 
	char* cd = new char[n];  			//分配临时存放每个字符编码的动态数组空间 
	cd[n - 1] = '\0';         			//编码结束符
	for (int i = 1; i <= n; i++) {
		start = n - 1;					//start开始指向最后，即编码结束符的位置 
		child = i;
		parent = HT[i].parent;			//parent指向节点child的双亲节点
		while (parent != 0) {
			--start;					//回溯一次start向前指一个位置
			if (HT[parent].lChild == child)
				cd[start] = '0';		//child为parent的左孩子，生成0 
			else
				cd[start] = '1';		//child为parent的右孩子，生成1 
			child = parent;
			parent = HT[parent].parent;	//继续向上回溯
		}
		HC[i] = new char[n - start];		//为第i个字符编码分配空间
		strcpy(HC[i], &cd[start]); 		//将求得的编码从临时空间cd复制到HC的行列中 
	}
	delete cd;							//释放临时空间
	cout << "霍夫曼的字符编码:\n";
	for (int i = 1; i <= n; i++) {
		cout << HT[i].data << ":" << HC[i] << endl;
	}
cout<<endl;
    
}

//对正文编码
void TextCode(HuffmanTree HT, HuffmanCode& HC, int n, string* a) {
	int flag = 0;
	char ch;
	cout << *a << "编码后:" << endl;
	for (int j = 0; j < a->size(); j++) {
		for (int i = 1; i <= n; i++) {
			if ((*a)[j] == HT[i].data) {
				cout << HC[i];
				flag = 1;       //标志flag为1，匹配到初始化的字符 
				break;
			}
			else
				flag = 0;
		}
		if (!flag)
			cout << (*a)[j];
	}
	cout << endl;
}
//解码
void Decoding2(HuffmanTree HT, int n, string* b) {
	int m = 2 * n - 1; //根节点
	int i = 0;
	cout << *b << "解码后:" << endl;
	while (i < b->size()) {
		int current = m;
		while (HT[current].lChild != 0 && HT[current].rChild != 0 && i < b->size()) {
			if ((*b)[i] == '0') {
				current = HT[current].lChild;
			}
			else if ((*b)[i] == '1') {
				current = HT[current].rChild;
			}
			i++;
		}
		if (HT[current].lChild == 0 && HT[current].rChild == 0) {  //当前节点是叶子节点
			cout << HT[current].data;
			current = m; // 重置当前节点为根节点
		}
	}
	cout << endl;
}


int main() {
	int choice, n;
	HuffmanTree Tree;
	HuffmanCode HC;
	cin >> n;
	string* a = new string;
	string* b = new string;
	Initialization(Tree, n,a,b);   //初始化数
	Encoding(Tree, HC, n);   //输出字符编码
	TextCode(Tree, HC, n, a);
    cout<<endl;
	Decoding2(Tree, n, b);//解码

	return 0;
}