刻意练习-哈夫曼编码简单压缩一个文件

最新推荐文章于 2023-01-08 21:02:40 发布
最新推荐文章于 2023-01-08 21:02:40 发布
阅读量286 收藏 1
点赞数
分类专栏： 数据结构/算法/设计模式 刻意练习-编程 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/renyongjian1994/article/details/119054144
版权

一、文件是如何被压缩的？

  • 现在假设有这样一个文件，文件内容如下：

    damainnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaaaaaaaaaaaaaaaaaaaaaaaaaayikunnnnnnnnnnnnnnnaaaaaaaaaa

  • 现在这个文件总共是100个字节

在这里插入图片描述

  • 现在文件里面的内容是一个字符占用一个字节(bytes)，8个bit。如果我有办法能够用更少的bit来表示这个文件中的内容，就能够实现文件的压缩。

  • 所以，我先放弃ascii 编码，使用另外一个表来编码这个文件。 这个表怎么来的呢？看这里。

    haffuman_map haffuman_table[]=
{
	{'n',0b1,1},
	{'a',0b01,2},
	{'d',0b00011,5},
	{'i',0b0010,4},
	{'y',0b0000,4},
	{'u',0b00010,5},
	{'m',0b00110,5},
	{'k',0b00111,5},
};

  • 这里可以看到，n只需要一个bit就能表示。文件中的n出现了55次，之前就是需要55个字节，现在只需要55/8 不到7个字节就表示成功了。文件占的空间少了，也就是被压缩了。

  • 理论上，只要我的这个表非常的丰富，包含了所有的字符，并且高频出现的采用更少的字节存储，那么，就能压缩所有的字符文件。核心其实是这个表。

二、抽象

  • 压缩和解压

    //把from 文件 压缩成 to 文件。
int compress_to_file(char *from_file,char *to_file);
//把 from 的压缩文件，解压缩成to 文件。
int uncompress_to_file(char *from_file,char *to_file);

  • 对bit的操作。因为不再是对一个个字节的操作，而是涉及到一个个的读取bit，一个个的写入bit。所以抽象了一个流的结构体操作bit。

    typedef struct bit_stream
{
    /*当前读取或者写入的字节指针*/
	char *p;
    /*当前这个字节写入第几个bit了*/
	int locate;
    /*最后总共写了多少个bit*/
	int bit_len;
    /*用来存放流数据的buffer.*/
	char *buff;
    /*用来存放流数据的buffer大小*/
    int  buff_size_t;
}bit_stream;

  • 文件和buffer的数据交互。需要从文件中读取数据到buffer,把buffer写入到文件中。

    /*把文件读取到buffer中*/
int read_file_to_buffer(char *file_name,char *buff,int buff_len);
/*把buffer 写入到文件中*/
int write_buff_to_file(char *file_name,char *buff,int buff_len);

三、实现

  • 加密实现

    在这里插入图片描述

  • 解密实现

    在这里插入图片描述

四、整理

  • 完整代码

    #include<stdio.h>
#include<string.h>

typedef struct haffuman_map
{
	char src_chr;
	char dst_chr;
	int bit_size;
}haffuman_map;

typedef struct bit_stream
{
	int  buff_size_t;
	char *p;
	int locate;
	int bit_len;
	char *buff;
}bit_stream;

#define RENYJ_TRACE( format, args... )  do {fprintf(stderr,  "RENYJ_TRACE >>> %s->%s()->line.%d : " format "\n", __FILE__, __FUNCTION__, __LINE__, ##args);}while(0)


haffuman_map haffuman_table[]=
{
	{'n',0b1,1},
	{'a',0b01,2},
	{'d',0b00011,5},
	{'i',0b0010,4},
	{'y',0b0000,4},
	{'u',0b00010,5},
	{'m',0b00110,5},
	{'k',0b00111,5},
};

char bit_table[] = {0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};

int bit_stream_construct(bit_stream *p_stream,char *buffer,int buffer_size)
{
	if(p_stream == NULL)
	{
		return 0;
	}
	
	p_stream->buff = buffer;
	p_stream->buff_size_t = buffer_size;
	p_stream->p = buffer;
	p_stream->locate = 0;
	p_stream->bit_len = 0;
	return 0;
}

int read_bit(bit_stream *p_stream)
{
	if(p_stream == NULL)
	{
		return -1;
	}
	
	if((p_stream->p - p_stream->buff )*8 + p_stream->locate >= p_stream->bit_len)
	{
		return -1;
	}
	
	int bit_value = ((*(p_stream->p) & bit_table[p_stream->locate]));
	p_stream->locate++;
	if(p_stream->locate%8 == 0)
	{
		p_stream->locate = 0;
		p_stream->p++;
	}
	return (bit_value && 1);
}


int write_bit(bit_stream *p_stream,int bit)
{
	if(p_stream == NULL)
	{
		return -1;
	}
	
	if(bit)
	{
		*(p_stream->p) |= bit_table[p_stream->locate];
	}

	p_stream->bit_len++;
	p_stream->locate++;
	if(p_stream->locate%8 == 0)
	{
		p_stream->locate = 0;
		p_stream->p++;
	}
	return 0;
}

haffuman_map *encode_char(char ch)
{
	int i = 0;
	for(i = 0; i < sizeof(haffuman_table)/sizeof(haffuman_table[0]); i++)
	{
		if(haffuman_table[i].src_chr == ch)
		{
			return &haffuman_table[i];
		}
	}
	return 0;
}

int decode_char(char ch,char *ori_chr)
{
	int i = 0;
	for(i = 0; i < sizeof(haffuman_table)/sizeof(haffuman_table[0]); i++)
	{
		if(haffuman_table[i].dst_chr == ch)
		{
			*ori_chr =  haffuman_table[i].src_chr;
			return 0;
		}
	}
	return -1;
}

char locate_valid_start_bit(haffuman_map *cur_en_code)
{
	if(cur_en_code == NULL)
	{
		return -1;
	}
	
	int i = 0;
	for(i = 0;i < 7;i++)
	{
		if(i == (8-cur_en_code->bit_size))
		{
			break;
		}
	}
	return i;
}


int write_en_code_to_stream(bit_stream *p_stream,haffuman_map *cur_en_code)
{
	char valid_start_bit = 0;
	int i = 0;
	
	/*找到有效的bit起始位置*/
	valid_start_bit = locate_valid_start_bit(cur_en_code);
	/*依次写入*/
	for(i = valid_start_bit ; i < 8; i++)
	{
		write_bit(p_stream,cur_en_code->dst_chr & bit_table[i]);
	}
	return 0;
}


int write_en_code_stream_to_file(bit_stream *p_stream,char *file_name)
{
	/*需要把数据流的信息写入到文件中去*/
	FILE *fp = fopen(file_name,"wb");
	if(fp == NULL)
	{
		return -1;
	}
	fwrite(&(p_stream->bit_len),4,1,fp);
	fwrite(p_stream->buff,1,p_stream->bit_len/8+1,fp);
	fclose(fp);
	return 0;
}

int read_en_code_stream_from_file(char *file_name,bit_stream *p_stream)
{
	/*先读取数据流的信息*/
	FILE *fp = fopen(file_name,"rb");
	if(fp == NULL)
	{
		return -1;
	}
	fread(&(p_stream->bit_len),4,1,fp);
	fread(p_stream->buff,1,p_stream->bit_len/8+1,fp);
	fclose(fp);
	return 0;
}

int encode_buffer_to_stream(char *src_string,int src_len,bit_stream *p_stream)
{
	if(p_stream == NULL)
	{
		return -1;
	}
	char i = 0;
	char en_code = 0;
	haffuman_map *cur_encode_map = NULL;
	for(i = 0; i < src_len; i++)
	{
		cur_encode_map = encode_char(src_string[i]);
		/*将加密后的数据写入新buffer 组成的流中*/
		write_en_code_to_stream(p_stream,cur_encode_map);
	}	
	return 0;
}

int decode_stream_to_buff(char *buffer,int buff_len,bit_stream *p_stream)
{
	if(buffer == NULL || p_stream == NULL)
	{
		return -1;
	}
	/*初始化流的位置，从头开始读取*/
	p_stream->locate = 0;
	p_stream->p = p_stream->buff;
	char en_code = 0;
	char ori_chr = 0;
	int bit_value = 0;
	int ret = -1;
	int ori_index = 0;
	
	/*依次读取所有的bit*/
	while((bit_value = read_bit(p_stream)) != -1)
	{
		en_code = (en_code << 1)+bit_value;
		/*如果成功解码，从下一个bit开始，组装新的字符*/
		ret = decode_char(en_code,&ori_chr);
		if(ret != -1)
		{
			en_code = 0;
			buffer[ori_index] = ori_chr;
			ori_index++;
		}
	}
	return 0;
}


int read_file_to_buffer(char *file_name,char *buff,int buff_len)
{
	if(file_name == NULL)
	{
		return -1;
	}
	
	FILE *fp = fopen(file_name,"rb");
	if(fp == NULL)
	{
		return -1;
	}
	int act_len = fread(buff,1,buff_len,fp);
	fclose(fp);
	return act_len;
}

int write_buff_to_file(char *file_name,char *buff,int buff_len)
{
	if(file_name == NULL)
	{
		return -1;
	}
	/*需要把数据流的信息写入到文件中去*/
	FILE *fp = fopen(file_name,"wb");
	if(fp == NULL)
	{
		return -1;
	}
	int act_len = fwrite(buff,1,buff_len,fp);
	fclose(fp);
	return act_len;
}

int compress_to_file(char *from_file,char *to_file)
{
	if(from_file == NULL || to_file == NULL)
	{
		return -1;
	}
	/*压缩*/
	bit_stream write_stream;
	bit_stream *p_stream = &write_stream;
	memset(p_stream,0x00,sizeof(bit_stream));
	
	/*存放原始数据*/
	char buffer[1024] = {0};
	
	/*用来存放流中的buffer*/
	char stream_buff[1024] = {0};
	
	/*构建一个流*/
	bit_stream_construct(p_stream,stream_buff,sizeof(stream_buff)-1);
	
	/*从原始数据中读取，放到buffer中*/
	int act_len = read_file_to_buffer(from_file,buffer,sizeof(buffer)-1);
	RENYJ_TRACE("act_len=%d,buffer=%s",act_len,buffer);
	/*将 buffer 加密到 stream 中*/
	encode_buffer_to_stream(buffer,act_len,p_stream);

	/*将加密后的stream 中数据写入文件*/
	write_en_code_stream_to_file(p_stream,to_file);
	return 0;
}


int uncompress_to_file(char *from_file,char *to_file)
{
	if(to_file == NULL)
	{
		return -1;
	}
	/*解压缩*/
	bit_stream read_stream;
	bit_stream *p_stream = &read_stream;
	memset(p_stream,0x00,sizeof(bit_stream));
	/*用来存放加密buffer的*/
	char stream_buff[1024] = {0};
	
	/*用来存放原始buffer的*/
	char buffer[1024] = {0};
	
	/*构建一个流*/
	bit_stream_construct(p_stream,stream_buff,sizeof(stream_buff)-1);
	
	/*加密文件读取到 stream 中*/
	read_en_code_stream_from_file(from_file,&read_stream);
	
	/*加压到 buffer 中*/
	decode_stream_to_buff(buffer,sizeof(buffer)-1,p_stream);
	
	/*写入指定的文件中*/
	write_buff_to_file(to_file,buffer,strlen(buffer));
	return 0;
}

int main(int argc, const char *argv[])
{
	char *src_string = "damainnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaaaaaaaaaaaaaaaaaaaaaaaaaayikunnnnnnnnnnnnnnnaaaaaaaaaa";
	int str_len = strlen(src_string);
	
	char *from_file = "./hello";
	write_buff_to_file(from_file,src_string,str_len);
	
	compress_to_file(from_file,"./compress_hello");
	
	uncompress_to_file("compress_hello","uncompress_hello");
	return 0;
}

  • 从理论上讲，如果我的表足够的丰富和准确，我就能压缩和解压所有的文件。

  • 运行结果

    在这里插入图片描述

    可见，压缩文件之前有100个字节，压缩之后，有25个字节，解压缩之后，100个字节。

五、方法记忆

  • 压缩的本质是换一种编解码的方法。 将高频出现的内容采用更少的bit来存储，低频出现的内容采用较多的bit来存储。整体占用的空间就会下降。
  • 对数据流操作，就是不断的能够记录当前数据的位置，下一次读取或者写入的时候能够找到这个位置。 就仿佛没有间断，也就形成了流。

六、参考

  • 哈夫曼编码
不问江湖任少侠
关注
专栏目录
哈夫曼编码 简介
aibianchendewo的专栏
12-19 539
哈夫曼编码简介     哈弗曼编码几乎是所有压缩算法的基础，其实这个算法并不复杂，简单的理解就是，如何用更短的bit来编码数据。     我们知道普通的编码都是定长的，比如常用的ASCII编码,每个字符都是8个bit: 字符 编码 A 00101001 B 00101010 C 00101011 … …
哈夫曼编码与文件压缩
qq_39749300的博客
08-30 4164
一：哈夫曼树与哈夫曼编码 大家知道，文件压缩的原理么？ 假如我们有一个文件，文件当中仅有 A、B、C、D、E 五种字符，这五种字符出现的频率分别为 5次、4次、3次、2次、1次。 我们知道每个英文字母均占用一个字节，即 8 个比特，所以，我们可以认为原文件的大小就是15个字节，即：120 个比特。 现在，我们要设计一种能够压缩这个文件的算法，你会怎么做？ 固定长度编码 如果这个文件中仅有 A、B、C、D、E 这五种字符，我们可以让 A、B、C、D、E 按照二进制数分别表示为 000，001，010，011，
[ 数据结构 ] 赫夫曼编码--------数据、文件压缩解压
最新发布
jason_bone_的博客
01-08 457
如上图:给定字符串按定长编码处理,最终对应二进制长度为359思考:如何压缩,将359有效降低?----
哈夫曼树 & 哈夫曼编码
KIMTOU的博客
05-11 1万+
哈夫曼树 哈夫曼树的定义：设二叉树具有 n 个带权值的叶节点，那么从根节点到各个叶节点的路径长度与相应叶节点权值的乘积的和，叫作二叉树的带权路径长度 WPL (Weighted Path Length)。具有最小带权路径长度的二叉树称为哈夫曼树 (Huffman Tree)，也称为最优二叉树。权值较大的结点离根较近。 构造哈夫曼树的原则（贪心思想）： 权值越大的叶节点越靠近根节点 权值越小的叶节点越远离根节点 哈夫曼编码 哈夫曼编码就是规定哈夫曼树中的左分支为 0，右分支为 1，从根节点到每个叶节点所经
C语言利用哈夫曼树压缩文本文件
星空千代
04-13 1万+
利用最优二叉树(也称哈夫曼树)可以对文本进行编码， 从而实现压缩。
C语言实现哈夫曼编码压缩和解压各种文件
11-19
（3） 依次读取原始文件的每个字节，查找其对应的哈弗曼编码，将这些位写入到压缩文件中（注意：要凑够8位二进制才写入到文件中）。 （4） 将原始文件中各字节及出现的次数也写入到压缩文件中。 2、解压 （1） 从...
哈夫曼编码压缩和解压缩文件——C++实现
01-20
在C++中实现哈夫曼编码压缩和解压缩文件涉及到几个关键步骤： 1. **构建哈夫曼树**： - 首先，统计输入文本中各个字符的频率，创建一个哈夫曼节点的列表，每个节点包含字符和对应的频率。 - 使用最小堆（minHeap...
哈夫曼编码数据压缩_哈夫曼编码_哈夫曼编码实现数据压缩_
10-03
哈夫曼编码是一种高效的数据压缩方法，由美国学者大卫·哈夫曼在1952年提出，主要用于无损数据压缩。它通过构建特殊的哈夫曼树（也称为最优二叉树），为出现频率不同的字符分配不同的二进制编码，使得出现频率高的...
数据结构-哈夫曼编码实验报告.doc
07-11
3. 将原始文件转换为压缩文件，压缩文件的内容包括哈夫曼树的核心信息和编码序列。 4. 解压缩时，根据哈夫曼树对编码进行解码，还原出原始文件。 在压缩文件生成过程中，我们首先初始化一个大小为512的`header`数组...
基于哈夫曼编码的文本文件压缩与解压缩.zip
07-02
在“基于哈夫曼编码的文本文件压缩与解压缩.zip”这个压缩包中，很可能包含了用于演示或教学目的的哈夫曼编码实现代码、压缩和解压缩的示例文本以及相应的结果文件。学习和理解这个压缩包的内容，可以帮助我们更好地...
哈夫曼编码的理解(Huffman Coding)
一个喜欢诗和远方的程序媛
11-09 2704
1、哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是Huffman于1952年提出的一种编码方式，可变字长编码(VLC)的一种。霍夫曼编码不仅会考察文本中有多少个不同字符，还会考察每个字符出现的频率，根据频率的不同，选择不同长度的编码。霍夫曼编码试图用这种不等长的编码方法，来进一步增加压缩的效率，广泛用于数据压缩中，其压缩率通常在 20%～90% 之间。有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。 2、举例说明： 假设我有一个包含 1000 个字符的文件，每个字符
哈夫曼编码
DamonUp的博客
03-05 1036
在计算机数据处理中，霍夫曼编码使用变长编码表对源符号进行编码，出现频率较高的源符号采用较短的编码，出现频率较低的符号采用较长的编码，使编码之后的字符串字符串的平均长度 、期望值降低，以达到无损压缩数据的目的。 举个例子，现在我们有一字符串： this is an example of a huffman tree 这串字符串有36个字符，如果按普通方式存储这串字符串，每个字符占据1个字节...
哈弗曼编码，求编码字节总数
qq_29442755的博客
05-06 2832
问题描述：哈弗曼编码可以实现一个文本的压缩编码，现有一个字符串代表文本内容，请问此文本经过哈弗曼编码后的大小是多少字节。如：“aabc”建立一棵哈弗曼树可知上述字符串中的字符的编码a：1b：00c：01因此，“aabc”的哈弗曼编码为“110001”，共六个字节。代码如下：#include &lt;iostream&gt;using namespace std;char str[30]; //输入...
基于哈夫曼编码对文件进行压缩和解压缩（详细讲解）
lizefeng1998的博客
04-08 2万+
基于哈夫曼编码对文件进行压缩和解压缩（详细讲解） 本文对应c++代码实现链接 一、背景 利用特定的算法来压缩数据的工具，压缩后生成的文件称为压缩包。如果想使用其中的数据，就得用压缩软件对数据进行解压。利用压缩软件对文件中重复的数据进行压缩，可以减小文件中的字节总数，常用的压缩软件有rar、zip等。 二、编码介绍 2.1 等长编码 任何文件在计算中都是以字节为最小单位进行存储的，所以可以把任何文件看作是利用8位（一个字节）作为等长编码编码方式，编码而成的文件。往往这种编码方式并不是最优的编码方式。 例如：对
生成赫夫曼编码表
热门推荐
Frank---7的博客
03-28 5万+
package com.atguigu.huffmancode; import com.sun.org.glassfish.external.statistics.CountStatistic; import com.sun.org.glassfish.external.statistics.StringStatistic; import java.util.*; /** * @创建人 wdl * @创建时间 2021/3/27 * @描述 */ public class HuffmanCod
【数据结构】Huffman编码
糖梦梦是女侠
12-02 5414
基础知识         目前，进行快速的远距离通信的主要手段是电报，即将需传送的信息转换成由二进制字符组成的字符串。例如，需传送的信息为“ABACCDA”，它只有四个字符，只需要两个字符的串便可以进行编码。假设A、B、C、D的编码分别为00、01、10、11，则上述信息所转换成的电文为“00010010101100”，总长为14位，对方接收到时，可按照二位一分进行译码。         当然
哈夫曼树实现电文编码译码
CD__ordinary_word的博客
01-02 3157
哈夫曼编码实现电文字符串编码电文编码 电文编码 输入的一串电文字符实现哈夫曼编码，再对哈夫曼编码生成的 代码串进行译码，输出电文字符串。即以字符串字母出现次数为权值，生成哈夫曼树。 #include<stdio.h> #include<string.h> #include<stdlib.h> #define MAXSIZE 50 typedef char DataType; typedef struct // 哈夫曼树结点的结构 { DataType data;
电文的编码和译码（哈夫曼树的应用）
Pabebe的博客
12-30 1万+
一、        实验环境 学宝虚拟机，VC6.0二、        实验目的 从键盘接收一串电文字符，输出对应的哈夫曼编码，同时能翻译哈夫曼编码生成的代码串，输出对应的电文字符。三、        实验内容1.用C语言实现二叉树的链式（二叉链表）存储结构；2.实现二叉树的基本操作的有关算法（二叉树的建立、各种遍历等）；3.定义二叉树的静态链表结构，并利用这种结构存储哈夫曼树，利用哈夫曼树解决编...
C++实现哈夫曼编码文件压缩与解压缩技术解析
3. 生成Huffman编码表，并将每个字符对应的编码写入压缩文件中。 4. 使用生成的Huffman编码表替换原始文件中的字符序列，完成压缩过程。 解压缩过程则是压缩过程的逆过程： 1. 读取压缩文件中的Huffman编码表。 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值