【算法】贪心算法-哈夫曼压缩算法-无密/加密压缩、解压缩

最新推荐文章于 2024-07-24 14:54:00 发布
最新推荐文章于 2024-07-24 14:54:00 发布
阅读量188 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43919414/article/details/106372669
版权
本文介绍了哈夫曼编码在文件压缩中的应用，通过在Visual C++6.0环境下实现，详细阐述了压缩和解压缩的步骤。压缩过程中包括统计字符频度、构建哈夫曼树和生成哈夫曼编码；解压缩则依赖于元数据重建哈夫曼树，按照编码读取信息。
摘要由CSDN通过智能技术生成

目录

开发环境：

Visual C++6.0

代码：

#include <iostream>
#include <windows.h>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
typedef struct
{
	int  weight;
	int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef struct
{
	char* data;
	int* num;
	int length;
}TNode;
typedef struct
{
	char *data;
	char** HM;
}Code;
typedef char** HuffmanCode;
bool IfEncode()
{
	int choose;	
	cout<<"\t            1.加密压缩     2.无密压缩"<<endl;
	cout<<"请输入选择："; 
	cin>>choose;
	if(choose==1)
		return true;
	else
		return false;
}
void Encode(vector<char>& v)
{
	char ch[30];
	v.push_back('@');
	cout<<"请输入压缩密码"<<endl; 
	cin>>ch;
	for(int i=0;ch[i]!='\0';i++)
		v.push_back(ch[i]);
	v.push_back('\0');
	v.push_back('@');
	cout<<"开始压缩…"<<endl; 
}
void ReadTxt(vector<char>& v)
{
	char ch;
	ifstream infile("vae.txt",ios::in);//读取需要压缩的文件vae.txt
	if(!infile)
	{
		cerr<<"open error"<<endl;
		exit(1);
	}
	if(IfEncode())
		Encode(v);
	while(infile.peek()!=EOF)
	{
		infile.get(ch);
		v.push_back(ch); 
	}	
	infile.close();	
}
void InitList(TNode& T)
{
	T.data=new char[256];
	T.num=new int[256];
	if(!T.data||!T.num)
		exit(1);
	T.length=0;
}
bool Find(TNode T,char ch)
{
	int i;
	for(i=0;i<T.length;i++)
		if(ch==T.data[i])
			return true;
	return false;
}
void TCount(vector<char> v1,TNode &T)
{
	int i,j=0;
	char ch;
	int m=v1.size();
	for(i=0;i<m;i++)
	{
		ch=v1[i];
		if(!Find(T,ch))
		{
			T.data[j]=ch;
			T.num[j]=count(v1.begin(),v1.end(),ch);
			j++;
			T.length++;
		}		
	}		
}
void Select(HuffmanTree &HT,int m,int& s1,int& s2)
{
	int k,j,n,min=32767;
	for(k=1;k<=m;k++)s
			if(HT[k].weight<=min)
			{
				j=k;
				min=HT[k].weight;
			}			
	}
	s1=j;
	HT[j].parent=1;
	min=32767;
	for(k=1;k<=m;k++)
	{
		if(HT[k].parent==0)
			if(HT[k].weight<=min)
			{
				n=k;
				min=HT[k].weight;
			}			
	}
	s2=n;
}
void CreateHuffmanTree (HuffmanTree &HT,TNode T,int length)
{
	int m,i,s1,s2;
	if(length<=1)
		return;
	m=2*length-1;
	HT=new HTNode[m+1];
	for(i=1;i<=m;++i)
	{
		HT[i].parent=0;
		HT[i].lchild=0;
		HT[i].rchild=0;
	}
	for(i=1;i<=length;++i)
		HT[i].weight=T.num[i-1];	
	for(i=length+1;i<=m;i++)
	{
		Select(HT,i-1,s1,s2);
		HT[s1].parent=i;
		HT[s2].parent=i;
		HT[i].lchild=s1;
		HT[i].rchild=s2;
		HT[i].weight=HT[s1].weight+HT[s2].weight;
	}	
}
void CreatHuffmanCode (HuffmanTree HT,HuffmanCode &HC,int n)
{
	int i,f,c,start;
	HC=new char*[n+1];
	char* cd=new char[n];
	cd[n-1]='\0';
	for(i=1;i<=n;i++)
	{
		start=n-1;
		c=i;
		f=HT[i].parent;
		while(f!=0)
		{
			--start;
			if(HT[f].lchild==c)
				cd[start]='0';
			else
				cd[start]='1';
			c=f;
			f=HT[f].parent;
		}
		HC[i]=new char[n-start];
		strcpy(HC[i],&cd[start]);
	}	
	delete cd;
}

void Zip(HuffmanCode HC,vector<char> v,TNode T)
{
	int i=0,j=0,k=0;
	ofstream outfile("com.zip",ios::out);//输出压缩后的文件com.zip
	if(!outfile)
	{
		cerr<<"open error"<<endl;
		exit(1);
	}
	for(i=0;i<v.size();i++)
	{
		for(j=0;j<T.length;j++)
			if(T.data[j]==v[i])
				break;
		for(k=0;HC[j+1][k]!='\0';k++)
			outfile<<HC[j+1][k];			
	}
	outfile.close();
	cout<<"正在压缩…";Sleep(500);cout<<" 。";Sleep(500);cout<<" 。"<<endl;
	cout<<"压缩成功，可到com.zip中查看压缩后文件"<<endl; 
} 
bool REncode(char ch[])
{
	int i=0;
	char code[30];
	cout<<"请输入解压密码:"<<endl;
	cin>>code;
	if(strcmp(code,ch)==0)
		return true;
	else
		return false;
}
int in_HM(Code &c)
{
	c.data=new char[256];
	c.HM=new char* [256];
	int length=0,i;
	ifstream infile("code.dat",ios::in);
	if(!infile)
	{
		cerr<<"open error"<<endl;
		exit(1);
	}
	infile>>length;
	for(i=0;i<length;i++)
	{
		infile>>c.data[i];
		c.HM[i]=new char[length+1];
		infile>>c.HM[i];
	}
	infile.close(); 
	return length;	
}
void out_HM(HuffmanCode HC,TNode T)
{
	int i;	
	ofstream outfile("code.dat",ios::out);
	if(!outfile)
	{
		cerr<<"open error"<<endl;
		exit(1);
	}
	outfile<<T.length<<endl;
	for(i=0;i<T.length;i++)
	{
		outfile<<T.data[i]<<endl;
		outfile<<HC[i+1]<<endl;
	}
	outfile.close();
}
void RZip(HuffmanCode HC,TNode T)
{
	char ch;
	char ch2[30];
	int i,j,flag,flag2=0,m=0;
	ofstream outfile("rzip.txt",ios::out);//将压缩好的文件重新解压为rzip.txt
	ifstream infile("com.zip",ios::in);
	if(!outfile)
	{
		cerr<<"open error"<<endl;
		exit(1);
	}
	if(!infile)
	{
		cerr<<"open error"<<endl;
		exit(1);
	}
	while(infile.peek()!=EOF)
	{	
		flag=0;
		char* cd=new char[T.length];
		for(i=0;;i++)
		{
			infile>>ch;
			cd[i]=ch;
			cd[i+1]='\0';
			for(j=1;j<=T.length;j++)
				if(strcmp(HC[j],cd)==0)
				{
					if(T.data[j-1]=='@')
					{	
						if(flag2==0)
						{
							flag=1;
							flag2=1;
							delete cd;
							break;
						}
						if(flag2==1)
						{
							while(1)
							{
								if(REncode(ch2))
								{
									cout<<"密码正确，正在解压… "<<endl;
									flag2=0;
									break;
								}						
								else
									cout<<"密码错误，请重新输入"<<endl; 
							} 
							flag=1;
							delete cd;
							break;
						}	
					}
					if(flag2==1)
					{
						ch2[m]=T.data[j-1];
						flag=1;
						m++;
						delete cd;
						break;	
					}
					if(flag2==0)
					{
						outfile<<T.data[j-1];
						flag=1;
						delete cd;
						break;
					}
				}
			if(flag==1)
				break;
		}
	}
	cout<<"正在解压…";Sleep(500);cout<<" 。";Sleep(500);cout<<" 。"<<endl;
	cout<<"解压成功!请到rzip.txt中查看解压后文件" <<endl; 
}
void RZip()
{
	char ch;
	char ch2[30];
	Code c;
	int i,j,length,flag,flag2=0,m=0;
	length=in_HM(c);
	ofstream outfile("rzip.txt",ios::out);
	ifstream infile("com.zip",ios::in);
	if(!outfile)
	{
		cerr<<"open error"<<endl;
		exit(1);
	}
	if(!infile)
	{
		cerr<<"open error"<<endl;
		exit(1);
	}
	while(infile.peek()!=EOF)
	{	
		flag=0;
		char* cd=new char[length];
		for(i=0;;i++)
		{
			
			infile>>ch;
			cd[i]=ch;
			cd[i+1]='\0';
			for(j=0;j<length;j++)
				if(strcmp(c.HM[j],cd)==0)
				{
					if(c.data[j]=='@')
					{	
						if(flag2==0)
						{
							flag=1;
							flag2=1;
							delete cd;
							break;
						}
						if(flag2==1)
						{
							while(1)
							{
								if(REncode(ch2))
								{
									cout<<"密码正确，正在解压… "<<endl;
									flag2=0;
									break;
								}						
								else
									cout<<"密码错误，请重新输入"<<endl; 
							} 
							flag=1;
							delete cd;
							break;
						}	
					}
					if(flag2==1)
					{
						ch2[m]=c.data[j];
						flag=1;
						m++;
						delete cd;
						break;	
					}
					if(flag2==0)
					{
						outfile<<c.data[j];
						flag=1;
						delete cd;
						break;
					}
				}
			if(flag==1)
				break;
		}
	}
	cout<<"正在解压…";Sleep(500);cout<<" 。";Sleep(500);cout<<" 。"<<endl;	
	cout<<"解压成功，请到rzip.txt中查看解压后的文件" <<endl; 
}
void about()
{
	system("cls");
	cout<<"\t╔═══════════════════════════════╗"<<endl;
	cout<<"\t║                    欢迎使用解压缩程序   ^-^                  ║"<<endl;
	cout<<"\t║  关于程序：                                                  ║"<<endl;
	cout<<"\t║      压缩：                                                  ║"<<endl;	
	cout<<"\t║       默认压缩程序所在目录下的vae.txt，生成压缩后的com.zip   ║"<<endl;
	cout<<"\t║                                                              ║"<<endl;
	cout<<"\t║      解压：                                                  ║"<<endl;
	cout<<"\t║       默认解压序所在目录下的com.zip，生成解压后的rzip.txt    ║"<<endl;
	cout<<"\t║                                                              ║"<<endl;	
	cout<<"\t║      无源文件解压：                                          ║"<<endl;
	cout<<"\t║        使用仅以压缩文件解压，无需源文件，仅支持无空格无回车  ║"<<endl;
	cout<<"\t║        的文本解压！                                          ║"<<endl;
	cout<<"\t║                                                              ║"<<endl;
	cout<<"\t║      程序支持压缩中英文文件。                                ║"<<endl;
	cout<<"\t║                                                              ║"<<endl;
	cout<<"\t╚═══════════════════════════════╝"<<endl;
}
void menu()
{
	cout<<"\t╔═══════════════════════════════╗"<<endl;
	cout<<"\t║                                                              ║"<<endl;
	cout<<"\t║                  欢迎使用解压缩程序                          ║"<<endl;
	cout<<"\t║                                                              ║"<<endl;
	cout<<"\t║                     1. 压缩文件                              ║"<<endl;
	cout<<"\t║                     2. 解压文件                              ║"<<endl;
	cout<<"\t║                     3. 无源文件解压                          ║"<<endl;	
	cout<<"\t║                     4. 关于程序                              ║"<<endl;
	cout<<"\t║                     5. 退出程序                              ║"<<endl;
	cout<<"\t║                                                              ║"<<endl;
	cout<<"\t╚═══════════════════════════════╝"<<endl;
} 
int main(){
	vector<char> v;
	int n,choose;
	TNode T;
	InitList(T);
	HuffmanTree HT;	
	HuffmanCode HC;	
	while(1)
	{
		system("cls"); 
		menu();
		cout<<"请输入所选择的序号:";
		cin>>choose;
		switch(choose)
		{
			case 1:
				ReadTxt(v);
				TCount(v,T);
				n=T.length;
				CreateHuffmanTree (HT,T,n);
				CreatHuffmanCode (HT,HC,n);
				Zip(HC,v,T);
				out_HM(HC,T);
				system("pause");
				break;
			case 2:
				RZip(HC,T);
				system("pause");
				break;
			case 3:
				RZip();
				system("pause");
				break;
			case 4:
				about();
				system("pause");
				break; 
			case 5:
				return 0;
			default:
				cout<<"输入错误，请重新输入";
				system("pause");
				break; 		
		}
	}
	return 0;
 }

实验步骤：

运行选项4进入使用说明

原理：

哈夫曼编码的思想对文件进行压缩，主要原理是通过哈夫曼编码来重新表示字符，使得出现频率高的字符编码短，出现少的字符编码长。

压缩过程：

1）统计字符种类及频度：ASCII码值当下标，字符频度当对应下标的值。
2）构建哈夫曼树：在没有访问过的节点中，找最小字符频度下标来构建哈夫曼树。
3）构建哈夫曼编码：递归思想构建。
4)生成压缩文件（.ycyHuf后缀名）：把字符的哈夫曼编码以二进制形式写入目标文件中。给压缩文件头部写入元数据，解压缩时需使用这些数据。

解压过程：

1）根据压缩文件的头部元数据，得到字符种类和频度。
2）构建哈夫曼树：在没有访问过的节点中，找最小字符频度下标来构建哈夫曼树。
3）构建哈夫曼编码：递归思想构建。
4）生成解压缩的文件（后缀名和源文件后缀名一样 ）即可：一位一位的从压缩文件中读取信息，'1’向左子树走，'0’向右子树走。

LimCC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用Haffman 算法实现对ascii字符文件的压缩
01-24 4614
利用Haffman 算法实现对ascii字符文件的压缩     EmilMatthew(EmilMatthew@126.com)摘要:  本文是对Haffman算法进行的一次实践。根据ascii码文件中各ascii字符出现的频率情况创建Haffman树，再将各字符对应的哈夫曼编码写入文件中。同时，亦可根据对应的哈夫曼树，将哈夫曼编码文件解压成字符文件. 关键词: Haffman
【贪心法】最优前缀码（Huffman哈夫曼算法）
weixin_52075165的博客
11-25 6169
在计算机中需要用0-1字符串作为代码来表示信息，为了正确解码，必须要求任何字符的代码不能作为其他字符代码的前缀，这样的码称为二元前缀码的存储通常采用二叉树结构，令每个字符作为树叶，对应这个字符的前缀码看作根到这片树叶的一条路径，规定每个结点通向左儿子的边记作0，通向右儿子的边记作1。不同学符在信息中出现的频率不同．设 C ={x1,x2,...,xn}是 n 个字符的集合，xi的频率是 f(xi), i =1,2,..., n ，那么存储一个字符所使用的二进制位数的平均值是：其中是表示字符。
哈夫曼树算法文件全加密解密
07-01
文本文件的加密和解密。某公司有一份机密文件，是由英文字母（大小写）、英文逗号、英文句点、空格和回车等符号组成的文件名为Jimi.txt的文本文件。公司为了保证文件不被泄密，要求技术人员将文件中的每个字符都用一个二进制位串进行加密，需要时能进行解密，但必须保证加密后的文件不能过大，且对加密的文件进行解密后与原文件必须完全一致。菜单包括： 1. 显示原文本文件 2.文本文件加密 3.显示字符编码 4.显示加密文件 5.文本文件解密 6.显示解密文件 7.退出系统
哈夫曼编码的贪心算法
04-23
哈夫曼编码的C#实现 字母表：a,b,c,d,e,f 关键字序列：45,13,12,16,9,5 以上是测试数据
C语言实现的基于Huffman哈夫曼编码的数据压缩与解压缩.7z
06-08
根据ASCII码文件中各ASCII字符出现的频率情况创建Haffman树，再将各字符对应的哈夫曼编码写入文件中，实现文件压缩。
greedy_哈夫曼编码_活动安排_背包问题_python_贪心算法_
10-03
本项目通过Python编程语言实现了贪心算法，应用于哈夫曼编码、活动安排、背包问题等经典场景，展示了贪心策略在解决实际问题中的应用。 哈夫曼编码是一种高效的前缀编码方法，用于无损数据压缩。其基本思想是：将...
0023算法笔记——【贪心算法】哈夫曼编码问题--16页.pdf
09-05
"哈夫曼编码和贪心算法" 哈夫曼编码是一种广泛用于数据文件压缩的编码方法，其压缩率通常在20%～90%之间。...哈夫曼编码是一种广泛用于数据文件压缩的编码方法，使用变长编码和贪心算法实现高效的数据压缩。
哈夫曼压缩与解压算法(可以直接运行）
06-13
然后，通过构建哈夫曼树，将频率作为权重，使用贪心算法生成一棵带权路径长度最短的二叉树。这棵树的每个叶子节点都代表一个字符，而从根节点到叶子节点的路径表示该字符的哈夫曼编码。在实际操作中，这个过程可以...
哈夫曼编码（贪心算法）课堂分享.pptx
11-20
哈夫曼编码是一种高效的数据编码方法...总结来说，哈夫曼编码是贪心算法在数据压缩领域的成功应用，通过构建优化的二叉树结构，实现了根据字符出现频率的动态编码，有效地减少了存储需求，提高了数据传输和存储的效率。
用哈夫曼树算法写对文件压缩与解压缩代码.doc
05-12
- 使用贪心算法，每次从优先队列中取出两个频率最小的节点合并成一个新的节点，新节点的频率等于两个子节点的频率之和，并将新节点放回队列。重复此过程，直到队列中只剩下一个节点，这个节点就是哈夫曼树的根节点...
用Hufffman编码实现文件压缩实验报告
11-18
用Hufffman编码实现文件压缩实验报告 根据ascii码文件中各ascii字符出现的频率情况创建Haffman树，再将各字符对应的Hufffman编码写入文件中，实现文件压缩。
北京工业大学--算法作业3--huffman编码对文本文件进行压缩与解压---Java
12-12
北京工业大学--算法作业3--huffman编码对文本文件进行压缩与解压---Java代码 设计并实现贪心算法，利用huffman编码对文本文件进行压缩与解压。 输入：一个文本文件 输出：压缩后的文件 算法过程： （1）统计文本文件中每个字符的使用频度 （2）构造huffman编码 （3）以二进制流形式压缩文件
贪心算法_哈夫曼编码问题(Huffman Coding)
It's just a matter of time.
11-26 9237
哈夫曼编码问题，可以用贪心算法来解还是比较爽的啊(上一篇博客我在想贪心算法能解的问题不多)。下面来详细讨论一下哈夫曼编码问题。 问题描述:现有一个文本文件，其中包含的字符数据出现的次数各不相同，先要求对该文本中包含的字符进行编码，使文本占用的位数更小。 问题分析：我们知道文件的存储都是以二进制数表示的，如：字符c可以表示为010101之类的。因为不同的操作系统对于不同的数据类型会分配给相同的数
Huffman算法实现文件加密
伍毛毛的博客
01-10 911
使用Huffman算法来加密文件 这次的blog只是为了记录一下本人第一次自己编写的算法 参考的博客和文章忘了出处，如有相似的，请联系博主 此次程序主要使用C++来编写，其中由于特殊原因混有一些C语言，博主会逐渐逐渐完善代码 程序的功能是在rawletter.txt中读取出现的字符以及其权重（权重可以理解成出现的概率），然后通过使用Huffman算法来形成每个字符对应的Huffman编码，按照原来...
贪心法求解哈夫曼编码问题
LixDemon的博客
03-22 6080
问题描述 设要编码的字符集为{d1， d2， …， dn}，它们出现的频率为{w1， w2， …， wn}，应用哈夫曼树构造最优的不等长的由0、1构成的编码方案。 问题求解 先构建以这个n个结点为叶子结点的哈夫曼树，然后由哈夫曼树产生各叶子结点对应字符的哈夫曼编码。 哈夫曼树（Huffman Tree）的定义：设二叉树具有n个带权值的叶子结点，从根结点到每个叶子结点都有一个路径长度。从根结点到各个...
算法导论--贪心算法--赫夫曼编码
流年
01-30 247
算法导论上构建赫夫曼编码的时候，说是用的最小堆，其实是每次都取出来一个最小值，而不是一次性取2个值。这点第一次的时候理解疏忽了。 其实用快排（nlogn）构建一个概率从小到大的结构也行！不过最小堆的操作时间复杂度肯定要小很多（logn） “ public class huffuman { public static void main(String[] args) { ...
贪心算法 之 哈夫曼编码
zuo_h_dr的博客
10-28 9671
贪心算法 之 哈夫曼编码 1.最优二叉树：（哈夫曼树） 1&gt;结点的权：赋予叶子结点以个有意义的值； 2&gt;结点的路径长度：从根结点到当前结点的的长度 结点的带权路径长度：W*L （W:权 L:路径长度） 3&gt;二叉树的带权路径长度：一颗二叉树的所有叶子结点的带权路径长度之和 4&gt;最优二叉树：一颗二叉树的带权路径最小，就是最优二叉树 2.哈夫曼树的特点：...
基于Huffman哈夫曼编码的文件压缩与解压缩
qq_38474871的博客
07-19 1505
一、实验题目用哈夫曼编码实现文件压缩二、实验目的了解文件的概念掌握线性链表的插入、删除等算法掌握Huffman树的概念及构造方法掌握二叉树的存储结构及遍历算法利用Huffman树及Huffman编码，掌握实现文件压缩的一般原理三、实验设备与环境微型计算机Windows 系列操作系统Visual C++6.0软件四、实验内容根据ascii码文件中各ascii...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
最新发布
weixin_65180740的博客
07-24 825
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
贪心算法详解：哈夫曼编码压缩原理与优化
"这篇文档是关于贪心算法在解决哈夫曼编码问题上的应用，主要讲述了哈夫曼编码的原理、特点以及如何构建最优的哈夫曼树进行编码。" 哈夫曼编码是一种高效的无损数据压缩方法，尤其适用于字符频率分布不均匀的数据。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值