基于Huffman编码的文档压缩

最新推荐文章于 2024-06-10 14:35:13 发布

chenxianqin2

最新推荐文章于 2024-06-10 14:35:13 发布

阅读量331

点赞数

分类专栏：算法设计与分析文章标签：哈夫曼压缩解压

本文链接：https://blog.csdn.net/chenxianqin2/article/details/79152083

版权

算法设计与分析专栏收录该内容

5 篇文章 0 订阅

订阅专栏

算法思想：

统计文件中字符种类个数和各种字符个数，根据词频统计构建赫夫曼树并根据赫夫曼树找出各字符对应的编码，再根据各字符的编码对文件进行压缩，最后重构赫夫曼树，根据赫夫曼树和二进制编码对压缩文件进行解压。

其中的重点在于赫夫曼树的构建与编码：构建n颗二叉树（包括单个树结点），每棵树只有其根结点有权重，由这些树组成森林。在森林中选取最小的两棵树构成新的二叉树（小的树为左子树）并且置新二叉树根结点权值为左右子树上根结点的权值之和，从森林中删除这两棵二叉树，重复以上步骤直到森林中只剩一棵树，该树就是赫夫曼树。从根结点遍历，左子结点加0，右子结点加1，从根结点到每一叶子结点的路径构成的01串就是该叶子结点的赫夫曼编码。

算法实现：

压缩：原文件读取，赫夫曼树构建与编码，生成压缩文件；

解压：压缩文件读取，赫夫曼树重建与解编码，生成原文件。

采用链表实现，可以节省内存空间，但时间有可能比矩阵慢。

文件读取采用ifstream.get()方法，该方法每次读取一个字节，每个字节为8位，转化为无符号整形为0-255，也就是说，文件所有可能出现的字符有256种，创建一个大小为257并初始值为0的整型数组来储存各个字符出现的频率。按顺序按字节读取文件，将读取到的字节转化为无符号整型作为数组下标找到数组中各个字符频率储存的位置并加一，以此来统计原文件的各种字符的频率。最后将下标为256的值加一，表示每个文件有一个结束标志。

文件读取与字符统计

while  (index = (unsigned) infile.get()) != EOF
     weightOfChar[index]++

统计数组中频率不为0的数量n，创建2n-1个树结点，每个结点包括代表的字符的值，父结点和左右子结点的下标值，频率，编码。该树数组的前n个数组用来储存文件中存在的字符，后面的树结点为前面结点的父结点，通过不断找出最小权重的二叉树构成新的二叉树，直至构建出赫夫曼树。

构建赫夫曼树

for  i = n to 2n-1
    selectMin(&leftChild, &rightChild, i)  //找出最小的两棵树并赋值

    //构建父子关系

    huffmannode[i].lChild = leftChild and huffmannode[i].rChild = rightChild

    huffmannode[leftChild].parent and huffmannode[rightChild].parent = i

    huffmannode[i].weight=huffmannode[leftChild].weight+huffmannode[rightChild].weight

生成赫夫曼编码可从每个叶子结点开始，为每个叶子结点赋一个空串，当某个结点为其父结点的左子树结点时，给字符串加0，若为父结点的右子树结点时，给字符串加1，直至遇到根结点，最后将字符串逆序就是每个叶子结点的赫夫曼编码。

赫夫曼编码

for  i = 0 to num

	while 当前结点不为根结点

		if  当前结点为父结点的左子树结点

			huffmanCode+'0';

		else

			huffmanCode+ '1';

huffmanCode逆序

经过以上步骤，可以得到一个huffman编码字典。关于cacm.all所生成的字典，单独整理在附件中。

先往压缩文件存入字符的种类数，字符和其频率，用于后期解码，再存入压缩的内容。

储存编码后的文件

buf = 0

while  index = (unsigned int) infile.get() != EOF //按顺序边读边写

	charToBit = codeOfChar[index]

	for i to charToBit.length

	if  charToBit[i] == '1'

		buf++

	if offset == 7	//如果偏移了7次，表示已经凑足8个01构成的编码

		outfile << buf and offset = 0 and buf = 0

	else

		buf = buf << 1 and offset++

	文件读取和写入完后，将的结束标志的编码也储存进去

	最后不足8位的左移凑成8位再写入

解压文件，先读取文件的第一行得到字符的种类数n，再读取n行得到所有字符的种类和权重，根据这些信息，可以直接调用前面所写的赫夫曼树构建和编码的函数，生成一棵与压缩文件时一样的赫夫曼树。然后根据按顺序读取到的压缩后的信息和赫夫曼树还原文件内容。

还原写入解压文件

p = huffmanTree.head  and  isOver = false

while ( ! isOver)
	
	buf = (unsigned char)in.get()

	for  i = 0 to 8

		if  (unsigned int)buf >= 128  //buf大于等于128表示最左边数字为1

			p = p->rChild

		else

			p = p->lChild

			buf = buf << 1   //将buf左移1位用来继续判断数字

		if  p指向叶子结点

			if  p指向结束符	//表示文件已经读取完了，退出两重循环

				isOver = false  and	break

			else

				out << (p结点所代表的字符)  and	p=huffmanTree.head

证明贪心算法得到的是最优解

要证明赫夫曼树可以通过贪心算法得到最优解，需要证明最优前缀码问题具有贪心选择性质和最优子结构性质。

（1）贪心选择性质

设C是字符集，令x，y是C中具有最小频率的两个字符，证明存在C的一个最优前缀码，x和y的码字长度相同且只有最后一个二进制位不同。

证明：设a，b是树T中最深的两个叶子兄弟结点，a.frep<b.frep且x.frep<y.frep，由于x，y频率最小，所以x.frep<a.frep，y.frep<b.frep，交换a与x得到T’，再交换b与y得到T’’，T和T’的代价差为：

B(T) - B(T’) = x.frep*d_T(x) + a.frep*d_T(a) - x.frep*d_T_’(x) - a.frep*d_T_’(a)

= x.frep*d_T(x) + a.frep*d_T(a) - x.frep*d_T(a) - a.frep*d_T(x)

= (a.frep - x.frep)(d_T(a)-d_T(x)) >= 0

同理得B(T’) - B(T’’) >= 0，所以 B(T) - B(T’’) >= 0，由于T树是最优的，所以B(T) - B(T’’) <= 0，得到B(T’) = B(T’’)。所以T’’也是最优树，而且x和y的码字长度相同且只有最后一个二进制位不同。

（2）最优子结构

设T是表示字符集C的一棵最优前缀编码树。设x和y是树T中的一对兄弟叶子，z是其父亲。如果将z看成是具有频率z.frep=x.frep+y.frep的字符，则最优子结构性质就是要说明：树T’=T-{x，y}将是表示字符集C’=C-{x,y}∪{z}的一棵最优前缀编码树。

证明：将树T的平均码长B(T)用树T’的平均码长B(T’)来表示。对于每个c属于C-{x,y}，有d_T(c)=d_T_’(c)，因此c.frep*d_T(c) - c.frep*d_T(c)，由于d_T(x) = d_T(y) = d_T_’(z)+1，有x.frep*d_T(x) + y.frep*d_T(y) = (x.frep + y.frep)(d_T_’(z) + 1) = z.frep*d_T_’(z) + (x.frep+y.frep)，于是B(T) = B(T’) + x.frep + y.frep。假设T对应的前缀码不是C的最优前缀码，存在最优编码树T’’满足B(T’’)<B(T)。T’’包含兄弟结点x和y。令T’’’为将T’’中x、y及它们的父结点替换为叶子结点z得到的树，其中z.frep=x.frep+y.frep。于是B(T’’’) = B(T’’) - x.frep - y.frep < B(T) - x.frep - y.frep = B(T’)，与T’对应C’的一个最优前缀码的假设矛盾。因此由反证法得，T必然表示字母表C的一个最优前缀码。

具体实现代码：

#include <iostream>
#include <string>
#include <time.h>
#include <windows.h>
#include <fstream>
#include <bitset> 

using namespace std;

#define maxCodeLen 200
#define maxASCIIKinds 257
LARGE_INTEGER StartTime;	//计时参数
LARGE_INTEGER EndTime;
LARGE_INTEGER Freq;

void startTime();	//开始计时
double endTime();	//停止计时并返回消耗时间

int readFile(string filePath);
void createHuffmanTree(int num);
void selectMin(int *lc,int *rc,int num);
void huffmanCoding(int num);
void compressedFile(int num, string filePathBeforeCompress, string filePathAfterCompress);
void decompressionFile(string filePathAfterCompress, string filePathDeCompress);
void getWeight(string codeStr);
void displayHuffmanCode(int num);
void Encode(string filePathBeforeCompress, string filePathAfterCompress);
void Decode(string filePathAfterCompress, string filePathDeCompress);

//统计字符出现的次数
int weightOfChar[maxASCIIKinds];
string codeOfChar[maxASCIIKinds];

typedef struct {
	int charValue = -1;
	int weight = 0;
	int parent = -1;
	int lChild = -1;
	int rChild = -1;
	char code[maxCodeLen];
	int codeLen = 0;
}huffmanNode;

huffmanNode *huffmannode;


int main()
{
	string filePathBeforeCompress = "要压缩的文件";
	string filePathAfterCompress = "压缩后的文件";
	string filePathDeCompress = "解压后的文件";
	int t, i;

	cout << "1.压缩文件      2.解压文件   " << endl;
	while (cin >> t) {
		if (t == 1)
			Encode(filePathBeforeCompress, filePathAfterCompress);
		else if (t == 2)
			Decode(filePathAfterCompress, filePathDeCompress);
		else
			break;
	}
    return 0;
}

void Encode(string filePathBeforeCompress, string filePathAfterCompress) {

	startTime();
	int charKindsLen;
	string huffmanCode;

	//读取文件并统计字符频率返回字符种类数量
	charKindsLen = readFile(filePathBeforeCompress);
	//根据字符频率构建哈夫曼树
	createHuffmanTree(charKindsLen);
	//根据哈夫曼树进行编码
	huffmanCoding(charKindsLen);
	//压缩文件
	compressedFile(charKindsLen, filePathBeforeCompress, filePathAfterCompress);

	cout << "压缩时间" << endTime() << "us" << endl;
}

void Decode(string filePathAfterCompress, string filePathDeCompress) {
	
	startTime();
	decompressionFile(filePathAfterCompress, filePathDeCompress);
	cout << "解压时间" << endTime() << "us" << endl;
}

//读取文件并统计字符的频率,返回文件字符种类的数量
int readFile(string filePath) {

	int singleChar;
	int charKindsLen = 0;
	int ASCIIKinds = 0;
	ifstream infile;

	infile.open(filePath, ios::in | ios::binary);
	if (!infile) {
		cout << "文件不存在\n";
		exit(-1);
	}
	
	//所有字符权重初始化为0
	for (int i = 0; i < maxASCIIKinds; i++)
		weightOfChar[i] = 0;
	weightOfChar[maxASCIIKinds - 1] = 1;

	//统计字符出现频率，以字符的ASCII码作为下标
	while ((singleChar = infile.get()) != EOF) {
		if (singleChar < 0)
			singleChar = 256 + singleChar;
		weightOfChar[singleChar]++;
	}
	
	infile.close();

	//统计权重不为0的字符的数量
	for (int j = 0; j < maxASCIIKinds; j++)
		if (weightOfChar[j] != 0)
			charKindsLen++;
	
	return charKindsLen;
}

//选择所有节点中权重最小的两个节点
void selectMin(int *lc, int *rc, int num) {

	int i;
	int min = -1;
	for (i = 0; i < num; i++) {
		if (huffmannode[i].parent == -1) {
			if (min == -1 || huffmannode[i].weight < huffmannode[min].weight)
				min = i;
		}
	}
	*lc = min;
	min = -1;
	for (i = 0; i < num; i++) {
		if (huffmannode[i].parent == -1 && i!=*lc) {
			if (min == -1 || huffmannode[i].weight < huffmannode[min].weight)
				min = i;
		}
	}
	*rc = min;
}

//构建哈夫曼树
void createHuffmanTree(int num) {

	int allNum = 2 * num - 1;
	int i, j, leftChild, rightChild;

	huffmannode = new huffmanNode[allNum];

	for (i = 0, j = 0; i < maxASCIIKinds; i++) {
		if (weightOfChar[i] != 0) {
			huffmannode[j].charValue = i;
			huffmannode[j].weight = weightOfChar[i];
			huffmannode[j++].code[0] = 0;
		}
	}

	for (i = num; i < allNum; i++) {
		selectMin(&leftChild, &rightChild, i);
		huffmannode[i].lChild = leftChild;
		huffmannode[i].rChild = rightChild;
		huffmannode[i].weight = huffmannode[leftChild].weight + huffmannode[rightChild].weight;
		huffmannode[leftChild].parent = i;
		huffmannode[rightChild].parent = i;
	}
}

//为每一个节点生成一个哈夫曼编码
void huffmanCoding(int num) {

	int currentNode;
	int parentNode;
	int i, j, index;
	char huffmanCode[maxCodeLen];

	for (i = 0; i < num; i++) {
		index = 0;
		for (currentNode = i, parentNode = huffmannode[currentNode].parent; parentNode != -1; currentNode = parentNode, parentNode = huffmannode[parentNode].parent) {
			if (currentNode == huffmannode[parentNode].lChild)
				huffmanCode[index++] = '0';
			else
				huffmanCode[index++] = '1';
		}
		huffmanCode[index] = '\0';

		for (j = index - 1; j >= 0; j--) 
			huffmannode[i].code[index - j - 1] = huffmanCode[j];
		huffmannode[i].code[index] = '\0';
		huffmannode[i].codeLen = index;

		codeOfChar[huffmannode[i].charValue] = huffmannode[i].code;
	}
}

//压缩输出为有特定后缀的压缩文件
void compressedFile(int num, string filePathBeforeCompress, string filePathAfterCompress) {

	ifstream infile;
	ofstream outfile;
	int singleChar;
	string charToBit;
	unsigned char buf = 0;
	int bufLen = sizeof(unsigned char) * 8;
	int offset = 0;
	int i, len;
	infile.open(filePathBeforeCompress, ios::in | ios::binary);
	outfile.open(filePathAfterCompress, ios::out | ios::binary);

	//储存哈夫曼树信息
	outfile << num;
	outfile << (char)10;
	for (i = 0; i < maxASCIIKinds; i++) {
		if (codeOfChar[i] != "") {
			outfile << i;
			outfile << ".";
			outfile << weightOfChar[i];
			outfile << ":";
			outfile << codeOfChar[i];
			outfile << (char)10;
		}
	}

	//储存编码后的文件信息
	while ((singleChar = infile.get()) != EOF) {
		if (singleChar < 0)
			singleChar = 256 + singleChar;
		charToBit = codeOfChar[singleChar];
		len = charToBit.length();
		for (i = 0; i < len; i++) {
			if (charToBit[i] == '1')
				buf++;
			if (offset == bufLen - 1) {
				outfile << buf;
				offset = 0;
				buf = 0;
			}else {
				buf = buf << 1;
				offset++;
			}
		}
	}
	//储存最后的EOF结束标志
	charToBit = codeOfChar[maxASCIIKinds - 1];
	for (i = 0; i < charToBit.length(); i++) {
		if (charToBit[i] == '1')
			buf++;
		if (offset == bufLen - 1) {
			outfile << buf;
			offset = 0;
			buf = 0;
		}
		else {
			buf = buf << 1;
			offset++;
		}
	}
	//最后不足8位的右移凑成8位
	while (offset < bufLen - 1) {
		offset++;
		buf = buf << 1;
	}
	outfile << buf;

	infile.close();
	outfile.close();
}

//解压并生成解压后的文件
void decompressionFile(string filePathAfterCompress, string filePathDeCompress) {

	ifstream in;
	ofstream out;

	in.open(filePathAfterCompress, ios::in | ios::binary);
	out.open(filePathDeCompress, ios::out | ios::binary);

	int i, j, k;
	int singleChar;
	int nodeLen, len;
	string charLen;
	string codeStr;
	int weight;
	string code;
	unsigned char buf;
	int bufLen = 8;

	//获取字符的种类数
	getline(in,charLen);
	nodeLen = atoi(charLen.c_str());

	huffmannode = new huffmanNode[nodeLen * 2 - 1];

	//初始化权重
	for (i = 0; i < maxASCIIKinds; i++)
		weightOfChar[i] = 0;
	weightOfChar[maxASCIIKinds - 1] = 1;

	//给权重赋值
	for (i = 0; i < nodeLen; i++) {
		getline(in, codeOfChar[i]);
		getWeight(codeOfChar[i]);
	}
	
	//构建哈夫曼树
	createHuffmanTree(nodeLen);
	//根据哈夫曼树进行编码
	huffmanCoding(nodeLen);

	//displayHuffmanCode(nodeLen);

	bool isOver = true;
	//p指向树的根节点
	huffmanNode *p = &huffmannode[nodeLen * 2 - 2];
	while (isOver) {
		buf = (unsigned char)in.get();
		for (i = 0; i < bufLen; i++) {
			if ((int)buf >= 128) {
				p = &huffmannode[p->rChild];
			}
			else {
				p = &huffmannode[p->lChild];
			}
			buf = buf << 1;
			if (p->charValue != -1) {
				if (p->charValue == maxASCIIKinds - 1) {
					isOver = false;
					break;
				}else{
					out << (unsigned char)(p->charValue);
					p = &huffmannode[nodeLen * 2 - 2];
				}
			}
		}
	}
	in.close();
	out.close();
}

void getWeight(string codeStr) {

	int pos1, pos2, singleChar;
	string Str;

	pos1 = codeStr.find(".") + 1;
	pos2 = codeStr.find(":") + 1;
	singleChar = atoi(codeStr.substr(0,pos1).c_str());
	weightOfChar[singleChar] = atoi(codeStr.substr(pos1,pos2).c_str());
}

void displayHuffmanCode(int num) {
	for (int i = num-1; i < num; i++){
		cout << huffmannode[i].charValue << " " << huffmannode[i].weight << " " << huffmannode[i].parent << " " << huffmannode[i].lChild << " " << huffmannode[i].rChild << " ";
		for (int j = 0; j < huffmannode[i].codeLen;j++) 
			cout << huffmannode[i].code[j];
		cout << endl;
	}
}

/*void getTimeRAR() {

	clock_t start_time = clock();
	system("rar a cacm E:/suanfa/cacm.all -ad E:/suanfa/");
	clock_t end_time = clock();
	printf("RAR 压缩: %lu ms\n", end_time - start_time);

	system("del E:/suanfa/cacm.all");
	start_time = clock();
	system("unrar x E:/suanfa/cacm -ad E:/suanfa/");
	end_time = clock();
	printf("RAR 解压: %lu ms\n", end_time - start_time);

}*/

void startTime()
{
	QueryPerformanceFrequency(&Freq);
	QueryPerformanceCounter(&StartTime);
}

double endTime()
{
	QueryPerformanceCounter(&EndTime);
	return (double)((EndTime.QuadPart - StartTime.QuadPart) * 1000000 / Freq.QuadPart);	//返回消耗时间，单位毫秒
}

chenxianqin2

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基于Huffman编码的文档压缩

算法思想：统计文件中字符种类个数和各种字符个数，根据词频统计构建赫夫曼树并根据赫夫曼树找出各字符对应的编码，再根据各字符的编码对文件进行压缩，最后重构赫夫曼树，根据赫夫曼树和二进制编码对压缩文件进行解压。其中的重点在于赫夫曼树的构建与编码：构建n颗二叉树（包括单个树结点），每棵树只有其根结点有权重，由这些树组成森林。在森林中选取最小的两棵树构成新的二叉树（小的树为左子树）并且置新二叉树根结
复制链接

扫一扫