（C++）Huffman编码 加密压缩并解码文件

最新推荐文章于 2024-05-15 17:58:53 发布
最新推荐文章于 2024-05-15 17:58:53 发布
阅读量2.1k 收藏 47
点赞数 5
分类专栏： C/C++语言系统 Huffman树 文章标签： 数据结构 c++ huffman tree 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44487881/article/details/106102314
版权

Huffman编码 加密压缩并解码文件

Huffman编码

掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。

实验内容

  • 实现文件中数据的加解密与压缩：将硬盘上的一个文本文件进行加密，比较加密文件和原始文件的大小差别；
  • 对加密文件进行解密，比较原始文件和解码文件的内容是否一致。

实验说明

1．输入和输出：

（1）输入：硬盘上给定的原始文件及文件路径。

（2）输出：

  • 硬盘上的加密文件及文件路径；

  • 硬盘上的解码文件及文件路径；

  • 原始文件和解码文件的比对结果。

2．实验要求：

  • 提取原始文件中的数据（包括中文、英文或其他字符），根据数据出现的频率为权重，构建Huffman编码表；

  • 根据Huffman编码表对原始文件进行加密，得到加密文件并保存到硬盘上；

  • 将加密文件进行解密，得到解码文件并保存点硬盘上；

  • 比对原始文件和解码文件的一致性，得出是否一致的结论。

主要数据类型与变量

/********************** Huffman树结点 **********************/
//Huffman树单个结点
struct node {
	string s; //字符串存单个字符（含中文）
	int weight; //记录当前结点的权值
	node* Left, * Right; //左子树指针，右子树指针
};
//自定义结点优先级（用于优先队列）
class Compare_Huffman_node {
public:
	bool operator()(node*& a, node*& b)const {
		return b->weight < a->weight; //小顶堆
	}
};
//哈夫曼树指针，哈夫曼树结点指针
typedef struct node* HuffmanTree, * HuffmanNode; 

/********************** 全局变量 **********************/
map<string, int> FrequencyTable; //字符频率表
map<string, string> CodeTable; //哈夫曼编码表
//优先队列，取权值最小结点的堆
priority_queue<HuffmanNode, vector<HuffmanNode>, Compare_Huffman_node> Q; 
 //存储 源文件, 哈夫曼编码文件，解码文件 的字符串
string Source_s, ZeroOne_s, Decoding_s;
string CodeTable_s; //存储 译码表 的字符串
const int C_Bit = 8; //C_Bit位压缩

部分核心算法

  1. 根据字符频率表构建哈夫曼树。
    将每个字符都构建成一颗树，对森林进行n – 1次合并操作。每次选两个权值最小的树进行合并，新树的权值为两者之和，并将新树加入森林，重复合并步骤。

  2. 根据译码表重构哈夫曼树。
    遍历译码表中每个字符的哈夫曼编码，从根节点开始，0向左子树走，1向右子树走，当一段编码结束时，在此叶子结点存入对应字符。全部遍历完毕，原哈夫曼树也被重新构造出来了。译码表的构建类似，不再赘述。

  3. 加密/解密。
    加密时，遍历每个字符，按译码表转换成哈夫曼编码加入总01串中等待压缩操作。解密时，遍历01串，从哈夫曼树根结点开始，0向左子树走，1向右子树走，走到叶子节点时输出该节点所存字符，下个01字符又重新从根结点开始走。

  4. 压缩/解压缩01串（所有字符组成的哈夫曼编码）。
    按每8位压缩成一个unsigned char类型，最后不足8位时，前补0凑够8位，并将余数存入加密文件第一位。解压缩时，先读入一个07的余数，之后循环读入一个0255的unsigned char值，转换为2进制存入01串中准备翻译，全部读入后，若余数不为0，最后8为仅保留倒数余数位。

程序模块


/********************** 菜单栏 **********************/
void Encryption_Menu(); //加密选项菜单
void Decryption_Menu(); //解码选项菜单
void Compare_Menu(); //比较文件菜单

/********************** 文件操作 **********************/
string Open_File(string, void(*p)(ifstream&)); //打开文件。 传入参数：操作名称，读入字符的函数指针
void Out_File(string, void(*p)(ofstream&)); //输出文件，传入参数：操作名称，写入字符的函数指针
void Save_Encrypted(); //保存加密文件
void Load_Encrypted(); //加载加密文件
size_t Get_FileSize(const string&); //获取文件大小

/********************** Huffman树 **********************/
HuffmanTree Build_Huffman(); //构造哈夫曼树
HuffmanTree Rebuild_Huffman(); //重构哈夫曼树

/********************** 读出写入子函数 **********************/
void Read_Source(ifstream&); //读入原始文件。传入参数：ifstream流
void Read_Decoding(ifstream&);//读入解码文件
void Read_Encrypted(fstream&); //读入加密文件。传入参数：ifstream流
void Read_CodeTable(ifstream&); //读入译码表文件。传入参数：ifstream流
void Write_ZeroOne(ofstream&); //输出出01文件
void Write_Decoding(ofstream&); //输出解码文件
void Write_CodeTable(ofstream&); //输出译码表文件
void Write_Encrypted(fstream&); //输出加密文件

/********************** 加密解码 **********************/
void Coding(HuffmanTree, string); //获取哈夫曼编码表。传入参数：构建好的哈夫曼树，用于存编码的字符串
void Encryption(); //对原始文件进行哈夫曼加密
void Decryption(HuffmanTree); //对加密文件解码。传入参数：哈夫曼树

运行截图

主界面

主菜单界面
主界面
原始文件（以源代码为例）
在这里插入图片描述

加密界面

加密功能界面
加密界面
加密文件
在这里插入图片描述

解码界面

解码功能菜单
解码界面
译码表文件
在这里插入图片描述
解码文件
在这里插入图片描述

文件比较界面

比较功能菜单
在这里插入图片描述
在这里插入图片描述
比较结果信息
在这里插入图片描述
在这里插入图片描述
压缩率计算
在这里插入图片描述

源代码

#include <iostream> //C++ 流输入输出库
#include <fstream> //C++ 文件流输入输出库
#include <cstdio> //C 标准输入输出库
#include <cstdlib> //C 标准函数库
#include <cstring> //C 字符串函数库
#include <string> //C++ string类库
#include <map> //C++ map映射库
#include <queue> //C++ queue队列库
#include <algorithm> //C++ 常用算法库

using namespace std;

/********************** Huffman树结点 **********************/
//Huffman树单个结点
struct node {
	string s; //字符串存单个字符（含中文）
	int weight; //记录当前结点的权值
	node* Left, * Right; //左子树指针，右子树指针
};
//自定义结点优先级（用于优先队列）
class Compare_Huffman_node {
public:
	bool operator()(node*& a, node*& b)const {
		return b->weight < a->weight; //小顶堆
	}
};
typedef struct node* HuffmanTree, * HuffmanNode; //哈夫曼树指针，哈夫曼树结点指针

/********************** 全局变量 **********************/
map<string, int> FrequencyTable; //字符频率表
map<string, string> CodeTable; //哈夫曼编码表
priority_queue<HuffmanNode, vector<HuffmanNode>, Compare_Huffman_node> Q; //优先队列，取权值最小结点的堆
string Source_s, ZeroOne_s, Decoding_s; //存储 源文件, 哈夫曼编码文件，解码文件 的字符串
string CodeTable_s; //存储 译码表 的字符串
const int C_Bit = 8; //C_Bit位压缩

/********************** 菜单栏 **********************/
void Encryption_Menu(); //加密选项菜单
void Decryption_Menu(); //解码选项菜单
void Compare_Menu(); //比较文件菜单

/********************** 文件操作 **********************/
string Open_File(string, void(*p)(ifstream&)); //打开文件。 传入参数：操作名称，读入字符的函数指针
void Out_File(string, void(*p)(ofstream&)); //输出文件，传入参数：操作名称，写入字符的函数指针
void Save_Encrypted(); //保存加密文件
void Load_Encrypted(); //加载加密文件
size_t Get_FileSize(const string&); //获取文件大小

/********************** Huffman树 **********************/
HuffmanTree Build_Huffman(); //构造哈夫曼树
HuffmanTree Rebuild_Huffman(); //重构哈夫曼树

/********************** 读出写入子函数 **********************/
void Read_Source(ifstream&); //读入原始文件。传入参数：ifstream流
void Read_Decoding(ifstream&);//读入解码文件
void Read_Encrypted(fstream&); //读入加密文件。传入参数：ifstream流
void Read_CodeTable(ifstream&); //读入译码表文件。传入参数：ifstream流
void Write_ZeroOne(ofstream&); //输出出01文件
void Write_Decoding(ofstream&); //输出解码文件
void Write_CodeTable(ofstream&); //输出译码表文件
void Write_Encrypted(fstream&); //输出加密文件

/********************** 加密解码 **********************/
void Coding(HuffmanTree, string); //获取哈夫曼编码表。传入参数：构建好的哈夫曼树，用于存编码的字符串
void Encryption(); //对原始文件进行哈夫曼加密
void Decryption(HuffmanTree); //对加密文件解码。传入参数：哈夫曼树

//重置全局变量
void init() {
	FrequencyTable.clear(); CodeTable.clear();
	while (!Q.empty()) Q.pop();
	Source_s.clear(), ZeroOne_s.clear(), Decoding_s.clear();
	CodeTable_s.clear();
}
int main() {
	system("color 30"); //换个背景颜色
	while (true) {
		cout << "欢迎使用本系统进行文件加密压缩/解码还原!" << endl;
		cout << "请输入选项前的数字以继续操作：" << endl;
		cout << "\t1.文件加密" << endl;
		cout << "\t2.文件解码" << endl;
		cout << "\t3.文件比较" << endl;
		cout << "\t0.退出系统" << endl;
		int op; cin >> op;
		switch (op)
		{
			//文件加密
		case 1: system("cls"); Encryption_Menu();  break;
			//文件解码
		case 2: system("cls"); Decryption_Menu(); break;
			//文件比较
		case 3: system("cls"); Compare_Menu(); break;
			//退出系统
		case 0: cout << "退出系统成功！" << endl; return 0;
		default:
			cout << "输入选项有误，请检查后重新输入！" << endl;
			system("pause"); system("cls");
			break;
		}
	}
}

/********************** 菜单栏 **********************/
//加密选项菜单
void Encryption_Menu() {
	Open_File("原始", Read_Source); //打开原始文件
	cout << "打开原始文件成功，正在构造Huffman树..." << endl;
	HuffmanTree T = Build_Huffman(); //根据频率表构造哈夫曼树
	cout << "Huffman树构造成功，正在进行Huffman编码..." << endl;
	Coding(T, ""); //根据哈夫曼树获取哈夫曼编码
	cout << "编码成功，正在加密..." << endl;
	Encryption(); //对原始文件进行哈夫曼加密
	cout << "加密成功！" << endl;
	cout << "********************************************************************\n" << endl;
	Save_Encrypted(); //压缩并保存加密文件
	cout << "加密文件保存完成！\n" << endl;
	//Out_File("01", Write_ZeroOne); //输出01文件
	Out_File("译码表", Write_CodeTable); //输出译码表文件
	cout << "操作完成！请牢记您输入的加密文件地址以及译码表地址！" << endl;
	system("pause"); system("cls");
	init(); //重置全局变量
}
//解码选项菜单
void Decryption_Menu() {
	Load_Encrypted(); //加载并解压缩加密文件
	cout << "加密文件解压缩成功！\n" << endl;
	Open_File("译码表", Read_CodeTable);
	cout << "译码表加载完毕，正在重构Huffman树..." << endl;
	HuffmanTree T = Rebuild_Huffman(); //根据译码表重构哈夫曼树
	cout << "Huffman树重构完毕，正在对加密文件进行解码..." << endl;
	Decryption(T); //对加密文件进行解码
	cout << "解码成功！" << endl;
	cout << "********************************************************************\n" << endl;
	Out_File("解码", Write_Decoding); //输出解码文件
	cout << "操作完成！请牢记您输入的解码文件地址！" << endl;
	system("pause"); system("cls");
	init(); //重置全局变量
}
//比较文件菜单
void Compare_Menu() {
	Source_s.clear(); string file_name = Open_File("原始", Read_Source);
	size_t Source_size = Get_FileSize(file_name);
	cout << "\n------------------------------------------- 原始文件 -------------------------------------------\n" << endl;
	cout << Source_s;
	cout << "\n------------------------------------------- 原始文件 -------------------------------------------\n" << endl;
	Decoding_s.clear(); file_name = Open_File("解码", Read_Decoding);
	size_t Decoding_size = Get_FileSize(file_name);
	cout << "\n------------------------------------------- 解码文件 -------------------------------------------\n" << endl;
	cout << Decoding_s;
	cout << "\n------------------------------------------- 解码文件 -------------------------------------------\n" << endl;

	cout << "*********************************************************************************" << endl;
	cout << "\t原始文件大小：" << Source_size << " 字节" << endl;
	cout << "\t解码文件大小：" << Decoding_size << " 字节" << endl;
	if (Source_s == Decoding_s) cout << "\t经比对，原始文件与译码文件一致！" << endl;
	else cout << "\t经比对，原始文件与译码文件不一致！" << endl;
	cout << "*********************************************************************************\n" << endl;

	cout << "\t请输入存放" << "加密" << "文件的路径及文件名: " << endl;
	cout << "示例：" << "C:\\Users\\lgc2621690255\\source\\repos\\Project1\\Project1\\" << "加密" << "文件.Huffman" << endl;
	file_name; cin >> file_name; size_t Encryption_size = Get_FileSize(file_name);
	cout << "*********************************************************************************" << endl;
	cout << "\t原始文件大小：" << Source_size << " 字节" << endl;
	cout << "\t加密文件大小：" << Encryption_size << " 字节" << endl;
	cout << "\t压缩比为：" << (1.0 - (double)Encryption_size / (double)Source_size) * 100 << "%" << endl;
	cout << "*********************************************************************************\n" << endl;
	system("pause"); system("cls");
	init(); //重置全局变量
}
/********************** 菜单栏 **********************/


/********************** 文件操作 **********************/
//打开文件
string Open_File(string op, void(*read)(ifstream&)) {
	ifstream infile; //文件输入流
	cout << "\t请输入" << op << "文件的存放路径及文件名: " << endl;
	cout << "示例：" << "C:\\Users\\lgc2621690255\\source\\repos\\Project1\\Project1\\" << op << "文件.txt" << endl;
	string file_name; cin >> file_name;
	infile.open(file_name); //打开指定文件
	if (!infile.is_open()) { //如果打开文件失败
		cout << "文件 " << file_name << " 打开失败!" << endl;
		cout << "请检查: 1.文件是否存在 2. 路径是否正确 3.是否无权限访问该文件 / 文件夹" << endl;
		exit(-1); //终止程序，抛出异常值
	}
	read(infile); //从文件流读入字符
	infile.close(); //关闭文件流
	cout << endl; //纯属美观，无实际意义
	return file_name;
}
//输出文件，传入参数：加密/解码文件字符串，"加密"/"解码"
void Out_File(string op, void(*write)(ofstream&)) {
	ofstream outfile; //文件输出流
	cout << "\t请输入存放" << op << "文件的路径及文件名: " << endl;
	cout << "示例：" << "C:\\Users\\lgc2621690255\\source\\repos\\Project1\\Project1\\" << op << "文件.txt" << endl;
	string file_name; cin >> file_name;
	outfile.open(file_name); //打开指定文件
	if (!outfile.is_open()) { //如果打开文件失败
		cout << "文件 " << file_name << " 打开失败!" << endl;
		cout << "请检查: 1.文件是否已存在 2. 路径是否正确 3.是否无权限访问该文件 / 文件夹" << endl;
		exit(-1); //终止程序，抛出异常值
	}
	write(outfile);
	outfile.close(); //关闭文件流 
	cout << endl; //纯属美观，无实际意义
}
//保存加密文件
void Save_Encrypted() {
	fstream file; //文件输出流
	cout << "\t请输入存放" << "加密" << "文件的路径及文件名: " << endl;
	cout << "示例：" << "C:\\Users\\lgc2621690255\\source\\repos\\Project1\\Project1\\" << "加密" << "文件.Huffman" << endl;
	string file_name; cin >> file_name;
	file.open(file_name, ios::binary | ios::out); //打开指定文件
	if (!file) { //如果打开文件失败
		cout << "文件 " << file_name << " 打开失败!" << endl;
		cout << "请检查: 1.文件是否已存在 2. 路径是否正确 3.是否无权限访问该文件 / 文件夹" << endl;
		exit(-1); //终止程序，抛出异常值
	}
	Write_Encrypted(file);
	file.close(); file.clear();//关闭文件流 
}
//加载加密文件
void Load_Encrypted() {
	fstream file; //文件输入流
	cout << "\t请输入" << "加密" << "文件的存放路径及文件名: " << endl;
	cout << "示例：" << "C:\\Users\\lgc2621690255\\source\\repos\\Project1\\Project1\\" << "加密" << "文件.Huffman" << endl;
	string file_name; cin >> file_name;
	file.open(file_name, ifstream::in | ios::binary); //打开指定文件
	if (!file) { //如果打开文件失败
		cout << "文件 " << file_name << " 打开失败!" << endl;
		cout << "请检查: 1.文件是否存在 2. 路径是否正确 3.是否无权限访问该文件 / 文件夹" << endl;
		exit(-1); //终止程序，抛出异常值
	}
	Read_Encrypted(file);
	file.close(); file.clear();//关闭文件流
}
//获取文件大小
size_t Get_FileSize(const string& file_name) {
	ifstream in(file_name.c_str());
	in.seekg(0, ios::end);
	size_t size = in.tellg();
	in.close();
	return size; //单位是：byte
}

/********************** 文件操作 **********************/


/********************** Huffman树 **********************/
//构造哈夫曼树
HuffmanTree Build_Huffman() {
	HuffmanTree T; T = new node; //新建一颗哈夫曼树
	T->s = ""; T->weight = 0; T->Right = T->Left = NULL; //赋初值
	while (Q.size() > 1) { //当优先队列（森林）内元素数量 > 1
		T = new node; //新建一颗哈夫曼树
		T->Left = Q.top(), Q.pop(); //左子树为森林内权值最小的树
		T->Right = Q.top(), Q.pop(); //右子树为森林内权值次小的树
		T->weight = T->Left->weight + T->Right->weight; //当前结点的权值为左右子树权值之和
		Q.push(T); //将新构造的树重新插入优先队列中
	}
	T = Q.top(), Q.pop(); //森林内仅存的一颗哈夫曼树
	return T;
}
//重构Huffman树
HuffmanTree Rebuild_Huffman() {
	HuffmanTree T, _T; T = new node; //新建一颗哈夫曼树
	T->s = ""; T->weight = 0; T->Right = T->Left = NULL; //赋初值
	_T = T;
	for (auto it : CodeTable) {
		int size = it.first.size();
		T = _T;
		for (int i = 0; i < size; ++i) {
			HuffmanNode t; t = new node; //新建一颗哈夫曼树
			t->s = ""; t->weight = 0; t->Right = t->Left = NULL; //赋初值

			if (it.first[i] == '0') {
				if (T->Left == NULL) T->Left = t;
				T = T->Left;
			}
			else {
				if (T->Right == NULL) T->Right = t;
				T = T->Right;
			}

			if (i == size - 1) T->s = it.second;
		}
	}
	return _T;
}
/********************** Huffman树 **********************/


/********************** 读出写入子函数 **********************/
void Write_ZeroOne(ofstream& out) { out << ZeroOne_s; } //输出01文件
void Write_Decoding(ofstream& out) { out << Decoding_s; } //输出解码文件
 //输出译码表文件
void Write_CodeTable(ofstream& out) {
	CodeTable_s.clear(); for (auto it : CodeTable) CodeTable_s += it.first + " " + it.second + "\n";
	out << CodeTable_s;
}
//输出加密文件
void Write_Encrypted(fstream& file) {
	int size = ZeroOne_s.size();
	unsigned char last_bit = (unsigned char)(size % C_Bit + '0'); file.write((char*)&last_bit, sizeof(last_bit));
	for (int i = 0; i < size; i += C_Bit) {
		int res = 0;
		for (int j = 0; i + j < size && j < C_Bit; ++j) res = res * 2 + (ZeroOne_s[i + j] - '0');
		unsigned char ch = res;
		file.write((char*)&ch, sizeof(ch));
	}
}
//读入数据。传入参数：ifstream流
void Read_Source(ifstream& in) {
	char ch; string s;
	while (in.peek() != EOF) { //当文件流不到文件结尾时
		ch = in.get(); s = ch; //一个一个字符读入
		if (ch > 127 || ch < 0) { //处理非ASCII码的字符（中文字符）
			ch = in.get(); s = s + ch;
		}
		++FrequencyTable[s]; //字符 s 频率 + 1
		Source_s = Source_s + s; //原始文件字符串
	}
	//遍历字符频率表
	for (auto it : FrequencyTable) {
		HuffmanNode t = new node; //新建一个哈夫曼结点
		t->s = it.first; t->weight = it.second; t->Left = NULL; t->Right = NULL; //为其赋值
		Q.push(t); //加入到优先队列（堆）中
	}
}
//读入解码文件
void Read_Decoding(ifstream& in) {
	char ch; string s;
	while (in.peek() != EOF) { //当文件流不到文件结尾时
		ch = in.get(); s = ch; //一个一个字符读入
		if (ch > 127 || ch < 0) { //处理非ASCII码的字符（中文字符）
			ch = in.get(); s = s + ch;
		}
		Decoding_s = Decoding_s + s; //原始文件字符串
	}
}
//读入加密文件。传入参数：ifstream流
void Read_Encrypted(fstream& file) {
	unsigned char ch; int last_bit = -1;
	//依次读取二进制文件中的unsigned char值读入到变量i,并输出
	while (file.read((char*)&ch, sizeof(ch))) {
		if (last_bit == -1) { last_bit = ch - '0'; continue; }
		int t = ch;
		string s;
		for (int i = 0; i < C_Bit; ++i) {
			s = s + (char)((t & 1) + '0'); t >>= 1;
		}
		reverse(s.begin(), s.end());
		ZeroOne_s = ZeroOne_s + s;
	}
	if (last_bit != 0) {
		int size = ZeroOne_s.size();
		string t; for (int i = size - last_bit; i < size; ++i) t = t + ZeroOne_s[i];
		for (int i = 0; i < C_Bit; ++i) ZeroOne_s.pop_back();
		ZeroOne_s = ZeroOne_s + t;
	}
	//cout << ZeroOne_s << endl;
}
//读入译码表
void Read_CodeTable(ifstream& in) {
	char ch; string s;
	while (in.peek() != EOF) { //当文件流不到文件结尾时
		ch = in.get(); s = ch; //一个一个字符读入
		if (ch > 127 || ch < 0) { //处理非ASCII码的字符（中文字符）
			ch = in.get(); s = s + ch;
		}
		string coding; in >> coding; in.get();
		CodeTable[coding] = s;
	}
	//for (auto it : CodeTable) cout << it.first << " " << it.second << endl;
}
/********************** 读出写入子函数 **********************/


/********************** 加密解码 **********************/
//获取哈夫曼编码表。传入参数：构建好的哈夫曼树，用于存编码的字符串
void Coding(HuffmanTree T, string s) {
	if (T->Left == NULL && T->Right == NULL) { //当走到了叶子结点
		CodeTable[T->s] = s; //存储该结点内字符的01编码
		return;
	}
	Coding(T->Left, s = s + "0"); //左边走，编码 + 0
	s.pop_back(); //回溯时 编码长度 - 1
	Coding(T->Right, s = s + "1"); //右边走 编码 + 1
	s.pop_back(); //回溯时 编码长度 - 1
}
//对原始文件加密
void Encryption() {
	int size = Source_s.size(); string s; //获取原始文件的长度
	for (int i = 0; i < size; ++i) {
		s = Source_s[i]; //逐个处理字符

		if (Source_s[i] > 127 || Source_s[i] < 0) { //处理非ASCII码的字符（中文字符）
			++i; s = s + Source_s[i];
		}
		ZeroOne_s = ZeroOne_s + CodeTable[s]; //将编码表中 字符对应的 01编码 存入加密字符串
	}
}
//对加密文件解码。传入参数：加密用的哈夫曼树
void Decryption(HuffmanNode T) {
	int i = 0, size = ZeroOne_s.size(); //获取加密文件的长度
	HuffmanNode _T = T; //存储哈夫曼树的根结点
	while (i < size) {
		int cnt = 0; T = _T; //重置变量
		while (T->Left != NULL && T->Right != NULL) { //当没走到叶子结点时
			if (ZeroOne_s[i + cnt] == '0') T = T->Left; //是 0 则向左子树走
			else if (ZeroOne_s[i + cnt] == '1') T = T->Right; //是 1 则向左子树走
			++cnt; //本次编码的长度 + 1
		}
		Decoding_s = Decoding_s + T->s; //结果存入解码字符串中
		i += cnt; //已走长度i 加上 本次编码的长度 cnt
	}
}
/********************** 加密解码 **********************/
好昵称都被猪取了额
关注
  • 5
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构实验（哈夫曼编码实验进行压缩文件和解压文件）
dogs的博客
05-11 1657
实验二 目的要求： 掌握赫夫曼树和赫夫曼编码的基本思想和算法的程序实现。 实验内容： 实现文件中数据的加解密与压缩：将硬盘上的一个文本文件进行加密，比较加密文件和原始文件的大小差别；对加密文件进行解密，比较原始文件和解码文件的内容是否一致。 实验说明： 1．输入和输出： （1）输入：硬盘上给定的原始文件及文件路径。 （2）输出：  硬盘上的加密文件及文件路径；  硬盘上的解码文件及文件路径；  原始文件和解码文件的比对结果。 2．实验要求：  提取原始文件中的数据（包括中文、英文或其他字符），根据
数据结构哈夫曼编码实验报告.doc
07-11
数据结构实验报告 ―― 实验五 简单哈夫曼编/译码的设计与实现 本实验的目的是通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结构在 实际问题中的应用。此实验可以作为综合实验，阶段性实验时可以选择其中的几个功能 来设计和实现。 一、【问题描述】 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本 。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数 据进行译码，此实验即设计这样的一个简单编/码系统。系统应该具有如下的几个功能： 1、接收原始数据。 从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件nod edata.dat中。 2、编码。 利用已建好的哈夫曼树（如不在内存，则从文件nodedata.dat中读入），对文件中的正 文进行编码，然后将结果存入文件code.dat中。 3、译码。利用已建好的哈夫曼树将文件code.dat中的代码进行译码，结果存入文件tex tfile.dat中。 4、打印编码规则。 即字符与编码的一一对应关系。 二、【数据结构设计】 1、构造哈夫曼树时使用静态链表作为哈夫曼树的
zip压缩包解密方法有哪些？如果忘了了密码？要怎么解密
最新发布
pf_data的博客
05-15 2537
为了方便储存或者传输文件，我们经常会把文件转换成ZIP压缩文件，想保密性好的话，还会给他添加打开密码。那如果后续不需要打开密码了，或者一个不小心忘记了密码，该怎么清除密码呢？
哈夫曼编码c++ 代码
10-04
数据结构课程设计哈夫曼的代码，vs2010 以上的直接打开可以运行； 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。
[源码和文档分享]基于c++的哈夫曼编码
qq_38474647的博客
06-19 229
c++实现哈夫曼编码，本例中采取了相对简单易懂的构建方式，与其他相类似的代码相比，更为直观和简练。 C++实现的哈夫曼编码与解码: 统计某电文中字符出现的频率（假设电文中只含有大小写英文字母） 把字符出现的频率作为权值建立哈夫曼树，进行哈夫曼编码，并输出每个字符的编码结果 对电文进行哈夫曼编码 把电文的哈夫曼...
Huffman编码压缩和解压文档，C++实现
areen7003的博客
08-24 1098
注：本演示代码采用自上而下得到huffman编码（二叉树） 关于huffman树及相关算法这里就略过，这里探讨的是如何进行编码和解压缩。先说一下大致步骤 1.首先，读取文档（txt格式），将其存入string类型的变量pretext里 2.进行词频统计 3.创建Huffman树，并以此得到各字符的二进制编码 4.对pretext进行遍历，通过上...
基于huffman编码的文件解压缩程序(c语言，源码）
11-14
基于huffman编码的文件解压缩程序 采用c语言编写，支持文件的解压缩功能 供学习交流，大型文件请不要尝试，可能会很慢
文件加密基于赫夫曼编码的简单程序
09-28
利用赫夫曼编码对字符文件进行加密，可以对txt字符文件进行加密，由于满足课程设计，所以加密功能简单，但是赫夫曼为核心代码，是单独函数分开的，用于学习赫夫曼算法是简单的，并附有解释。
huffman的加密和解码
01-10
文件`huffman`可能包含了实现这些功能的代码，包括字符频率统计、哈弗曼树构建、编码和解码的函数等。通过阅读和理解这段代码，你可以更深入地了解哈弗曼编码的工作原理及其在实际应用中的实现细节。 总结来说，...
VS2010下基于Qt4.8.2开发的huffman树文件内容加密解密程序
06-19
5. 解码过程：读取压缩文件，根据Huffman编码表恢复原始字符。 至于加密部分，可能使用了某种对称加密算法，如AES（高级加密标准）或者DES（数据加密标准）。在文件内容被Huffman编码后，这些加密算法可以进一步...
数据结构实验实验报告Huffman赫夫曼编码及应用.pdf
11-12
本实验报告详细介绍了如何运用Huffman编码对文本进行加密、解密，并通过C++语言在Visual Studio 2015平台上实现。 实验的目标是掌握Huffman树及其编码的基本概念和实现过程。实验内容分为以下几个步骤： 1. 数据...
用C++语言实现哈夫曼编码
01-11
在做实验的时候如何用C++实现哈夫曼编码了？
C++ 哈夫曼树对文件压缩、加密实现代码
08-29
主要介绍了C++ 哈夫曼树对文件压缩、加密实现代码,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c++实现的哈夫曼编码和解码（源代码）
10-23
网上很多哈夫曼源代码要不是复制，要不是对文件操作，无法对内存缓冲区使用。自己写了一个c++类封装的，接口简洁，方便使用，提供对缓冲区内存的编码和解码，测试可行。但编码和解码时间较长，以后改进。
压缩软件huffman编码
11-03
压缩软件 设有一个文本文件A（可以使C源程序），统计该文件中各字符频率，对各字符进行Huffman编码， 将该文件翻译成Huffman编码文件B，再将Huffman编码文件翻译成文件C，并对文件A与C进行比较
哈夫曼编码系统（对英文加密）
12-05
这是数据结构中对哈夫曼（最优二叉树）的运用，适合计算机软件专业大二学生学习最优树的数据结构，C/C++哈夫曼编码系统，仅供参考。
数据结构实验实验报告Huffman赫夫曼编码及应用.docx
11-12
Huffman编码是一种高效的数据压缩算法，主要用于无损数据压缩，其核心思想是通过构建最优二叉树（也称为赫夫曼树）来实现字符的编码。这个实验报告详细介绍了如何运用赫夫曼编码对文件进行加密和解密。 实验的主要...
c++版的字符串加解密程序，huffman算法
08-29
在本程序中，Huffman编码，一个源于信息论的数据压缩算法，被巧妙地应用到了字符串的加密与解密过程中。下面我们将深入探讨这两个核心概念。 首先，我们来理解C++中的字符串处理。在C++中，字符串是以字符数组的...
C++ Huffman编码压缩解压
OrdinaryCrazy的博客
11-08 1430
压缩：统计词频--->建立Huffman树--->保存词频--->逐个字节转换为编码写入 解压：读取词频--->建立Huffman树---->读取编码重走Huffman树返回对应字符 #include #include #include #include #include #include #include #define OK 1 using namespace std; us
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值