哈夫曼解压缩解压缩学习

最新推荐文章于 2024-07-24 17:02:53 发布

多方通行8

最新推荐文章于 2024-07-24 17:02:53 发布

阅读量849

点赞数 1

分类专栏： # 数据结构

本文链接：https://blog.csdn.net/q244645787/article/details/128500124

版权

哈夫曼编码文件压缩解压缩哈夫曼树最佳搜索树

关键词由CSDN通过智能技术生成

数据结构专栏收录该内容

12 篇文章 3 订阅

订阅专栏

压缩解压缩：

文件很大：有损压缩无损压缩

png：有损压缩最为常见的9个像素合为1个像素

哈夫曼树：最佳搜索树

假如：

看看所有数据的查找次数：1*1+(2+3)*2+(8+12+16+20)*3=179

如果我们将出现次数最多的放在上层，比如：

则，查找次数：20*1+(16+12)*2+(8+2+3+1)*3=128

而179 >128

这也是为什么哈夫曼树为最佳搜索树的原因

举例：写在用的智能输入法，用的字的次数越多，那个字出现在前面就越多，就是用哈夫曼树的一种构建方式。

频率高的越容易找到，低的越不容易找到。

为什么可以用来解压缩：

假如我打了一堆字符54个字母，一个字母一字节，那么就需要54字节去存储

而我们对这些字节从小到大进行存储：

空白的为空字节，然后我们以左边的节点为0，右边的节点为1

则：

所以我们可以开始计算：1*24 + 2*14 + 3*9 + 4*4 + 4*1=99bit

99bit -> 13字节不到

本质上进行了压缩

出现频率高的编码就越短，出现频率低的编码就越长

如何实现：

1.压缩过程：

1.分析待压缩文件

获取文件中出现的字节和每个出现字节出现的次数组合成字典（索引）

根据字典组建哈夫曼树，获取每个字节对应的哈夫曼编码
读待压缩文件创建压缩后文件，把字典写入压缩后文件中

然后一个一个字节去读待压缩文件的把它转换成对应的编码

把编码写入压缩后文件中

2.解压缩过程：

1.从压缩后文件中读取字典

2.根据字典生成哈夫曼树

3.循环从压缩后文件中读取字节

一个个bit位获取根据bit位的值去哈夫曼树中寻找

找到一个节点就解压一个字节

没有孩子了仍然向右说明结束了

测试：待解压文件名： 1.txt

压缩后文件名： 2.txt

解压后文件名： 3.txt

通过节点来创建数组，在数组里面找到最小的两个，然后数组里面添加空的节点（最小两个的和），然后在寻找最小两个节点

压缩代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string>
//测试用，为1，如果不想测试，改为0即可
#define TESTHAFFMANCODE 0
#define TESTWRITECHAR 0
//哈夫曼编码长度	文件中字符种类越多，对应哈夫曼编码越长
#define HFM_CODE_LEN	10
struct ZiFu
{
	unsigned char	zf;					//字符
	unsigned int	count;				//字符出现次数
	char			code[HFM_CODE_LEN];	//哈夫曼编码
	int				idx;				//字符数组下标
};
//做字典
struct allZiFu
{
	int			zf_count;//出现过字符的个数
	ZiFu		arr[256];//存储每个字符的信息
};
//哈夫曼树节点类型
struct treeNode
{
	ZiFu		data;
	treeNode*	pLeft;
	treeNode*	pRight;
	treeNode*	pParent;
};
//创建树的新节点
treeNode* creatNode(ZiFu* pzf);
//分析文件得到字典（出现过字符的个数 字符 字符出现次数）
void analysisFile(char* srcFile, allZiFu* zd);
//创建哈夫曼树并返回
treeNode* creatHaffmanTree(allZiFu* zd);
//根据哈夫曼树，创建哈夫曼编码，并写入字典中
void creatHaffmanCode(treeNode* root, allZiFu* zd);
//判断当前节点是否是叶子节点
bool isLeaf(treeNode* root);
//设置哈夫曼编码到字典
void setHaffmanCode(treeNode* root, char* pCodeStar);
//把字典和对应字符的编码写到压缩后文件中
void writeCompressFile(char* srcFile, char* dstFile, allZiFu* zd);
//从字典中获取某个字符的哈夫曼编码
void getHaffmanCode(char c, char* haffmanCode, allZiFu* zd);
int main()
{
	char srcFile[256] = "1.txt";//待压缩文件
	char dstFile[256] = "2.txt";//压缩后文件
	allZiFu zd={0};//字典
	analysisFile(srcFile, &zd);//分析好文件
	treeNode* root = NULL;
	root = creatHaffmanTree(&zd);
	creatHaffmanCode(root, &zd);
	writeCompressFile(srcFile, dstFile,&zd);//写压缩文件
	printf("压缩完毕");
	system("pause");
	return 0;
}
treeNode* creatNode(ZiFu* pzf)
{
	treeNode* pNew = (treeNode*)malloc(sizeof(treeNode));
	if (NULL== pNew)
	{
		printf("哈夫曼树空白节点创建失败");
		return NULL;
	}
	memset(pNew, 0, sizeof(treeNode));
	memcpy(pNew->data.code, pzf->code, HFM_CODE_LEN);//拷贝
	pNew->data.count = pzf->count;
	pNew->data.zf = pzf->zf;
	pNew->data.idx = pzf->idx;

	return pNew;
}
void analysisFile(char* srcFile, allZiFu* zd)
{
	//1.打开文件
	FILE* fp = fopen(srcFile, "rb");//二进制只读
	if (NULL==fp)
	{
		printf("analysisFile函数,打开待压缩文件%s失败。\n",srcFile);
		return;
	}
	//2.读取文件内容
	unsigned char c;	//存储读到的字节
	int r;				//fread返回值
	bool isRead;		//标记是否出现
	int i;
	while (1)//循环读取
	{
		//读取字节，读不到结束
		r = fread(&c, 1, 1, fp);
		if (1 != r)
		{
			break;
		}
		//判断是否出现过
		isRead = false;
		for (i = 0; i < zd->zf_count; i++)
		{
			if (c == zd->arr[i].zf)//说明出现过
			{
				isRead = true;
				break;
			}
		}
#if 0
		//  出现，统计次数加1
		if (isRead)
		{
			zd->arr[i].count++;
		}
		else//如果没有出现，存储，统计次数加1
		{
			zd->zf_count++;//字符个数增加
			zd->arr[i].zf = c;//记录字符
			zd->arr[i].count++;
		}
#else
		if (!isRead)//如果没有出现
		{
			zd->zf_count++;//字符个数增加
			zd->arr[i].zf = c;//记录字符
		}
		zd->arr[i].count++;
#endif // 0
	}
	//3.关闭

}
treeNode* creatHaffmanTree(allZiFu* zd)
{
	//准备指针数组 存储所有节点
	treeNode** treeArray = (treeNode**)malloc(sizeof(treeNode*) * zd->zf_count);
	//容器也可以 vector<treeNode*> buff;for循环就行了
	for (int i = 0; i < zd->zf_count; i++)
	{
		treeArray[i] = creatNode(&(zd->arr[i]));
		treeArray[i]->data.idx = i;//下标
	}
	//循环找最小的和第二小的 循环zd->zf_count-1次
	int minIdx, secMinIdx;
	int j;
	treeNode* pTemp=NULL;
	for (int i = 0; i < zd->zf_count-1; i++)
	{
		//找出最小的和第二小的
		j = 0;
		while (treeArray[j]==NULL)
		{
			j++;//让j是第一个的下标
		}
		minIdx = j;
		for (j= 0; j < zd->zf_count; j++)
		{
			if (treeArray[j] &&
				treeArray[j]->data.count< treeArray[minIdx]->data.count)
			{
				minIdx = j;
			}
		}
		//找出第二小的
		j = 0;
		while (treeArray[j]==NULL ||j==minIdx)
		{
			j++;
		}
		secMinIdx = j;
		for (j = 0; j < zd->zf_count; j++)
		{
			if (treeArray[j] && j!=minIdx &&
				treeArray[j]->data.count < treeArray[secMinIdx]->data.count)
			{
				secMinIdx = j;
			}
		}
		//组合为树
		//制作父节点的数据
		ZiFu tempZF = { 0,treeArray[minIdx]->data.count + treeArray[secMinIdx]->data.count };
		tempZF.idx = -1;//保险
		pTemp = creatNode(&tempZF);

		pTemp->pLeft = treeArray[minIdx];
		pTemp->pRight = treeArray[secMinIdx];

		treeArray[minIdx]->pParent = pTemp;
		treeArray[secMinIdx]->pParent = pTemp;
		//数组添加（最小的和第二小的）父     删除最小的和第二小的
		treeArray[minIdx] = pTemp;
		treeArray[secMinIdx] = NULL;
	}
	return pTemp;
}
void creatHaffmanCode(treeNode* root, allZiFu* zd)
{
	int idx;
	if (root)
	{
		if (isLeaf(root))
		{
			idx = root->data.idx;
			setHaffmanCode(root, zd->arr[idx].code);//往上去找父
		}
		else
		{
			creatHaffmanCode(root->pLeft, zd);
			creatHaffmanCode(root->pRight, zd);
		}
	}
}
bool isLeaf(treeNode* root)
{
	if (root && NULL==root->pLeft && NULL == root->pRight)
	{
		return true;
	}
	return false;
}
void setHaffmanCode(treeNode* root, char* pCodeStar)
{
	treeNode* pTemp = root;
	char buff[HFM_CODE_LEN] = { 0 };
	int buffIdx = 0;
	while (pTemp->pParent)//一路往上
	{
		if (pTemp==pTemp->pParent->pLeft)//左
		{
			buff[buffIdx] = 1;
		}
		else//右
		{
			buff[buffIdx] = 2;
		}
		buffIdx++;
		pTemp = pTemp->pParent;
	}
	//逆转存储到参数数组中
	char temp;
	for (int i = 0; i < buffIdx/2; i++)
	{
		temp = buff[i];
		buff[i] = buff[buffIdx - i - 1];
		buff[buffIdx - i - 1] = temp;
	}
	//赋值
	strcpy(pCodeStar, buff);
}
void writeCompressFile(char* srcFile, char* dstFile, allZiFu* zd)
{
	//创建压缩后文件  打开待压缩文件
	FILE* fpSrc = fopen(srcFile, "rb");
	FILE* fpDst = fopen(dstFile, "wb");
	if (NULL== fpSrc || NULL== fpDst)
	{
		printf("writeCompressFile函数打开文件失败\n");
		return;
	}
	//把字典写入压缩后文件中
	fwrite(zd, 1, sizeof(allZiFu), fpDst);
	//读待压缩文件 一个个字节读 对照字典中的哈夫曼编码 得到对应的二进制，
	//每拼成一个字节（8bit）写入压缩后文件中
	char c;//储存读到的字节
	int r;

	char charForWrite;//储存写入压缩后文件的字节（二进制位拼接而来）
	int idxForWrite;//charForWrite的二进制位索引

	char haffmanCode[HFM_CODE_LEN] = { 0 };//临时储存编码
	int haffmanCodeIdx=0;

	bool isEnd = false;
	while (1)
	{
		if (0==haffmanCode[haffmanCodeIdx])
		{
			r = fread(&c, 1, 1, fpSrc);
			if (1 != r)
			{
				break;
			}
			getHaffmanCode(c, haffmanCode, zd);
			haffmanCodeIdx = 0;
		}
#if TESTHAFFMANCODE
		printf("%c ==============", c);
		for (int i = 0; i <HFM_CODE_LEN ; i++)
		{
			printf("%d", haffmanCode[i]);
		}
		printf("\n");
#endif // TESTHAFFMANCODE

		//哈夫曼编码变成二进制储存到charForWrite里面，8个bit位写入fpDst一次
		idxForWrite = 0;
		charForWrite = 0;
		while (idxForWrite<8)
		{
			if (2==haffmanCode[haffmanCodeIdx])//设置对应bit位为0
			{
				charForWrite &= ~(1 << (7 - idxForWrite));
				haffmanCodeIdx++;
				idxForWrite++;
			}
			else if(1 == haffmanCode[haffmanCodeIdx])
			{
				charForWrite |= (1 << (7 - idxForWrite));
				haffmanCodeIdx++;
				idxForWrite++;
			}
			else//读取下一个字符或者结束
			{
				r = fread(&c, 1, 1, fpSrc);
				if (1!=r)
				{
					isEnd = true;
					break;
				}
				getHaffmanCode(c, haffmanCode, zd);
				haffmanCodeIdx = 0;
#if TESTHAFFMANCODE
				printf("%c ==============", c);
				for (int i = 0; i < HFM_CODE_LEN; i++)
				{
					printf("%d", haffmanCode[i]);
				}
				printf("\n");
#endif // TESTHAFFMANCODE
			}
		}
		fwrite(&charForWrite, 1, 1, fpDst);//写入压缩后文件中
#if TESTWRITECHAR
		for (int i = 0; i < 8; i++)
		{
			if ((charForWrite & 0x80) == 0x80)
			{
				printf("1");
			}
			else
			{
				printf("0");
			}
			charForWrite <<= 1;
		}
		printf("\n");
#endif // TESTWRITECHAR

		if (isEnd)
		{
			break;
		}
	}
	//关闭保存
	fclose(fpSrc);
	fclose(fpDst);
}
void getHaffmanCode(char c, char* haffmanCode, allZiFu* zd)
{
	for (int i = 0; i < zd->zf_count; i++)
	{
		if (c==zd->arr[i].zf)
		{
			strcpy(haffmanCode,zd->arr[i].code);
			break;
		}
	}
}

解压代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string>
#define HFM_CODE_LEN 10
struct ZiFu
{
	unsigned char	zf;					//字符
	unsigned int	count;				//字符出现次数
	char			code[HFM_CODE_LEN];	//哈夫曼编码
	int				idx;				//字符数组下标
};
//做字典
struct allZiFu
{
	int			zf_count;//出现过字符的个数
	ZiFu		arr[256];//存储每个字符的信息
};
//哈夫曼树节点类型
struct treeNode
{
	ZiFu		data;
	treeNode* pLeft;
	treeNode* pRight;
	treeNode* pParent;
};
treeNode* creatNode(ZiFu* pzf);
treeNode* creatHaffmanTree(allZiFu* zd);
bool isLeaf(treeNode* root);
int main()
{
	
	char srcFile[256] = "2.txt";//压缩后文件
	char dstFile[256] = "3.txt";//解压后文件
	allZiFu zd = { 0 };//字典
	//1.读取字典
	FILE* fpSrc = fopen(srcFile, "rb");
	fread(&zd, 1, sizeof(allZiFu), fpSrc);
	//根据字典生成哈夫曼树
	treeNode* root = creatHaffmanTree(&zd);
	 //循环读取
	//统计字节数
	int allCount = root->data.count;
	int myCount = 0;
	char temp;
	int bit_idx;//bit位索引
	treeNode* tempNode = root;
	FILE* fpDst=fopen(dstFile,"wb");
	bool isOver = false;
	while (1 == fread(&temp, 1, 1, fpSrc))
	{
		bit_idx = 0;
		while (bit_idx < 8)
		{
			if ((0x80>>bit_idx)==(temp&(0x80>>bit_idx)))//当前位为1；
			{
				tempNode = tempNode->pLeft;
			}
			else
			{
				tempNode = tempNode->pRight;
			}
			if (isLeaf(tempNode))
			{
				fwrite(&(tempNode->data.zf), 1, 1, fpDst);
				myCount++;
				if (myCount >= allCount)
				{
					isOver = true;
					break;
				}
				tempNode = root;
			}
			bit_idx++;
		}
		if (isOver)
		{
			break;
		}
	}
	fclose(fpSrc);
	fclose(fpDst);
	printf("解压缩完毕");
	system("pause");
	return 0;
}
treeNode* creatNode(ZiFu* pzf)
{
	treeNode* pNew = (treeNode*)malloc(sizeof(treeNode));
	if (NULL == pNew)
	{
		printf("哈夫曼树空白节点创建失败");
		return NULL;
	}
	memset(pNew, 0, sizeof(treeNode));
	memcpy(pNew->data.code, pzf->code, HFM_CODE_LEN);//拷贝
	pNew->data.count = pzf->count;
	pNew->data.zf = pzf->zf;
	pNew->data.idx = pzf->idx;

	return pNew;
}
treeNode* creatHaffmanTree(allZiFu* zd)
{
	//准备指针数组 存储所有节点
	treeNode** treeArray = (treeNode**)malloc(sizeof(treeNode*) * zd->zf_count);
	//容器也可以 vector<treeNode*> buff;for循环就行了
	for (int i = 0; i < zd->zf_count; i++)
	{
		treeArray[i] = creatNode(&(zd->arr[i]));
		treeArray[i]->data.idx = i;//下标
	}
	//循环找最小的和第二小的 循环zd->zf_count-1次
	int minIdx, secMinIdx;
	int j;
	treeNode* pTemp = NULL;
	for (int i = 0; i < zd->zf_count - 1; i++)
	{
		//找出最小的和第二小的
		j = 0;
		while (treeArray[j] == NULL)
		{
			j++;//让j是第一个的下标
		}
		minIdx = j;
		for (j = 0; j < zd->zf_count; j++)
		{
			if (treeArray[j] &&
				treeArray[j]->data.count < treeArray[minIdx]->data.count)
			{
				minIdx = j;
			}
		}
		//找出第二小的
		j = 0;
		while (treeArray[j] == NULL || j == minIdx)
		{
			j++;
		}
		secMinIdx = j;
		for (j = 0; j < zd->zf_count; j++)
		{
			if (treeArray[j] && j != minIdx &&
				treeArray[j]->data.count < treeArray[secMinIdx]->data.count)
			{
				secMinIdx = j;
			}
		}
		//组合为树
		//制作父节点的数据
		ZiFu tempZF = { 0,treeArray[minIdx]->data.count + treeArray[secMinIdx]->data.count };
		tempZF.idx = -1;//保险
		pTemp = creatNode(&tempZF);

		pTemp->pLeft = treeArray[minIdx];
		pTemp->pRight = treeArray[secMinIdx];

		treeArray[minIdx]->pParent = pTemp;
		treeArray[secMinIdx]->pParent = pTemp;
		//数组添加（最小的和第二小的）父     删除最小的和第二小的
		treeArray[minIdx] = pTemp;
		treeArray[secMinIdx] = NULL;
	}
	return pTemp;
}
bool isLeaf(treeNode* root)
{
	if (root && NULL == root->pLeft && NULL == root->pRight)
	{
		return true;
	}
	return false;
}

多方通行8

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
哈夫曼解压缩解压缩学习

通过节点来创建数组，在数组里面找到最小的两个，然后数组里面添加空的节点（最小两个的和），然后在寻找最小两个节点。举例：写在用的智能输入法，用的字的次数越多，那个字出现在前面就越多，就是用哈夫曼树的一种构建方式。看看所有数据的查找次数：1*1+(2+3)*2+(8+12+16+20)*3=179。则，查找次数：20*1+(16+12)*2+(8+2+3+1)*3=128。获取文件中出现的字节和每个出现字节出现的次数组合成字典（索引）空白的为空字节，然后我们以左边的节点为0，右边的节点为1。
复制链接

扫一扫