哈夫曼压缩与解压缩（c语言版）

最新推荐文章于 2024-08-19 18:00:26 发布
最新推荐文章于 2024-08-19 18:00:26 发布
阅读量1.5w 收藏 355
点赞数 51
分类专栏： 项目实训 文章标签： 哈夫曼压缩与解压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42034205/article/details/101710602
版权

目录

哈夫曼压缩与解压缩（c语言版）

一：引言

二：主要原理

三：主要技术点

四：实现过程

1.压缩：

2.解压缩：

五：详细分析，及代码实现

哈夫曼压缩与解压缩（c语言版）

一：引言

学过数据结构的同学，应该都听过哈夫曼树，和哈夫曼压缩算法，今天小编向大家讲解哈夫曼压缩与压缩的过程以及代码也算是记录一下自己所学所做的东西。

哈夫曼压缩，其实效率不是很高，一般情况下压缩率13%左右，特殊情况下效率很高（频率高的字符的情况）。但是尝试自己去完成它，对你的代码能力有很大的提升。下面开始讲解

二：主要原理

1.哈夫曼树 ：

给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近（频率越高的结点离根越进）。

以 下数组为例，构建哈夫曼树

int a[] = {0,1,2,3,4,5,6,7,8}

我们可以发现以下规律

1：9个数构成的哈夫曼树一共有17个结点，也就是可以n个数可以生产2*n-1个结点

2：数字越大的数离根节点越近，越小的数离根节点越近。


2.如何利用haffman编码实现文件压缩：

比如abc.txt文件中有以下字符：aaaabbbccde，

1.进行字符统计

    aaaabbbccde
     
    a : 4次
    b : 3次
    c : 2次
    d : 1次
    e : 1次

2.用统计结果构建哈夫曼树

3.用哈夫曼树生成哈夫曼编码（从根结点开始，路径左边记为0，右边记为1）：

    a的编码：1
    b的编码:01
    c的编码:000
    d的编码:0011
    e的编码:0010

4.哈夫曼编码代替字符，进行压缩。

源文件内容为：aaaabbbccde
将源文件用对应的哈夫曼编码（haffman code）替换，则有：11110101 01000000 00110010   （总共3个字节）

由此可见，源文件一共有11个字符，占11字节的内存，但是经过用haffman code替换之后，只占3个字节，这样就能达到压缩的目的

三：主要技术点

1.哈夫曼树算法（哈夫曼压缩的基本算法，如何不懂该算法，小编建议先学习下该算法）

2.哈希算法（字符统计时候会用到）

3.位运算（涉及到将指定位，置0或置1）

4.内存对齐模式（小编在这里踩过坑，非常重要）

5.存储模式（大端存储，小端存储，能看懂文件16进制的形式）

6.主函数带参（很简单）

7.设置压缩密码，解压输入密码解压（小编自己加的内容）

四：实现过程

1.压缩：

1.遍历文件每个字节，统计所有的字符和其频率，

2.构建哈夫曼树

3.遍历树，给叶子节点生成哈夫曼编码

4.将字符和其频率，以及密码，写入新文件。

5.再次遍历文件每个字节，将该字节内容用哈夫曼编码代表，将哈夫曼编码写入文件。

2.解压缩：

1.从文件中将将字符和其频率读出来，生成一张表。读之前可以先验证输入密码是否正确

2.用改表构建哈夫曼树。

3.遍历哈夫曼树，给叶子节点生成哈夫曼编码

4遍历文件每个bit位，按照哈夫曼编码，得到数个bit所对应得到字符，将该字符写入文件。

五：详细分析，及代码实现

三个必要的位运算，（这三个方法是他人提供）

//判断指定位是否为0，若index位为0，则GET_BYTE值为假，否则为真
#define GET_BYTE(value, index) (((value) & (1 << ((index) ^ 7))) != 0)
//将指定位，置为1
#define SET_BYTE(value, index) ((value) |= (1 << ((index) ^ 7)))
//将指定位，置为0
#define CLR_BYTE(value, index) ((value) &= (~(1 << ((index) ^ 7))))

1.字符统计

结构体定义

typedef struct huffman{
	int character;
	int freq;
}HUFFMAN;

统计过程及哈希算法

//count初值为0，传过来用于统计多少种字符，goalfile，为文件名称
HUFFMAN *freqhuf(int *count, char *goalfile){
	int freq[256] = {0};
	int i;
	int index;
	HUFFMAN *result;
	FILE *fpIn;
	int ch;
	
	fpIn = fopen(goalfile, "rb");
	ch = fgetc(fpIn);
//统计所有字符，这里巧妙的采用哈希算法，用字符的ASCII码值作为下标，
//freq[ASCII]的值，作为该字符的频率，很巧妙的形成字符和其频率的映射关系
	while (!feof(fpIn)) {
		freq[ch]++;
		ch = fgetc(fpIn);
	}
	fclose(fpIn);
//统计多少种字符
	for(i = 0; i < 256; i++){
		if(freq[i] != 0){
			(*count)++;
		}
	}
//将统计的结果，字符和其频率生成数组返回出去。
	result = (HUFFMAN *)calloc((2*(*count) - 1), sizeof(HUFFMAN));
	for(i = 0,index = 0; i < 256; i++){
		if(freq[i] != 0){
			result[index].character = i;
			result[index++].freq = freq[i];
		}
	}
	return result;
}

2.构建哈夫曼树

//哈夫曼树的节点
typedef struct huff{
        //字符及其频率
	HUFFMAN freq;
        //左孩子
	int left;
        //右孩子
	int right;
        //是否用过0表示没有用过1表示用过
	int use;
        //该节点对于的哈夫曼编码字符串
	char *code;
}Huff;
//创建哈夫曼树
Huff *bulidhuftree(HUFFMAN *information, int *count){
	int i;
	int degree = 2*(*count) - 1;
	Huff *result;
	int temp;

	//将生成的哈夫曼树放在result里返回
	result = (Huff *)calloc(sizeof(Huff), degree);
        //填充基本字符及其频度
	for(i = 0; i < *count; i++){
		result[i].freq.freq = information[i].freq;
		result[i].freq.character= information[i].character;
		result[i].left = -1;
		result[i].right = -1;
		result[i].use = 0;
		result[i].code = (char*)malloc(sizeof(char)*(*count));
	}
	//根据基本字符及其频度填充哈夫曼表
	for(i = *count; i < degree; i++){
		result[i].use = 1;
		result[i].freq.character = '#';
		result[i].right = searchmin(result, *count);
		result[i].left = searchmin(result, *count);
		result[i].freq.freq = result[result[i].right].freq.freq + result[result[i].left].freq.freq;
		temp  = searchmin(result, ++(*count));
		if(temp == -1){
			break;
		}
		result[temp].use = 0;
		result[i].use = 0;
	}
	return result;
}
//查找到频率最小的字符的下标
int searchmin(Huff *freq, int count){
	int i;
	int minindex = -1;
	
	for(i = 0; i < count; i++){
		if(freq[i].use == 0){
			minindex = i;
			break;
		}
	}
	if(minindex == -1){
		return -1;
	}
	for(i = 0; i < count; i++){
		if((freq[i].freq.freq <= freq[minindex].freq.freq) && freq[i].use == 0){
			minindex = i;
		}
	}
	freq[minindex].use = 1;
	return minindex;
}

3.构建哈夫曼编码

根节点所在的下标，index为字符串下标，str为字符串，

void bulidhuftreecode(int root, int index, Huff *freq, char *str){
	//采用递归，此处是哈夫曼压缩最难得地方，建议大家根据代码遍历跟踪一遍
	if(freq[root].left != -1 && freq[root].right != -1){
		str[index] = '1';
		bulidhuftreecode(freq[root].left, index+1, freq, str);
		str[index] = '0';
		bulidhuftreecode(freq[root].right, index+1, freq, str);
	}
	else{
		str[index] = 0;
		strcpy(freq[root].code, str);
	}	
}

4.写入压缩文件头信息（密码，字符数量，压缩文件标志），写入所有字符和其频率。

typedef unsigned char u8;
//压缩文件的头信息
typedef struct message{
        //前三个字节用M，u,f代表哈夫曼文件，不是这三个字符代表该文件不是压缩文件
 	u8 ishuf[3];
        //字符数量
 	u8 count;
        //最后一个字符所对应的下标
 	u8 lastindex;
        //密码（密码可以用自己学过的加密方式加密，这里我没有用加密算法）
 	int password;
}MESSAGE;
//创建压缩文件
void creatcodefile(Huff *freq, int count, char *goalfile, char *resultfile, HUFFMAN *storefreq){
	FILE *fpOut;
	FILE *fpIn;
	unsigned char value;
	int i;
	int index = 0;
	const char *hufCode;
	int arr[256];
	int ch;
	int password;
	MESSAGE headcode = {'M', 'u', 'f'};

	//将密码存入文件头信息
	printf("请设置压缩密码，以便解压时候用：\n");
	scanf("%d", &headcode.password);
	printf("压缩中！请稍等。\n");
	
	fpOut = fopen(resultfile, "wb");
	fpIn = fopen(goalfile, "rb");
	headcode.count = (u8)(count + 1)/2;
	headcode.lastindex = howlongchar(freq, count);
        //将文件头信息写入文件
	fwrite(&headcode, sizeof(MESSAGE), 1, fpOut);
        //将字符和其频率写入文件
	fwrite(storefreq, sizeof(HUFFMAN), (count + 1)/2, fpOut);
	
	for(i = 0; i < (count + 1)/2; i++){
		arr[freq[i].freq.character] = i;
	}
        //遍历源文件，将每个字符按其哈夫曼编码写入新文件
	ch = fgetc(fpIn);
	while(!feof(fpIn)){
		hufCode = freq[arr[ch]].code;
		for(i = 0; hufCode[i]; i++){
			if(hufCode[i] == '0'){
				CLR_BYTE(value, index);
			}
			if(hufCode[i] == '1'){
				SET_BYTE(value, index);
			}
			if(++index >= 8){
				index = 0;
				fwrite(&value, 1, 1, fpOut);
			}
		}
		ch = fgetc(fpIn);
	}
	if(index){
		fwrite(&value, 1, 1, fpOut);
	}
	fclose(fpIn);
	fclose(fpOut);
}

压缩后的文件展示

 

主函数代码，以及其他辅助方法。

//得到哈夫曼文件最后一个字节第几个是有效位
int howlongchar(Huff *freq, int count){
	int i;
	int sum = 0;
	
	for(i = 0; i < (count + 1)/2; i++){
		sum = sum + strlen(freq[i].code);
		sum &= 0xFF;
	}
	return sum % 8 == 0 ? 8 : sum % 8;
}
int main(int argc, char *argv[]) {
	int count = 0;
	HUFFMAN *information;
	Huff *freq;
	char *str;
	char 	resultfile[50];
	char  goalfile[50];
	FILE *fp;
	int i;
	
	fp = fopen(argv[1], "r");
	if(fp == NULL){
		printf("不存在该文件！");
		return 0;
	}
	fclose(fp);
	fp = fopen(argv[2], "w");
	fclose(fp);	
	strcpy(goalfile, argv[1]);
	strcpy(resultfile, argv[2]);
	//统计字符
	information = freqhuf(&count, goalfile);
        //临时数组存每个字符code
	str = (char*)malloc(sizeof(char)*(count+1));
        //构建哈夫曼树
	freq = bulidhuftree(information, &count);
        //构建哈夫曼编码
	bulidhuftreecode(count - 1, 0, freq, str);
        //创建压缩文件
	creatcodefile(freq, count, goalfile, resultfile, information);
	//释放内存
	free(information);
	free(str);
	for(i = 0; i < count; i++){
		free(freq[i].code);
	}
	free(freq);
	printf("压缩成功！");
	
	return 0;  
}

解压缩：基本与压缩原理相似

1.从文件中将将字符和其频率读出来，生成一张表。读之前可以先验证输入密码是否正确

HUFFMAN *freqhuf(int *count, char *goalfile, int *lastindex){
	int i;
	HUFFMAN *result;
	FILE *fpIn;
	
	fpIn = fopen(goalfile, "rb");
	if(fseek(fpIn, 3L, SEEK_SET) == 0){
		fread(count, sizeof(char),  1, fpIn);
		fread(lastindex, sizeof(char),  1, fpIn);
	}
	result = (HUFFMAN *)calloc(sizeof(HUFFMAN), *count);
	if(fseek(fpIn, 12L, SEEK_SET) == 0){
		fread(result, sizeof(HUFFMAN), *count, fpIn);
	}
	fclose(fpIn);
	return result;
}

2、初始化哈夫曼表

和压缩过程一样。

3、生成哈夫曼树

和压缩过程一样。

4、生成哈夫曼编码

和压缩过程一样。

5、从压缩文件中读取二进制信息，还原文件

void creatsourcefile(Huff *freq, int count, char *goalfile, char *resultfile, int lastindex){
	FILE *fpOut;
	FILE *fpIn;
	long temp;
	u8 value;
	int index = 0;
	int root;
	long bitecount;
	int fininsh = 0;
	
	fpIn = fopen(goalfile, "rb");
	fseek(fpIn, 0L, SEEK_END);
	bitecount = ftell(fpIn);
	fclose(fpIn);
	
	root = count - 1;
	temp = (long)(count + 1)/2;
	fpOut = fopen(resultfile, "wb");
	fpIn = fopen(goalfile, "rb");
	if(fseek(fpIn, temp * 8 + 12, SEEK_SET) == 0){
		printf("解码中！");
		fread(&value, sizeof(char), 1, fpIn);
		while(!fininsh){
			if(GET_BYTE(value, index) == 0){
				root = freq[root].right;
			}
			if(GET_BYTE(value, index) == 1){
				root = freq[root].left;
			}
			if(freq[root].right == -1 && freq[root].right == -1){
				fwrite(&freq[root].freq.character, sizeof(char), 1, fpOut);
				root = count - 1;
			}
			if(++index >= 8){
				index = 0;
				fread(&value, sizeof(char), 1, fpIn);
			}
			if(ftell(fpIn) == bitecount){
				if(index >= lastindex){
					fininsh = 1;
				}
			}		
		}
		printf("解码成功！\n");	
	}
	else{
		printf("解码失败！\n");
	}
}

主函数

int main(int argc, char *argv[]) {
	int count = 0;
	HUFFMAN *information;
	Huff *freq;
	char *str;
	char 	resultfile[50];
	char  goalfile[50];
	FILE *fp;
	char Huf[3];
	int lastindex = 0;
	int i;
	int password;
	int unpassword;
	
	fp = fopen(argv[1], "rb");
	if(fp == NULL){
		printf("不存在该文件！");
		return 0;
	}
	fread(&Huf, sizeof(char), 3, fp);
	if(Huf[0] != 'M' || Huf[1] != 'u' || Huf[2] != 'f'){
		printf("该文件不是哈夫曼压缩的文件！");
		return 0;
	}
	if(fseek(fp, 8L, SEEK_SET) == 0){
		fread(&password, sizeof(int), 1, fp);
		printf("请输入解压密码：");
		scanf("%d", &unpassword);
		if(password != unpassword){
			printf("密码错误！");
			return 0;
		}
	}
	fclose(fp);
	fp = fopen(argv[2], "w");
	fclose(fp);
	strcpy(goalfile, argv[1]);
	strcpy(resultfile, argv[2]);
	
	information = freqhuf(&count, goalfile, &lastindex);
	str = (char*)malloc(sizeof(char)*(count+1));  //临时数组存每个字符code
	freq = bulidhuftree(information, &count);
	bulidhuftreecode(count - 1, 0, freq, str);
	free(str);
	creatsourcefile(freq, count, goalfile, resultfile, lastindex);
	
	free(information);
	for(i = 0; i < count; i++){
		free(freq[i].code);
	}
	free(freq);
	free(str);
	return 0;  
}

基于哈夫曼编码的文件压缩解压程序的C语言实现
06-07
利用无失真信源编码方法中的哈夫曼编码进行程序设计实践，实现对文件的压缩与解压操作。
C语言实现哈夫曼编码压缩和解压各种文件
11-19
实验目的：理解哈弗曼信源编码算法，并能应用于文件压缩中。 实验内容：写出程序，利用哈弗曼编码实现对文件的压缩，并能解压文件。 实验步骤： 1、压缩 （1） 统计原始文件中各字节出现的概率（次数）； （2） 采用哈弗曼算法对各字节进行编码，建立哈弗曼对照表； a) 构造二叉树 b) 编码 （3） 依次读取原始文件的每个字节，查找其对应的哈弗曼编码，将这些位写入到压缩文件中（注意：要凑够8位二进制才写入到文件中）。 （4） 将原始文件中各字节及出现的次数也写入到压缩文件中。 2、解压 （1） 从压缩文件中获得原始文件各字节及出现的次数，并根据此构造哈弗曼对照表; （2） 将压缩文件中对应
哈夫曼编码（小顶堆）
qq_74143684的博客
08-19 1188
哈夫曼编码是一种根据字符出现频率设计的变长编码方式，常用于数据压缩。它的基本思想是，将出现频率较高的字符用较短的编码表示，而出现频率较低的字符用较长的编码表示，从而减小编码的总长度。
C语言Huffman压缩和解压
aoningxun2220的博客
09-26 710
符号表结构体： struct node { // 字符串形式存储的Huffman编码 char code[MAX_CODE_LENGTH]; // 这个字符在文件中出现的次数 long count; // 在生成Huffman树的时候是否已经被当作叶子节点 int checked; // 符号 ...
数据压缩解析及C语言实现介绍
tpfgfxz的专栏
07-10 5855
引言 　　现有的压缩算法有很多种，但是都存在一定的局限性，比如：LZw[1]。主要是针对数据量较大的图像之类的进行压缩，不适合对简单报文的压缩。比如说，传输中有长度限制的数据，而实际传输的数据大于限制传输的数据长度，总体数据长度在100字节左右，此时使用一些流行算法反而达不到压缩的目的，甚至增大数据的长度。本文假设该批数据为纯数字数据，实现压缩并解压缩算法。 　　1 数据压缩概念 　　数
基于哈夫曼树的数据压缩算法（C语言）
Cap07博客
12-04 4248
头文件（head.h）： #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef int ElemType; typedef int Status; typedef struct { ElemType* base; ElemType* top; int stacksize; }SqStack, * SqStacklist; SqStacklist InitStack(); void Push(SqStacklist S, El
哈夫曼压缩与解压缩
11-28
哈夫曼实现文件的压缩与解压缩，代码关键部分有注释。
哈夫曼压缩解压算法-C语言
05-16
C语言实现的huffman压缩解压缩算法
C语言哈夫曼树压缩/解压器
Zheng_Jay的博客
05-09 1487
C语言哈夫曼树压缩/解压器 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样
基于哈夫曼树的文件压缩和解压
m0_58235748的博客
06-18 2767
哈夫曼树（Huffman Tree）是一种带权路径长度最短的树，也称最优二叉树，是经典的数据压缩算法中的核心思想。哈夫曼树的构建过程：根据给定的n个权值 {w1, w2, …, wn}，构造n棵只有一个节点的二叉树（这些节点我们可以视为叶子节点），每棵二叉树的根节点的权值已经设定为对应权值。在森林里选取两棵根节点的权值最小的树进行合并。得到一棵新树，该树的根节点权值为原来的两棵树的根节点权值之和。将新树放回森林中，并将原来两棵树从森林列表中删除。重复执行步骤2和3，直到森林里只有一棵树为止。
文件压缩与解压（哈夫曼编码）
11-06
利用哈夫曼编码原理对磁盘文件进行压缩与解压
C语言实现的基于Huffman哈夫曼编码的数据压缩与解压缩.7z
06-08
根据ASCII码文件中各ASCII字符出现的频率情况创建Haffman树，再将各字符对应的哈夫曼编码写入文件中，实现文件压缩。
基于哈夫曼编码的文本文件压缩与解压缩
10-30
基于哈夫曼编码的文本文件压缩与解压缩，使用c语言，实际只是编码解码，不应该称为解压缩，因为编码后文件会更大
Huffman文件压缩解压缩-C语言-数据结构
06-23
【C语言】【数据结构】【压缩、解压缩】利用哈夫曼编码进行对已有文件进行重新编码可以大大提高减小文件大小，减少存储空间。这要求在首先对一个现有文件进行编码行成新的文件，也就是压缩。在文件使用时，再对压缩文件进行解压缩，也就是译码，复原原有文件。 完美运行！
使用Huffman对文件进行压缩和解压缩
01-12
使用java语言实现Huffman对任意文件做到压缩和解压缩，压缩后的文件只能通过解压缩来解压后才能读取
Huffman:用c实现文件压缩和解压的霍夫曼编码算法
06-08
哈 该程序用于压缩或解压缩文件。 源代码以 API 风格构建，然后您可以使用 Huffman 编码轻松编写自己的压缩工具。 程序说明 ha使用技术压缩（和解压缩）文件。 输入文件被分成名为block的常规块，这个块有一个固定大小的block-size ，默认为10MB。 压缩率本身并不是很好，因为与bzip2或xz等其他工具相比，仅使用 Huffman 代码并不是很有效。 由于霍夫曼代码本身的性质，最小压缩大小是原始输入大小的八分之一，但这仅在您的文件包含相同字符时追加。 这个程序的优点是它的速度： 它是使用 pthread API 的多线程 霍夫曼码很容易计算 程序使用 ha input_filename -o output_filename 这只是一个基本用法示例，但您可以通过键入ha -h来查看所有选项。 使用此命令行，您将使用 10MB 的块大小、100MB 的最大内存使用量和
基于哈夫曼编码的解压缩软件C语言项目资源.zip
最新发布
10-31
基于哈夫曼编码的解压缩软件C语言项目资源
哈夫曼压缩算法程序c语言,基于哈夫曼(haffuman)算法的文件压缩的实现（C语言）(转)...
weixin_31937605的博客
05-21 1048
本文首先简要阐述哈夫曼算法的基本思想，然后介绍了使用哈夫曼算法进行文件压缩和解压缩的处理步骤，最后给出了C语言实现的文件压缩和解压缩的源代码。哈夫曼算法的主要思想是：①首先遍历要处理的字符串，得到每个字符的出现的次数；②将每个字符(以其出现次数为权值)分别构造为二叉树(注意此时的二叉树只有一个节点)；③取所有二叉树种种字符出现次数最小的二叉树合并为一颗新的二叉树，新二叉树根节点的权值等于两个子节点...
哈夫曼编码应用之实现文件压缩
no_sying_nothing的博客
07-30 3861
背景：为了锻炼自己的代码能力，以及数据结构算法掌握的能力，做此项目来锻炼自己提高自己的能力，本项目运用了C++中的知识，比如模板类，仿函数等等，还用到了数据结构中的算法知识，比如建堆调堆、哈夫曼编码，还用到了文件操作的知识。总是试一次很好的训练。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值