赫夫曼编码及应用

赫夫曼编码及应用

一，目的

实现文件中数据的加解密与压缩。

二，描述

将硬盘上的一个文本文件进行加密，比较加密文件和原始文件的大小差别；对加密文件进行解密，比较原始文件和

解码文件的内容是否一致。

输入和输出：

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

（2）输出：硬盘上的加密文件及文件路径；

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

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

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

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

保存点硬盘上；比对原始文件和解码文件的一致性，得出是否一致的结论。

三，测试过程

1、方案

（一） 测试文件：

（二）文件路径：

F:\\Dataclass\\test.txt（注意文件路径用两个反斜杠）

（三）结果

压缩文件展示：

四，部分源码

1. 主要数据类型与变量

   typedef struct
   {//哈夫曼树存储结构 
       unsigned int weight;
       unsigned int parent, lchild, rchild;
   }HTNode, *HuffmanTree;
   
   typedef struct
   {//存储数据扫描统计结果 
   	char* data;
   	int* num;
   	int length;
   }TNode;
   
   //存储哈夫曼编码结果 
   typedef char * * HuffmanCode;
   

2. 函数模块

   void ReadTxt(vector<char> &v)
   {//读取文件
   	char path[50];
   	char ch;
   	cout<<"请输入加密文件路径：" <<endl;
   	cin>>path; 
   	
   	ifstream infile(path,ios::in);
   	if(!infile)
   	{
   		cerr<<"open error"<<endl;
   		exit(1);
   	}
   	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;
   }
   
   int 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 n, int &s1, int &s2){
   	//选取最小的两个权值 s1,s2 
   	s1 = s2 =0;
   	for(int i = 1; i <= n; i++){
   		if(HT[i].parent == 0){
   			if(s1 == 0){
   				s1 = i;
   			}
   			else if(s2 == 0){
   				s2 = i;
   			}
   			else if(HT[i].weight < HT[s1].weight || HT[i].weight < HT[s2].weight){
   				s1 = HT[s1].weight < HT[s2].weight ? s1 : s2;
   				s2 = i;
   			}
   		}
   	}
   }
   
   void HuffmanCoding(HuffmanTree &HT, HuffmanCode &HC, TNode T) {
     // 构造哈夫曼树HT，
     // 并求出n个字符的哈夫曼编码HC
     int i, j, m, s1, s2, start;
     int n = T.length;
     char *cd;
     unsigned int c, f;
   
     if (n<=1) return;
     m = 2 * n - 1;
     HT = (HuffmanTree)malloc((m+1) * sizeof(HTNode));  // 0号单元未用
     for (i=1; i<=n; i++) { //初始化
       HT[i].weight=T.num[i-1];
       HT[i].parent=0;
       HT[i].lchild=0;
       HT[i].rchild=0;
     }
     for (i=n+1; i<=m; i++) { //初始化
       HT[i].weight=0;
       HT[i].parent=0;
       HT[i].lchild=0;
       HT[i].rchild=0;
     }
     for (i=n+1; i<=m; i++) { // 建哈夫曼树
       // 在HT[1..i-1]中选择parent为0且weight最小的两个结点，
       // 其序号分别为s1和s2。
       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;
     }
   
     //--- 从叶子到根逆向求每个字符的哈夫曼编码 ---
     HC = (HuffmanCode)malloc((n + 1)*sizeof(char *));
     cd = (char *)malloc(n*sizeof(char));    // 分配求编码的工作空间
     cd[n-1] = '\0';                         // 编码结束符。
     for (i=1; i<=n; ++i) {                  // 逐个字符求哈夫曼编码
       start = n-1;                          // 编码结束符位置
       for (c=i, f=HT[i].parent; f!=0; c=f, f=HT[f].parent) 
         // 从叶子到根逆向求编码
         if (HT[f].lchild==c) cd[--start] = '0';
         else cd[--start] = '1';
       HC[i] = (char *)malloc((n-start)*sizeof(char)); 
            // 为第i个字符编码分配空间
       strcpy(HC[i], &cd[start]);    // 从cd复制编码(串)到HC
     }
     free(cd);   // 释放工作空间
   } // HuffmanCoding
   
   
   void Zip(HuffmanCode HC,vector<char> v,TNode T)
   {
   	int i=0,j=0,k=0;
   	ofstream outfile("F:\\Dataclass\\zip.txt",ios::out);
   	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<<"压缩成功！可到F:\\Dataclass\\zip.txt中查看压缩后文件"<<endl; 
   } 
   
   
   void RZip(HuffmanCode HC,TNode T)
   {
   	char ch;
   	char ch2[30];
   	int i,j,flag,flag2=0,m=0;
   	ofstream outfile("F:\\Dataclass\\rzip.txt",ios::out);
   	ifstream infile("F:\\Dataclass\\zip.txt",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(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<<"解压成功!请到F:\\Dataclass\\rzip.txt中查看解压后文件" <<endl; 
   }
   

   主函数

     	int choice, n;
    	vector<char> v;
    	TNode T;
    	InitList(T);
   	HuffmanTree HT;	
   	HuffmanCode HC;
       while(1)
       {
       	system("cls");
           menu();
           printf("选择你的操作：");
           scanf("%d",&choice);
           switch(choice)
           {
               case 1:
                   ReadTxt(v);
   				TCount(v,T);
   				HuffmanCoding(HT, HC, T);
   				Zip(HC,v,T);
   				RZip(HC,T);
   				system("pause");
   				break;
               case 0:
                   return 0;
               default:
   				cout<<"输入错误！请重新输入";
   				system("pause");
   				break;
           }
       }
       return 0;
   }