数据结构 基于哈夫曼树的数据压缩算法

实验目的

1.掌握哈夫曼树的构造算法。
2.掌握哈夫曼编码的构造算法。

实验内容

问题描述
输入一串字符串，根据给定的字符串中字符出现的频率建立相应的哈夫曼树，构造哈夫曼编码表，在此基础上可以对压缩文件进行压缩(即编码),同时可以对压缩后的二进制编码文件进行解压(即译码)。
输入要求
多组数据，每组数据1行，为一个字符串(只考虑26个小写字母即可)。当输人字符串为“0”时，输入结束。
输出要求
每组数据输出2n+3行(n为输入串中字符类别的个数)。第1行为统计出来的字符出现频率(只输出存在的字符,格式为:字符:频度)，每两组字符之间用一个空格分隔，字符按照ASCII码 从小到大的顺序排列。第2行至第2n行为哈夫曼树的存储结构的终态(如主教材139页表5.2(b), 一行当中的数据用空格分隔)。第2n+1行为每个字符的哈夫曼编码(只输出存在的字符，格式为:字符:编码)，每两组字符之间用一个空格分隔，字符按照ASCII码从小到大的顺序排列。第2n+2行为编码后的字符串，第2n+3行为解码后的字符串(与输人的字符串相同)。
输入样例

aaaaaaabbbbbccdddd
aabccc
0

输出样例

a:7 b:5 c:2 d:4
1 7 7 0 0
2 5 6 0 0 
3 2 5 0 0
4 4 5 0 0
5 6 6 3 4
6 11 7 2 5
7 18 0 1 6
a:0 b:10 c:110 d:111
00000001010101010110110111111111111
aaaaaabbbbbccdddd
a:2 b:1 c:3
1 2 4 0 0
2 1 4 0 0
3 3 5 0 0
4 3 5 2 1
5 6 0 3 4
a:11 b:10 c:0
111110000
aabccc

实验提示

此实验内容即要求实现主教材的案例5.1,具体实现可参考算法5.10和算法5.11。
首先，读入一行字符串,统计每个字符出现的频率;然后,根据字符出现的频率利用算法5.10建立相应的哈夫曼树;最后，根据得到的哈夫曼树利用算法5.11求出每个字符的哈夫曼编码。

实验代码

#include <iostream>
using namespace std;
#define MAXNUM 255

int num[26] = { 0 };
char saveLetter[26] = { '0' };
int countNum[26] = { 0 };
char codeTemp[MAXNUM] = { '0' };

//哈夫曼树的存储表示
typedef struct HTNode {
	int weight;//结点的权值
	int parent, lchild, rchild;//结点的双亲、左孩子、右孩子的下标
	char data;
}HTNode, * HuffmanTree;

int Frequent(char s[], int& n) {
	int len = strlen(s);
	int num[26] = { 0 };
	
	memset(num, 0, sizeof(num));//全置为0
	int i = 0, j = 0;
	while (s[i] != '\0') {
		j = s[i] - 97;
		num[j]++;
		i++;
	}
	j = 0;
	for (i = 0; i < 26; i++) {
		if (num[i] != 0) {
			saveLetter[j] = char(i + 97);
			countNum[j] = num[i];
			j++;
		}
	}
	n = j;
	for (int k = 0; k < n; k++) {
		if (k == n - 1) {
			cout << saveLetter[k] << ":" << countNum[k] << endl;
		}
		else
		{
			cout << saveLetter[k] << ":" << countNum[k] << " ";
		}
	}
	return n;
}


void Select(HuffmanTree& HT, int Max, int& s1, int& s2) {
	int min = MAXNUM;//最小值
	int lmin = MAXNUM;//次小值
	for (int i = 1; i <= Max; i++) {
		if (HT[i].parent == 0) {
			if (HT[i].weight < min) {
				min = HT[i].weight;
				s1 = i;
			}
		}
	}
	for (int i = 1; i <= Max; i++) {
		if (HT[i].parent == 0) {
			if (HT[i].weight < lmin && i != s1) {
				lmin = HT[i].weight;
				s2 = i;
			}
		}
	}
}

/*
* 哈夫曼树的各节点存储在HuffmanTree定义的动态分配的数组中，为了实现方便，
* 数组的0号单元不使用，从1号单元开始使用，所以数组的大小为2n
* 将叶子结点集中存储在前面部分1~n个位置，而后面的n-1个位置存储其余非叶子结点
*/
void CreateHuffmanTree(HuffmanTree& HT,int n) {//构造哈夫曼树HT
	if (n <= 1)
		return;
	int m = 2 * n - 1;
	//cout << m << endl;
	HT = new HTNode[m + 1];//0号单元未用，所以需要动态分配m+1个单元，HT[m]表示根结点
	for (int i = 1; i < m; i++) {
		HT[i].parent = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].data = saveLetter[i - 1];//字母
	}
	for (int i = 1; i <= n; i++) {
		//cin >> HT[i].weight;//输入前n个单元中叶子结点的权值
		HT[i].weight = countNum[i-1];
	}
	int s1 = 0, s2 = 0;
	//初始化结束，下面开始创建哈夫曼树
	for (int i = n + 1; i <= m; i++) {
		Select(HT, i - 1, s1, s2);
		//在HT[k]（1<=k<=i-1)中选择两个其双亲域为0且权值最小的结点，
		//并返回它们在HT中的序号s1和s2
		HT[s1].parent = i;
		HT[s2].parent = i;
		//得到新结点i,从森林中删除s1,s2,将s1和s2的双亲域由0改为i
		HT[i].lchild = s1;
		HT[i].rchild = s2;//s1,s2分别作为i的左右孩子
		HT[i].weight = HT[s1].weight + HT[s2].weight;//i的权值为左右孩子权值之和
		if (i == m) {
			HT[i].parent = 0;
		}
	}
}

void ShowHT(HuffmanTree& HT, int n) {
	int m = 2 * n - 1;
	for (int i = 1; i <= m; i++) {
		cout << i ;
		cout << " " << HT[i].weight;
		cout << " " << HT[i].parent;
		cout << " " << HT[i].lchild;
		cout << " " << HT[i].rchild << endl;
	}
}

typedef char** HuffmanTreeCode;

void CreateHuffmanCode(HuffmanTree HT, HuffmanTreeCode& HC, int n) {
	//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
	HC = new char* [n + 1];//分配存储n个字符编码的编码表空间
	char* cd;
	cd = new char[n];//分配临时存放每个字符编码的动态数组空间
	cd[n - 1] = '\0';//编码结束符
	int start = 0, c, f = 0;
	for (int i = 1; i <= n; i++) {//逐个字符求哈夫曼编码
		start = n - 1;//start开始时指向最后，即编码结束符位置
		c = i;
		f = HT[i].parent;//f指向结点c的双亲结点
		while (f != 0) {//从叶子结点开始向上回溯，直到根结点
			start--;//回溯一次start向前指向一个位置
			if (HT[f].lchild == c)
				cd[start] = '0';//结点c是f的左孩子，则生成代码0
			else
				cd[start] = '1';//结点c是f的右孩子，则生成代码1
			c = f; f = HT[f].parent;//继续向上回溯
		}
		HC[i] = new char[n - start];//为第i个字符编码分呸空间
		strcpy(HC[i], &cd[start]);//将求得的编码从临时空间cd复制到HC的当前行中
	}
	delete[] cd;//释放临时空间
}

void ShowCode(HuffmanTree& HT, HuffmanTreeCode& HC, int n, char str1[]) {
	for (int i = 0; str1[i] != '\0'; i++) {
		for (int j = 1; j <= n; j++) {
			if (str1[i] == saveLetter[j - 1]) {
				cout << HC[j];
				strcat_s(codeTemp, HC[j]);
			}
		}
	}
	cout << endl;
}

void CreateHuffmanReCode(HuffmanTree& HT, HuffmanTreeCode& HC, int n) {
	int i = 2 * n - 1;
	int j = 0;
	while (codeTemp[j] != '\0') {//codeTemp是暂存01编码串
		if (codeTemp[j] == '0') {
			i = HT[i].lchild;//左孩子
		}
		else if (codeTemp[j] == '1') {
			i = HT[i].rchild;//右孩子
		}
		if (HT[i].lchild == 0) {
			cout << HT[i].data;
			i = 2 * n - 1;
		}
		j++;
	}
	cout << endl;
}


void ShowHC(HuffmanTreeCode& HC, int n) {
	for (int i = 1; i <= n; i++) {
		if (i != n)
			cout << saveLetter[i - 1] << ":" << HC[i] << " ";
		else
			cout << saveLetter[i - 1] << ":" << HC[i] << endl;
	}
}

int main() {
	int n;
	char string[50] = { '0' };
	while (true) {
		cin >> string;
		if (string[0] == '0')
			break;
		n = Frequent(string, n);
		HuffmanTree ht;
		HuffmanTreeCode hc;
		CreateHuffmanTree(ht, n);
		CreateHuffmanCode(ht, hc, n);
		ShowHT(ht, n);
		ShowHC(hc, n);
		ShowCode(ht, hc, n, string);
		CreateHuffmanReCode(ht, hc, n);
		memset(codeTemp, 0, sizeof codeTemp);//清空数组
	}
	
}

运行截图

实验小结

基于哈夫曼树的数据压缩算法，重点在于编码译码的部分，需要正确理解代码。