哈夫曼编码和译码系统方案

合集下载

哈夫曼编译码系统

if(bt[i].parent==0)
{
k=bt[i].weight;
temp=i;
break;
}
for(i=i+1;i<m;i++)//逐个与其他权值进行比较，并返回在parent为0下权值最小的序号
if(bt[i].weight < k && bt[i].parent == 0)
{
k=bt[i].weight;
{
fscanf(fp,"%c",&c[i]);
if(c[i]=='\n') continue;//读到换行符，跳过，读下一行
fscanf(fp,"%5d",&w[i]);
count++;
i++;
}
fclose(fp);
}
//将内容写入文件
void WriteDataFile(char *fileName)
printf("\t* *\t\n");
printf("\t* **哈夫曼编译码系统** *\t\n");
printf("\t* *\t\n");
printf("\t* *\t\n");
printf("\t* 1.更新哈夫曼编码信息*\t\n");
printf("\t* *\t\n");
printf("\t* 2.显示哈夫曼树及哈夫曼编码*\t\n");
(*s2)=Min(ht,m);
}
//构造哈夫曼树
void CreateHuffmanTree(HuffmanTree *HT,int n)

哈夫曼编码和译码

11
哈夫曼树的构造算法: 哈夫曼树的构造算法: 个结点的一维数组, (1)初始化哈夫曼树的 )初始化哈夫曼树的2n-1个结点的一维数组, 个结点的一维数组即将各结点中的各个域均置0; 即将各结点中的各个域均置 ; 个权值存放到一维数组的前n个单元中 (2)读入个权值存放到一维数组的前个单元中, )读入n个权值存放到一维数组的前个单元中, 它们即为初始森林中的n个只含根结点的权值个只含根结点的权值; 它们即为初始森林中的个只含根结点的权值; (3)对森林中的二叉树进行合并,产生个新 )对森林中的二叉树进行合并,产生n-1个新结点,依次存放到一维数组的第n+1个开始的单元中, 个开始的单元中, 结点,依次存放到一维数组的第个开始的单元中在这个过程中要注意对每个结点双亲域, 在这个过程中要注意对每个结点双亲域,左右孩子域以及权值的修改. 域以及权值的修改.
13
s1=maxval;s2= maxval;/ 设maxval为float类型最大值 ; ;/*设 ;/ 为类型最大值 */ for(j =1;j<=i;j+ +) ( ; ; ) if (ht[j].parent = =0) /*判断是否为根结点判断是否为根结点*/ 判断是否为根结点 if (ht[j].weight<s1) { s2=s1;s1= ht[j].weight; p2=p1;p1=j; } ; ; ; ; else if (ht[j].weight <s2) { s2= ht[j].weight; p2=j; } ; ; ht[p1].parent=i;ht[p2].parent=i; ; ; ht[i].lchild =p1;ht[i].rchild=p2; ; ; ht[i].weight= ht[pl].weight+ht[p2].weight; ; } return (ht);} ;

哈夫曼编码与译码课程设计

目录第1章需求分析 (1)第2章总体设计 (1)第3章抽象数据类型定义 (2)3.1 哈夫曼编码与译码抽象数据类型的设计 (2)第4章详细设计 (2)4.1 工程视图 (2)4.2 类图视图 (3)4.3 函数的调用关系 (3)4.4 主程序流程图 (4)4.5 主要算法的流程图 (5)第5章测试 (7)第6章总结 (8)附录：程序代码 (9)第1章需求分析Huffman编码和译码根据给定的字符集和各字符的频率值，求出其中给定字符Huffman编码，并针对一段文本（定义在该字符集上）进行编码和译码，实现一个Huffman编码/译码系统。

要求设计类（或类模板）来描述Huffman树及其操作，包含必要的构造函数和析构函数，以及其他能够完成如下功能的成员函数：求Huffman编码输入字符串，求出编码输入一段编码，实现译码并设计主函数测试该类。

第2章总体设计图2.1主函数：对输入的字符段进行存储，并对字符数和对应的权值（字符个数）进行统计存储。

哈夫曼树初始化函数：对给定的字符数和权值，创建一棵哈夫曼树。

权值大小比较函数：找到每次所给集合的最小值和次小值，并返回给哈夫曼树初始化函数。

哈夫曼树编码函数：对创建的哈夫曼树，为左孩子的赋值为0，右孩子赋值为1，然后对叶子结点依次编码。

哈夫曼树译码函数：对输入的01二进制数一一与叶子结点的编码依次比较匹配。

第3章抽象数据类型定义3.1哈夫曼编码与译码抽象数据类型的设计enum Child{none,lchild,rchild}; //采用枚举，标记是左孩子还是右孩子class element //元素类{public://类的公有成员elememt(); //构造函数void change(char l,char *c,int p,Child h,int w) //对对象进行修改操作void getparent(int p) //对父结点的值进行修改操作void geta(Child h) //对孩子结点进行修改操作void getweight(int w) //对权值进行修改操作int returnweight() //返回权值操作friend void Select(element h[],int k,int *a,int *b);//友元函数的声明friend void HuffmanTreeCode(element HT[]);friend void HuffmanTreeYima(element huff[],char cod[],int b);private://类的私有成员char letter,*code; //letter为字符,*code指向编码字符串int weight; //权值int parent; //父结点Child a; //为父结点的左孩子还是右孩子};第4章详细设计4.1工程视图图4.1工程视图4.2 类图视图图4.2类图视图4.3 函数的调用关系如下图：图4.3函数调用关系图主函数main()哈夫曼初始化函数 InitHuffmanTree （）寻找最小和次小结点函数 Select() 字符编码函数 HuffmanTreeCode （）字符译码函数 HuffmanTreeYima （）4.4主程序流程图4.5主要算法的流程图图4.5.1哈夫曼编码函数图4.5.2哈夫曼译码函数图5.1哈夫曼编码与译码这次课程设计写得比较仓促，程序许多处仍需要完善和修改。

哈夫曼编码与译码完整版

《数据结构》哈夫曼编码与译码实验报告题目：哈夫曼编码与译码班级：xxxx学号：xxxxxxxxxxx姓名：xxx完成时间：2012年12月19日一、程序总体结构主程序main显示系统时间showtime() 给用户提供选择方式chioce1()显示界面告诉用户程序名称show()打开文件进行加密openfile()退出程序输入电文进行加密input()将输入(文件中)的电文进行哈夫曼编码CrtHuffmanCode(ht,hc,n)统计输入(文件中)字母的出现频率CrW(data,w,count)【fcount(alldata,data,count)】输出每一个字母所对应的哈夫曼编码Printf(hc,n,data,alldata,count)将输入(文件中)的电文创建成哈夫曼树CrtHuffmantree(ht,w,n)对输入(文件中)的文字进行哈夫曼加密showall(hc,alldata,count,data,n)下面有几个不同的程序供选着参考：程序源代码:#include <iostream.h>#include <fstream.h>#include <string.h>#include <stdlib.h>typedef struct{char data;int weight;int parent,lchild,rchild;}HTNode,*HuffmanTree;typedef char * * HuffmanCode;void Select(HuffmanTree &HT,int n,int m){HuffmanTree p=HT;int tmp;for(int j=n+1;j<=m;j++){int tag1,tag2,s1,s2;tag1=tag2=32767;for(int x=1;x<=j-1;x++){ if(p[x].parent==0&&p[x].weight<tag1){ tag1=p[x].weight;s1=x;}}for(int y=1;y<=j-1;y++){ if(p[y].parent==0&&y!=s1&&p[y].weight<tag2){ tag2=p[y].weight;s2=y;}}if(s1>s2) //将选出的两个节点中的序号较小的始终赋给s1 { tmp=s1; s1=s2; s2=tmp;}p[s1].parent=j;p[s2].parent=j;p[j].lchild=s1;p[j].rchild=s2;p[j].weight=p[s1].weight+p[s2].weight;}}void HuffmanCoding(HuffmanTree &HT,int n,char *w1,int*w2) {int m=2*n-1;if(n<=1) return;HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); HuffmanTree p=HT;for(int i=1;i<=n;i++){ p[i].data=w1[i-1];p[i].weight=w2[i];p[i].parent=p[i].lchild=p[i].rchild=0;}for(;i<=m;i++){ p[i].weight=p[i].parent=p[i].lchild=p[i].rchild=0; }Select(HT,n,m);ofstream outfile; //生成hfmTree文件outfile.open("hfmTree.txt",ios::out);for (i=1;i<=m;i++){outfile<<HT[i].weight<<"\t"<<HT[i].parent<<"\t"<<HT[i].lchild<<"\t"<<HT[i].rchil d<<"\t"<<endl;}outfile.close();cout<<"初始化结果已保存在hfmTree文件中\n";}void ToBeTree() //将正文写入文件ToBeTree中{ofstream outfile;outfile.open("ToBeTree.txt",ios::out);outfile<<"THIS PROGRAM IS MYFAVORITE";outfile.close();}void Encoding(HuffmanTree &HT,int n) //编码{HuffmanCode HC;HC=(HuffmanCode)malloc((n+1)*sizeof(char *));char *cd;cd=(char *)malloc(n*sizeof(char));cd[n-1]='\0';for(int k=1;k<=n;k++){ int start=n-1;for(int c=k,f=HT[k].parent;f!=0;c=f,f=HT[f].parent){ if(HT[f].lchild==c) cd[--start]='0';else cd[--start]='1';}HC[k]=(char *)malloc((n-start)*sizeof(char));strcpy(HC[k],&cd[start]);}cout<<"输出哈夫曼编码:"<<endl;for(int h=1;h<=n;h++) //输出编码{ cout<<HT[h].data<<":";cout<<HC[h];cout<<" ";if (h%8==0) cout<<endl;}cout<<endl<<"输出正文编码:"<<endl;ToBeTree();//读取TOBETREE文件里的正文，并进行编码fstream infile;infile.open("ToBeTree.txt",ios::in);char s[80];while(!infile.eof()){infile.getline(s,sizeof(s));}infile.close();fstream outfile;outfile.open("CodeFile.txt",ios::out);int count=0;for (h=0;s[h]!='\0';h++){ for(k=1;k<=n;k++)if (s[h]==HT[k].data){ cout<<HC[k];cout<<" ";count++;outfile<<HC[k];break;}if (count%9==0) cout<<endl; //每输出7个换行}outfile.close();cout<<"\n编码结果已保存在文件CodeFile中."; cout<<endl;}void Decoding(HuffmanTree &HT,int n) //译码{int f=2*n-1;fstream infile;infile.open("CodeFile.txt",ios::in);char s[1000];while(!infile.eof()){infile.getline(s,sizeof(s));}infile.close();int i=0;int j=0;fstream outfile;outfile.open("TextFile.txt",ios::out);while(s[i]!='\0')while(HT[f].lchild!=0)//以f对应的节点的左孩子的值==0作为结束{if (s[j]=='0') f=HT[f].lchild;else f=HT[f].rchild;j++;}i=j;cout<<HT[f].data;outfile<<HT[f].data;}outfile.close();cout<<"\n译码结果已保存在文件TextFile中.";cout<<endl;}void Print() //印代码文件{ int count=0;fstream infile;infile.open("CodeFile.txt",ios::in);char s[1000];while(!infile.eof()){infile.getline(s,sizeof(s));for(int i=0;s[i]!='\0';i++){ cout<<s[i];count++;if (count%50==0) cout<<endl; //在终端上每行显示50个代码}}infile.close();cout<<endl;}char menu() //菜单函数{ cout<<"功能菜单如下:"<<endl;cout<<"* * * * * * * * * * * * * * * * * * * * *"<<endl;cout<<" I:初始化(Initialization) "<<endl;cout<<" E:编码(Encoding) "<<endl;cout<<" D:译码(Decoding) "<<endl;cout<<" P:印代码文件(Print) "<<endl;cout<<" Q:退出(Exit) "<<endl;cout<<"* * * * * * * * * * * * * * * * * * * * *"<<endl;cout<<"请输入功能字符:";char ch;cin>>ch;return ch;}{ int n;int Array[100];char cArray[100];HuffmanTree HT;cout<<"输入n个字符:";cin.getline(cArray,100);n=strlen(cArray);cout<<"一共"<<n<<"个字符.\n";cout<<"依次输入各个字符的权值:"<<endl;for (int i=1;i<=n;i++) cin>>Array[i];int tag;char x=menu();while(1){ switch (x){case 'I':HuffmanCoding(HT,n,cArray,Array);break; case 'E':Encoding(HT,n);break;case 'D':Decoding(HT,n);break;case 'P':Print();break;case 'Q':tag=0;cout<<"结束"<<endl;break; default:cout<<"你输入错误!"<<endl;}if(tag==0) break;cout<<"y(继续) or n(退出)"<<endl;char ch;cin>>ch;if (ch=='y'){ cout<<"请输入功能字符:";char c;cin>>c;x=c;}else exit(1);}}源程序：#include<iostream>#include<fstream>#include<iomanip>#include<vector>using namespace std;typedef struct //节点结构{char data; //记录字符值long int weight; //记录字符权重unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree; //动态分配数组存储哈夫曼树typedef char * *HuffmanCode; //动态分配数组存储哈夫曼编码表void Select(HuffmanTree &HT,int i,int &s1,int &s2) //在HT[1...t]中选择parent不为0且权值最小的两个结点，其序号分别为s1和s2{s1=0;s2=0;int n1=30000,n2=30000;for(int k=1;k<=i;k++){if(HT[k].parent==0){if(HT[k].weight<n1){n2=n1; n1=HT[k].weight;s2=s1; s1=k;}elseif(HT[k].weight<n2){n2=HT[k].weight;s2=k;}}}}void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int n)//将要编码的字符串存入空树中{ifstream fin1("zifu.txt");ifstream fin2("weight.txt");if(n<=1)return;int m=2*n-1;int i;HT=new HTNode[m+1];char *zifu;int *weight;zifu= new char[n+1];weight=new int[n+1];for(i=1;i<=n;i++)//将待编码的字符放在zifu数组中{char ch;ch=fin1.get();zifu[i]=ch;}for(i=1;i<=n;i++)//将带编码字符对应的权值放在weight数组中{fin2>>weight[i];}for( i=1;i<=n;i++){HT[i].data=zifu[i];HT[i].weight=weight[i];}for(i=n+1;i<=m;i++){HT[i].data='@';}for(i=1;i<=m;i++){HT[i].parent=HT[i].lchild=HT[i].rchild=0;}for(i=n+1;i<=m;++i){int 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*));开辟一个求编码的工作空间char *cd;cd=(char *)malloc(n*sizeof(char));//开辟空间存放权值cd[n-1]='\0';for(i=1;i<=n;i++){int start=n-1;int c,f;for( c=i, f=HT[i].parent;f!=0;c=f,f=HT[f].parent)//从叶子到根逆向求编码{if(HT[f].lchild==c)cd[--start]='0';//若是左孩子编为'0'elsecd[--start]='1';//若是右孩子编为'1'}HC[i]=(char *)malloc((n-start)*sizeof(char)); //为第i个编码分配空间strcpy(HC[i],&cd[start]);}delete []cd; //释放工作空间}void printHuffmanTree(HuffmanTree HT,int n) //显示有n个叶子结点的哈夫曼树的编码表{ ofstream fout("hfmtree.txt"); //将对应字符的的哈弗曼树存入cout<<"NUM"<<" "<<"data"<<" "<<"weight"<<" "<<"parent"<<" "<<"lchild"<<" "<<"rchlid"<<endl;for(int i=1;i<=2*n-1;i++){fout<<HT[i].weight<<setw(3)<<HT[i].parent<<setw(3)<<HT[i].lchild<<setw(3) <<HT[i].rchild<<endl;cout<<i<<setw(5)<<HT[i].data<<setw(3)<<HT[i].weight<<setw(3)<<HT[i].pare nt<<setw(3)<<HT[i].lchild<<setw(3)<<HT[i].rchild<<endl;}}void printHuffmanCoding(HuffmanTree HT,HuffmanCode HC,int n)//输出字符的对应哈弗曼编码并存入code.txt文件{cout<<"Huffman code is:"<<endl;ofstream fout("code.txt");for(int i=1;i<=n;i++){cout<<HT[i].data<<" --> ";cout<<(HC[i])<<endl;fout<<(HC[i])<<endl;}}void code_file(HuffmanTree HT,HuffmanCode HC,int n)//对文件tobetran.txt进行编码，并将编码存入codefile文件中{ifstream fin("tobetran.txt");ofstream fout("codefile.txt");vector<char> a;char ch;while((ch=fin.get())!='*')a.push_back(ch);cout<<"待编码的字符串为：";for(int k=0;k<a.size();k++)cout<<a[k];cout<<endl;cout<<"\n编码结果:"<<endl;for(int i=0;i<a.size();i++){for(int j=1;j<=n;j++){if(a[i]==HT[j].data){fout<<HC[j];break;}}}fin.close();fout.close();}void Decoding(HuffmanTree HT,HuffmanCode HC,int n)//打开codefile文件并对文件内容进行译码{int const m=2*n-1;ifstream fin("codefile.txt");ofstream fout("textfile.txt");vector<char> a;for(char c;fin>>c;)a.push_back(c);int count=0;for(int k=0;k<a.size();k++){cout<<a[k];count++;if(count%50==0)cout<<endl;}int i=0;int p; //用p来记住m的值cout<<endl;cout<<"\n译码结果："<<endl;while(i<a.size()){p=m; //从哈弗曼数的根开始遍历while(HT[p].lchild){if(a[i]=='1')p=HT[p].rchild;elsep=HT[p].lchild;i++;}fout<<HT[p].data;cout<<HT[p].data;}}void main(){int n;cout<<"输入权值个数："; //设置权值数值cin>>n;printf("\n");HuffmanTree HT; //哈夫曼树HTHuffmanCode HC; //哈夫曼编码表HCHuffmanCoding(HT,HC,n); //进行哈夫曼编码printHuffmanCoding(HT,HC,n); //显示编码的字符printf("\n");code_file(HT,HC,n); //显示要编码的字符串，并把编码值显示出来Decoding(HT,HC,n); //译码并显示译码后的字符串printf("\n\n\n");system("pause");}主要程序代码://HuffmanCode1.h#ifndef HUFFMAMCODE_H#define HUFFMAMCODE_H#include<iostream>#include<fstream>using namespace std;struct HuffmanNode //定义哈夫曼树各结点{int weight;int parent;int lchild,rchild;int flag;};class HuffmanCode1 //哈夫曼编码类{public:char Info[100];int Start;char Leaf;};class HuffmanTree1 //建立哈夫曼树类{private:HuffmanNode *Node;public:int f;HuffmanCode1 *hf;HuffmanTree1();~HuffmanTree1();void TranslatedCode();void CodeHuf(HuffmanNode a[],HuffmanCode1 b[],int n);void CreateHfmTree(char Str[],int m[],int n);void TransCode(HuffmanCode1 b[],int n) ;void TranslateArtcle(HuffmanCode1 b[],int n) ;};#endif //HUFFMAMCODE_HHuffmanCode.cpp#include "iostream"#include<stdio.h>#include "math.h"#include "stdlib.h"#include"HuffmanCode1.h"#include<string>using namespace std;#define MAXDA TA 10000 //最长字符串#define MAXSIZE 150 //最多子叶数//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////第一部分功能（W）实现的代码$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ HuffmanTree1::HuffmanTree1(){ Node=NULL; } //将树结点初始化为空HuffmanTree1::~HuffmanTree1(){ delete[] Node; } //释放结点空间void HuffmanTree1::CreateHfmTree(char Str[],int m[],int n)//建立哈夫曼树{int i,j,m1,m2,x1,x2;HuffmanNode *HfmNode=new HuffmanNode[2*n-1];HuffmanCode1 *HfmCode=new HuffmanCode1[n];for(i=0;i<2*n-1;i++){HfmNode[i].weight=0;HfmNode[i].parent=0;HfmNode[i].flag=0;HfmNode[i].lchild=-1;HfmNode[i].rchild=-1;}for(i=0;i<n;i++){HfmNode[i].weight=m[i];HfmCode[i].Leaf=Str[i];}for(i=0;i<n-1;i++){m1=m2=32767;x1=x2=0;for(j=0;j<n+i;j++){if(HfmNode[j].weight<=m1&&HfmNode[j].flag==0){m2=m1;x2=x1;m1=HfmNode[j].weight;x1=j;}else if(HfmNode[j].weight<=m2&&HfmNode[j].flag==0){m2=HfmNode[j].weight;x2=j;}}HfmNode[x1].parent=n+i;HfmNode[x2].parent=n+i;HfmNode[x1].flag=1;HfmNode[x2].flag=1;HfmNode[n+i].weight=HfmNode[x1].weight+HfmNode[x2].weight;HfmNode[n+i].lchild=x1;HfmNode[n+i].rchild=x2;}CodeHuf(HfmNode,HfmCode,n);TransCode(HfmCode,n);//TranslateArtcle(HfmCode,n);hf=HfmCode; f=n;}void HuffmanTree1::CodeHuf(HuffmanNode a[],HuffmanCode1 b[],int n) //对哈夫曼树进行编码{HuffmanCode1 Hfd;int c,p;for(int i=0;i<n;i++){Hfd.Start=n-1;c=i;p=a[c].parent;while(p!=0){if(a[p].lchild==c)[Hfd.Start]='0';else[Hfd.Start]='1';Hfd.Start--;c=p;p=a[c].parent;}printf("%c :",b[i].Leaf);for(int j=Hfd.Start+1;j<n;j++){b[i].Info[j]=[j];printf("%c",[j]);}printf("\n");b[i].Start=Hfd.Start;}}void HuffmanTree1::TransCode(HuffmanCode1 b[],int n) //对文章进行翻译并保存{ifstream ifs("WData.txt");ofstream ofs("WCode.txt");char s[1000];int t=0;char ch;cout<<"************************************************************** *****************"<<endl;printf("报文的编码为：\n");while(ifs.get(ch)){if(ch!='\n')s[t]=ch;for(int i=0;i<n;i++){if(s[t]==b[i].Leaf)for(int j=b[i].Start+1;j<n;j++){printf("%c",b[i].Info[j]);ofs<<b[i].Info[j];}}t++;}printf("\n");printf("报文的编码已经保存在WCode.txt中\n");cout<<"*********************************************************** ********************"<<endl;}void HuffmanTree1::TranslateArtcle(HuffmanCode1 b[],int n) //将所译的码翻译成文章并保存{int t=0;ifstream ifs("WCode.txt");ofstream ofs("TransWData.txt");string s;getline(ifs,s);for(t=0;s[t]!='\0';t++);int l=0;int j=0;printf("报文的译码结果为：\n");while(l<t){while(j<n){int hu=b[j].Start+1;int k=0;while(hu<n){if(s[l]==b[j].Info[hu]){l++;hu++;k++;}else{break;}}if(hu==n){printf("%c",b[j].Leaf);ofs<<b[j].Leaf;j=0;break;}else{l=l-k;j++; continue;}}}printf("\n");printf("译码的结果已经保存到TransWData.txt中\n");cout<<"*********************************************************** ********************"<<endl;}void HuffmanTree1::TranslatedCode(){ifstream ifs("WData.txt");char str[1000];char Str[100];int i=0,j,m[100],h,k=0;int n=0;cout<<"*********************************************************** ********************"<<endl;printf("文件中提取的文章字符串是：\n");char ch;while(ifs.get(ch)){printf("%c",ch);if(ch!='\n'){str[n++]=ch;}}printf("\n");printf("字符串中共含有字符%d个\n",n);for(i=0;i<n;i++){j=0;h=0;while(str[i]!=str[j])j++;if(j==i){Str[k]=str[i];printf("字符%c出现",Str[k]);}elsecontinue;for(j=i;j<n;j++){if(str[i]==str[j])h++;}printf("%d次\n",h);m[k]=h;k++;}cout<<"*********************************************************** ********************"<<endl;printf("字符串中字符种类有%d种\n",k);cout<<"*********************************************************** ********************"<<endl;printf("每个字符对应的哈夫曼编码是：\n");CreateHfmTree(Str,m,k);cin.get();// printf("\n");}//main.cpp//#include"HuffmanCode1.h"//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////第二部分功能实现的代码$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ typedef struct //哈弗曼树节点的结构体{char info; //关联字符信息unsigned int weight; //每个节点的权职unsigned int parent, lchild, rchild;}HTNode,*HuffmanTree;typedef char **HuffmanCode; //存储哈弗曼编码void Select(HuffmanTree HT, int j,int &s1,int &s2){ //选择双亲节点为0，并且最小的两个子叶节点int i=1,m;while(HT[i].parent!=0)i++; //找第一个双亲节点为0的子叶结点for(s2=s1=i;i<j;i++){ /保证s1中的权值最小，s2次小if(HT[i].parent==0 && HT[i].weight<HT[s1].weight){s2=s1;s1=i;}else if(HT[i].parent==0 && HT[i].weight>=HT[s1].weight &&HT[i].weight<=HT[s2].weight)s2=i;while(HT[i].parent==0 && s1==s2){m=i;m++;while(HT[m].parent!=0)m++;s2=m;}}}void HuffmanCoding(HuffmanTree &HT, HuffmanCode &HC, int *w, int n, char *info){ //哈弗曼编码int i,m;HuffmanTree p;if(n<1) return;m = 2*n-1;HT = (HuffmanTree)malloc((m+1)*sizeof(HTNode));for(p=HT+1,i=1;i<=n;++i,++p,++w,++info){ //初始化所有已存在的子叶信息p->info = *info;p->weight = *w;p->parent = 0;p->lchild = 0;p->rchild = 0;}//forfor(; i<=m;++i,++p){ //构造所需要的过度根节点p->weight = 0;p->parent = 0;p->lchild = 0;p->rchild = 0;}//forfor(i=n+1;i<=m;++i){ //建立哈弗曼树int s1,s2;Select(HT,i-1,s1,s2);HT[s1].parent =i;HT[s2].parent =i;HT[i].lchild = s2;HT[i].rchild = s1;HT[i].weight = HT[s1].weight+HT[s2].weight;}//for//哈弗曼编码HC = (HuffmanCode)malloc((n+1)*sizeof(char *));char* cd = (char*)malloc(n*sizeof(char));cd[n-1] = '\0';for(i=1;i<=n;++i){int f;unsigned int c;int 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));strcpy(HC[i], &cd[start]);}//forfree(cd);}//HuffmanCoding//Y功能实现输出并保存字符串的二进制编码void CheckCoding(HuffmanTree HT, HuffmanCode HC, char *strcheck, int m,int k) { ofstream ofs("BCode.txt"); //查询哈弗曼编码信息int p;for(int i=0; i<m; i++){for(int j=1; HT[j].info != strcheck[i]; j++);cout<<HC[j]; //输出并保存字符串的二进制编码ofs<<HC[j];}cout<<endl;cout<<"字符串的二进制编码已经保存在“BCode.txt”中"<<endl;//cout<<"译码翻译得到的文章已保存在“Data.txt”中"<<endl;cout<<"************************************************************** *****************"<<endl;cout<<"各字符对应的编码为:"<<endl; //输出各字符对应的哈夫曼编码for( p=1;p<=k;p++){cout<<HT[p].info <<": "<<HC[p]<<endl;}}//CheckCoding//对键盘输入的二进制代码进行译码void HuffmanTranslateCoding(HuffmanTree HT, int n,char*c){ ofstream ofs("TransBData.txt"); //译码过程int m=2*n-1;int i,j=0;cout<<"译码翻译得到的文章已保存在“TransBData.txt”中"<<endl;cout<<"译码翻译得到的文章为:";while(c[j]!='\0'){i=m;while(HT[i].lchild && HT[i].rchild){if(c[j]=='0')i=HT[i].lchild;else if(c[j]=='1')i=HT[i].rchild;j++;}cout<<HT[i].info; //翻译成字符串并输出和保存ofs<<HT[i].info;}}//译码过程、、对"BCode.txt"的编码进行译码void HuffmanTranslateCoding2(HuffmanTree HT, int n){ ifstream ifs("BCode.txt");ofstream ofs("TransBData2.txt");string c;int m=2*n-1;int i,j=0;getline(ifs,c);cout<<"译码翻译得到的文章已保存在“TransBData2.txt”中"<<endl;cout<<"译码翻译得到的文章为:";while(c[j]!='\0'){i=m;while(HT[i].lchild && HT[i].rchild){if(c[j]=='0')i=HT[i].lchild;else if(c[j]=='1')i=HT[i].rchild;j++;}cout<<HT[i].info; //翻译成字符串并输出和保存ofs<<HT[i].info;}}void Menushow(){cout<<"||******************************************************************** ****||"<<endl;cout<<" || HuffmanCode and HUffmanTranslate System ||"<<endl;cout<<" || ***********哈夫曼编码/译码系统************* ||"<<endl;cout<<" || *************欢迎使用本系统**************** ||"<<endl;cout<<" || 东北电力大学信息工程学院计机093班兴趣小组||"<<endl;cout<<" || 制作人：范辉强（组长）李哲周兴宇||"<<endl;cout<<"||******************************************************************** ****||"<<endl;cout<<" ||在本系统中您可以进行如下操作：||"<<endl;cout<<" ||第一部分功能：||"<<endl;cout<<" || A :从文件提取字符串，然后对提取的字符串进行编码||"<<endl;cout<<" || B :根据W操作对“WCode.txt”里的二进制编码进行译码||"<<endl;cout<<" ||第二部分功能：||"<<endl;cout<<" || C :对您输入的字符串进行编码||"<<endl;cout<<" || D:对BCode.txt里的编码进行译码||"<<endl;cout<<" || E :对您输入的二进制编码进行译码||"<<endl;cout<<" ||第三部分功能：||"<<endl;cout<<" || F :退出本系统||"<<endl;cout<<"||******************************************************************** ****||"<<endl;cout<<" ||温馨提示：||"<<endl;cout<<" || 执行A，请将您的数据存储在同目录下名为“WData”文本文档里||"<<endl;cout<<" || 在执行C操作时务必在您输入的字符串后加上“#”||"<<endl;cout<<" || B与A是对应的B在A后运行||"<<endl;cout<<" || D/E与C是对应的，即B/C是根据C来进行译码的||"<<endl;cout<<" || 译码D/E应在编码C后才能进行||"<<endl;cout<<" ||*********************** Copyright by FanFan ********************||"<<endl;}//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///main().cppint main(){int n=0,i=0,k=0,j,h,*w;FILE *fp;char ch2,str[MAXDA TA],choose,name[]="BData.txt";w=new int[MAXSIZE];char *info;char *strcheck=str;info=new char[MAXSIZE];char *ch=new char[MAXSIZE];HuffmanTree HT=new HTNode[MAXSIZE];HuffmanCode HC=NULL;HuffmanTree1 HuffmanNode;Menushow();while(1){cout<<endl;cout<<"************************************************************** *****************"<<endl;cout<<"*********************************************************** ********************"<<endl;cout<<"请输入您要进行的操作（W/F/B/C/Y/T)(不区分大小写)："<<endl;cin>>choose;cout<<"************************************************************** *****************"<<endl;switch(choose){case 'A':case 'a':HuffmanNode.TranslatedCode();break;case 'B':case 'b':HuffmanNode.TranslateArtcle(HuffmanNode.hf,HuffmanNode.f);case 'D':case 'd':HuffmanTranslateCoding2( HT,n);break;case 'E':case 'e'://进行译码操作cout<<"请您输入您要编译的二进制编码: "<<endl;cin>>ch;HuffmanTranslateCoding(HT,n,ch);break;case 'T':case 't'://退出系统return 0;case 'C':case 'c'://进行编码操作cout<<"请输入您要编码的字符串："<<endl;//从键盘输入字符串存放在字符数组str[1000]中/*if ((fp=fopen(name,"w"))==NULL){cout<<"cannot open file"<<endl;exit(0);}*/fp=fopen(name,"w");ch2=getchar();//接收上一次键盘输入的换行符ch2=getchar();while(ch2!='#'){fputc(ch2,fp);str[n++]=ch2;putchar(str[n-1]);ch2=getchar();}putchar(10);fclose(fp);cout<<endl;cout<<"输入的数据已经保存在“BData.txt”中"<<endl;cout<<"*******************************************************************************"<<endl;cout<<"字符串中共含有字符"<<n<<"个"<<endl;cout<<"*********************************************************** ********************"<<endl;for(i=0;i<n;i++) // 统计从键盘输入的字符串的信息{j=0;h=0;while(str[i]!=str[j])j++;if(j==i){info[k]=str[i];cout<<"字符"<<info[k]<<"出现";}elsecontinue;for(j=i;j<n;j++){if(str[i]==str[j])h++;}cout<<h<<"次"<<endl;w[k]=h;k++;}cout<<"************************************************************** *****************"<<endl;cout<<"字符串中字符种类有"<<k<<"种"<<endl;cout<<"************************************************************** *****************"<<endl;HuffmanCoding( HT, HC, w, n,info);//对输入的字符串进行编码*strcheck=str[0];cout<<"您输入的字符串编码为："<<endl;CheckCoding(HT,HC,strcheck,n,k);break;default:cout<<"对不起，您的输入不正确！请重新输入"<<endl;}//switch}//while}//main程序清单.cpp#include<iostream>#include<stdio.h>#include<stdlib.h>#include<string>#include"Hh1.h"using namespace std;FILE * f1=fopen("d:\\pra1.txt","r");FILE * f2=fopen("d:\\pra2.txt","w");FILE * f3=fopen("d:\\pra4.huf","w");int main(){init(SN); //初始化字符数据库// input(f1); //读入初始文件的字符//for(int i=0;forest[i]!=NULL;i++)cout<<forest[i]->c<<":"<<forest[i]->weight<<endl; //输出字符及出现次数// cout<<"出现字符种类"<<count<<endl; //输出字符种类//HFM huffman(count); //创建哈夫曼树实例// huffman.creat(); //创建哈夫曼树// count=0;huffman.hufcode(); //哈夫曼编码，此时为逆向//exchange(); //调整首尾对调哈夫曼编码// huffman.savewithhufcode(f1,f2); //用哈夫曼编码存储原文件//cout<<endl;cout<<"1.查看哈夫曼编码"<<endl;cout<<"2.哈夫曼解码"<<endl;cout<<"3.查看压缩率"<<endl;int choice;cin>>choice;while(choice>=1&&choice<=3){switch(choice){case 1:{for(i=0;hufNode[i].sig!=NULL;i++){cout<<"字符"<<hufNode[i].sig->c<<"的哈夫曼编码:"; //输出哈夫曼编码//for(int j=0;j<hufNode[i].size;j++)cout<<hufNode[i].code[j];cout<<endl;}cout<<"最大列数:"<<huffman.maxc()<<endl;break;}case 2:{fclose(f2);f2=fopen("d:\\pra2.txt","r");huffman.hufdecode(f2,f3); //哈夫曼解码//cout<<endl;break;}case 3:{compress(); //查看压缩情况//cout<<endl;}}cout<<"1.查看哈夫曼编码"<<endl;cout<<"2.哈夫曼解码"<<endl;cout<<"3.查看压缩率"<<endl;cin>>choice;}cout<<"*谢谢使用*"<<endl; //退出操作//return 0;}.h#include<iostream>using namespace std;struct signode{ //signode节点，哈夫曼树节点//char c; //字符//int weight; //权重//bool b; //文章中是否出现//。

哈夫曼编码和译码的设计与实现

算法与数据结构课程设计哈夫曼编码和译码的设计与实现1.问题描述利用哈夫曼编码进行通信可以大大提高信道的利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。

对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。

试为这样的信息收发站设计一个哈夫曼码的编/译码系统。

2.基本要求a.编/译码系统应具有以下功能：（1）I：初始化（Initialization）。

从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中。

（2）E：编码（Encoding）。

利用已建好的哈夫曼树（如不在内存，则从文件hfmTree中读入），对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中。

（3）D：译码（Decoding）。

利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中。

（4）P：印代码文件（Print）。

将文件CodeFile以紧凑格式显示在终端上，每行50个代码。

同时将此字符形式的编码文件写入文件CodePrin中。

（5）T：印哈夫曼树（Tree printing）。

将已在内存中的哈夫曼树以直观的方式（树或凹入表形式或广义表）显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。

b.测试数据（1）利用下面这道题中的数据调试程序。

某系统在通信联络中只可能出现八种字符，其概率分别为0.25，0.29，0.07，0.08，0.14，0.23，0.03，0.11，试设计哈夫曼编码。

（2）用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FAVORITE”。

字符空格 A B C D E F G H I J K L M频度 186 64 13 22 32 103 21 15 47 57 1 5 32 20字符 N O P Q R S T U V W X Y Z频度57 63 15 1 48 51 80 23 8 18 1 16 13．需求分析3.1程序的基本功能本程序可以对任何大小的字符型文件进行Huffman编码，生成一个编码文件。

哈夫曼编译码的设计与实现

哈夫曼编\译码的设计与实现一、简介1．设计目的：通过对简单哈夫曼编/译码系统的设计与实现来熟练掌握树型结构在实际问题中的应用。

2．问题的描述：利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码。

系统应该具有如下的几个功能：接收原始数据、编码、译码、打印编码规则。

二、数据结构的设计：1.哈夫曼结点结构体：typedef struct HtNode{int weight;int parent, lchild, rchild;}HtNode;2.哈夫曼树结构体：typedef struct HtTree{struct HtNode ht[MAXNODE+1];int root;}HtTree, *PHtTree;三、功能（函数）设计：总体上划分为四个模块，具体功能描述如下：1．初始化功能模块：接收输入信息，并正确输出2．建立哈夫曼树的功能模块：按照构造哈夫曼树的算法构造哈夫曼树，将HuffNode数组中的各个位置的各个域都添上相关的值3．哈夫曼编码的功能模块：根据输入的相关字符信息进行哈夫曼编码，然后将结果存入，同时将字符与0、1代码串的一一对应关系打印到屏幕上。

4．译码的功能模块：接收需要译码的0、1代码串，按照哈夫曼编码规则将其翻译成字符集中的字符所组成的字符串形式，将翻译的结果在屏幕上输出四、界面设计：该界面操做简单，内容详细，便于程序使用者根据提示轻松上手。

简洁明朗是该界面最大的特点。

哈夫曼编/译码请逐个输入结点和结点的权值>>>按Enter键开始根据此提示界面进入程序使用阶段。

请输入结点个数：根据用户输入结点个数，动态输入并存储字符及权值然后输出字符与0、1代码串的对应关系。

进入以下界面，进行后续操作1----------------------------编码2----------------------------译码3----------------------------重新输入权值;0----------------------------退出用户键入“0”，即可出编码译码操作五、程序设计：1．函数功能说明及其程序流程图的描述：1>:main函数：控制整个程序的整个流程。

哈夫曼编码和译码的算法设计与实现

哈夫曼编码和译码的算法设计与实现实验名称哈夫曼编码和译码的算法设计与实现实验方案实验成绩实验日期实验室信息系统设计与仿真室I 实验操作实验台号班级姓名实验结果一、实验目的1、掌握哈夫曼编码的二叉树结构表示方法；2、编程实现哈夫曼编码译码器；3、掌握贪心算法的设计策略。

二、实验任务①从文件中读取数据，构建哈夫曼树；②利用哈夫曼树，对输入明文进行哈夫曼编码；③利用哈夫曼树，对输入编码译码为明文。

三、实验设计方案1、结构体设计Huffman树：包括字符，权，父亲下标，左孩子下标，右孩子下标#define N 29 //26个小写字母，逗号，句号和空格字符.struct treenode{ //静态链表char c; //charint w; //weightint f; //fatherint l; //left child indexint r; //right child index};struct treenode htree[2*N-1];2、自定义函数设计①函数原型声明void input(); //读取文件字符、权值数据void huffman(); //建立huffman树void getcode(int i, char *str); //得到单个字符的huffman编码void encode(char ch); //将明文进行huffman编码void decode(char *str); //将huffman编码译为明文②读取文件字符、权值数据void input(){int i;char c;int f;freopen("in.txt","r",stdin);for(i=0;i<n;i++)< p="">{c=getchar(); //接收字符scanf("%d",&f); //接收权值getchar(); //接收回车ht[i].c=c;ht[i].w=f;ht[i].l=ht[i].f=ht[i].r=-1; //初始化父亲、左右孩子下标} freopen( "CON", "r", stdin);}③建立huffman树//使用贪心法建立huffman树,每次选择权值最小的根结点void huffman(){void huffman(){int j,k,n;input();j=0;k=N;for(n=N;n<2*N-1;n++){ //建立huffman树，共合并N-1次int r=0,s=0;ht[n].l=ht[n].f=ht[n].r=-1;while(r<2){ //选择两个最小的权值结点if((ht[k].w==0 || ht[k].w>ht[j].w) && j<n){< p="">s+=ht[j].w;if(r==0) ht[n].l = j; //修改父亲、孩子下标else ht[n].r=j;ht[j].f=n;j++;}else{s+=ht[k].w;if(r==0) ht[n].l = k; //修改父亲、孩子下标else ht[n].r=k;ht[k].f=n;k++;}r++;}ht[n].w=s; //修改权值}}④根据字符下标找到字符的huffman编码//根据字符所在的下标，从叶子结点往上搜索到根节点，然后逆置得到该字符的huffman编码void getcode(int i, char *str){ int n,j,l=0;for(n=i;ht[n].f!=-1;n=ht[n].f){ //沿着父亲往上搜索int m=ht[n].f;if(n==ht[m].l)str[l++]='0'; //左孩子记为0elsestr[l++]='1'; //右孩子记为1}for(j=0;j<=(l-1)/2;j++){ //将编码逆置char t;t=str[j];str[j]=str[l-1-j];str[l-1-j]=t;}str[l]=0; // str存放huffman编码，字符串结束标记}⑤读入明文生成huffman编码void encode(char ch){int i;char str[N];for(i=0;ht[i].c!=0;i++)if(ht[i].c==ch) //找字符下标break;if (ht[i].c!=0){getcode(i,str); //得到字符的huffman编码printf("%s",str);}}⑥将huffman编码串译码为明文void decode(char *str){while(*str!='\0'){int i;for(i=2*N-2;ht[i].l!=-1;){if(*str=='0')i=ht[i].l;elsei=ht[i].r;str++;}printf("%c",ht[i].c);}}3、主函数设计思路：主函数实现实验任务的基本流程。

哈夫曼编码与译码

哈夫曼编码与译码孙宇E010141081.题目内容：利用Huffman编码进行通信可以大大提高信道的利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据进行预先编码，在接收端进行解码。

对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/解码系统。

2.基本要求：输入一段英文，系统自动计算出每个字符的权值，以及哈夫曼编码，显示哈夫曼树。

最终把字符串的编码的显示出来。

然后进行译码，把编码信息转换成相应的文字信息。

3.程序模块结构图4.详细程序设计#include "stdafx.h" #include<stdio.h> #include<malloc.h> 主函数模块编码模块解码模块打印代码模块打印树模块输入初始化模块#include<string.h>#define MAXSIZE 100#define N 100#define M 2*N-1typedef struct //建立哈夫曼树结点{char ch;int weight;int parent;int LChild;int RChild;}HTNode,HuffmanTree[MAXSIZE];typedef struct //定义结构体{char ch;int number;}NUM[MAXSIZE];typedef char * HuffmanCode[N+1];void menu(void);void getchars(char *str,int *len); //输入字符串void Init(int A[MAXSIZE],int *n); //输入结点的权值（备用）void CrtHuffmanTree(HuffmanT ree ht,NUM w,int n);//创建哈夫曼树void select(HuffmanT ree ht,int pos,int *s1,int *s2);void CrtHuffmanCode(HuffmanTree ht,HuffmanCode hc,int n);//创建哈夫曼编码void showHuffmanCode(HuffmanCode hc,int n,NUM w,char *str,char *code,int len);//显示哈夫曼编码及各结点详细信息void total(char str[MAXSIZE],NUM w,int *n,int len);void CrtHuffmanDecode(HuffmanTree ht,char *code,int n);//进行译码工作void CrtHuffmanDecode(HuffmanTree ht,char *code,int n) {char result[MAXSIZE]={0};int rootIndex=n*2-1;int i,j,root=rootIndex;printf("\n传过来的信息是:\n");puts(&code[1]);for(i=j=1;i<=(int)strlen(&code[1])+1;i++){if(ht[root].RChild==0){result[j++]=ht[root].ch;root=rootIndex;}if(code[i]=='1')root=ht[root].RChild;elseroot=ht[root].LChild;}result[j]=0;printf("\n译码的结果是:\n%s\n\n",&result[1]);puts(&result[1]);}void total(char str[MAXSIZE],NUM w,int *n,int len) {int i,j=1,k=1;for(i=1;i<=len;i++)w[i].number=0;w[k].ch=str[j];w[k].number++;k++;for(j=2;j<len;j++){for(i=1;i<k;i++)if(str[j]==w[i].ch){w[i].number++;break;}if(i==k){w[k].ch=str[j];w[k].number++;k++;}}*n=k-1;}void showHuffmanCode(HuffmanCode hc,int n,NUM w,char *str,char *code,int len){int i,j;printf("字符\t权值\t编码\n");for(i=1;i<=n;i++)printf("%c\t%d\t%s\n",w[i].ch,w[i].number,hc[i]);printf("\n字符编码是:\n");for(i=1;i<len;i++)for(j=1;j<=n;j++)if(str[i]==w[j].ch){// printf("%s",hc[j]);strcat(&code[1],hc[j]);// break;}puts(&code[1]);}void CrtHuffmanCode(HuffmanTree ht,HuffmanCode hc,int n) {int i,c,start,p;char *cd;cd=(char *)malloc((n+1)*sizeof(char));cd[n-1]='\0';for(i=1;i<=n;i++){start=n-1;c=i;p=ht[i].parent;while(p!=0){--start;if(ht[p].LChild==c)cd[start]='0';elsecd[start]='1';c=p;p=ht[p].parent;}hc[i]=(char *)malloc((n-start)*sizeof(char));strcpy(hc[i],&cd[start]);}free(cd);}void select(HuffmanT ree ht,int pos,int *s1,int *s2){int i,m1,m2;for(i=1;i<=pos;i++)if(ht[i].parent==0){m1=i;break;}for(i=1;i<=pos;i++)if(ht[i].weight<=ht[m1].weight && ht[i].parent==0) m1=i;*s1=m1;m2=m1;for(i=1;i<=pos;i++)if(ht[i].parent==0 && i!=m2){m1=i;break;}for(i=1;i<=pos;i++)if(ht[i].weight<=ht[m1].weight && ht[i].parent==0 && i!=m2)m1=i;*s2=m1;}void CrtHuffmanTree(HuffmanTree ht,NUM w,int n){//构造哈夫曼树ht[M+1],w[]存放n个权值int i,m,s1,s2;for(i=1;i<=n;i++){ht[i].ch=w[i].ch;ht[i].weight=w[i].number;ht[i].parent=0;ht[i].LChild=0;ht[i].RChild=0;}m=2*n-1;for(i=n+1;i<=m;i++){ht[i].ch=' ';ht[i].weight=0;ht[i].parent=0;ht[i].LChild=0;ht[i].RChild=0;}for(i=n+1;i<=m;i++){select(ht,i-1,&s1,&s2);ht[i].weight=ht[s1].weight+ht[s2].weight;ht[s1].parent=i;ht[s2].parent=i;ht[i].LChild=s1;ht[i].RChild=s2;}}void getchars(char *str,int *len){printf("请输入一行字符串:\n");gets(&str[1]);*len=strlen(str);}/*void Init(int w[MAXSIZE],int *n) {int num,i=1;printf("请输入一组权值(以0结束):");scanf("%d",&num);while(num){w[i]=num;i++;scanf("%d",&num);}*n=i-1;}*/void main(void){HuffmanTree ht;HuffmanCode hc;char code[MAXSIZE]="";NUM w;int n,len;char str[MAXSIZE];getchars(str,&len);total(str,w,&n,len);// Init(w,&n);CrtHuffmanTree(ht,w,n);CrtHuffmanCode(ht,hc,n);showHuffmanCode(hc,n,w,str,code,len);CrtHuffmanDecode(ht,code,n);}5.测试程序：输入一段英文I am sunyu，i am a student. 显示结果如下：运行成功！。

哈夫曼编码译码器实验报告

哈夫曼编码译码器实验报告实验名称：哈夫曼编码译码器实验一、实验目的：1.了解哈夫曼编码的原理和应用。

2.实现一个哈夫曼编码的编码和译码器。

3.掌握哈夫曼编码的编码和译码过程。

二、实验原理：哈夫曼编码是一种常用的可变长度编码，用于将字符映射到二进制编码。

根据字符出现的频率，建立一个哈夫曼树，出现频率高的字符编码短，出现频率低的字符编码长。

编码过程中，根据已建立的哈夫曼树，将字符替换为对应的二进制编码。

译码过程中，根据已建立的哈夫曼树，将二进制编码替换为对应的字符。

三、实验步骤：1.构建一个哈夫曼树，根据字符出现的频率排序。

频率高的字符在左子树，频率低的字符在右子树。

2.根据建立的哈夫曼树，生成字符对应的编码表，包括字符和对应的二进制编码。

3.输入一个字符串，根据编码表将字符串编码为二进制序列。

4.输入一个二进制序列，根据编码表将二进制序列译码为字符串。

5.比较编码前后字符串的内容，确保译码正确性。

四、实验结果：1.构建哈夫曼树：-字符出现频率：A(2)，B(5)，C(1)，D(3)，E(1) -构建的哈夫曼树如下：12/\/\69/\/\3345/\/\/\/\ABCDE2.生成编码表：-A:00-B:01-C:100-D:101-E:1103.编码过程：4.译码过程：5.比较编码前后字符串的内容，结果正确。

五、实验总结：通过本次实验，我了解了哈夫曼编码的原理和应用，并且实现了一个简单的哈夫曼编码的编码和译码器。

在实验过程中，我充分运用了数据结构中的树的知识，构建了一个哈夫曼树，并生成了编码表。

通过编码和译码过程，我进一步巩固了对树的遍历和节点查找的理解。

实验结果表明，本次哈夫曼编码的编码和译码过程正确无误。

在实验的过程中，我发现哈夫曼编码对于频率较高的字符具有较短的编码，从而实现了对字符串的高效压缩。

同时，哈夫曼编码还可以应用于数据传输和存储中，提高数据的传输效率和存储空间的利用率。

通过本次实验，我不仅掌握了哈夫曼编码的编码和译码过程，还深入了解了其实现原理和应用场景，加深了对数据结构和算法的理解和应用能力。

实验五哈夫曼编码与译码的设计与实现

实验五哈夫曼编码与译码的设计与实现一、问题描述利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。

对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。

试为这样的信息收发编写一个哈夫曼码的编/译码系统。

基本要求：（1）接收原始数据：从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件nodedata.dat中。

（2）编码：利用已建好的哈夫曼树（如不在内存，则从文件nodedata.dat 中读入），对文件中的正文进行编码，然后将结果存入文件code.dat中。

（3）译码：利用已建好的哈夫曼树将文件code.dat中的代码进行译码，结果存入文件text中。

（4）打印编码规则：即字符与编码的一一对应关系。

（5）打印哈夫曼树：将已在内存中的哈夫曼树以直观的方式显示在终端上。

二、数据结构设计1、构造哈夫曼树时，使用静态链表作为哈夫曼树的存储。

在构造哈夫曼树时，设计一个结构体数组HuffNode保存哈夫曼树中各结点的信息，根据二叉树的性质可知，具有n个叶子结点的哈夫曼树共有2n-1个结点，所以数组HuffNode的大小设置为2n-1，描述结点的数据类型为：typedef struct{int weight;int parent;int lchild;int rchild;char inf;}HNodeType;2.求哈夫曼编码时使用一维结构数组HuffCode作为哈夫曼编码信息的存储。

求哈夫曼编码实际上就是在已建立的哈夫曼树中，从叶子结点开始，沿结点的双亲链域回退到根结点，每回退一步，就走过了哈夫曼的一个分支，从而得到一位哈夫曼编码值。

由于一个字符的哈夫曼编码就是从根结点到相应叶子结点所经过的路径上各分支所组成的0、1序列，因此先得到的分支代码为所求编码的低位码，后得到的分支代码为所求的高位码。

数据结构实验，哈夫曼编码译码系统

数据结构实验，哈夫曼编码译码系统展开全文1. 实验名称: 二叉树的基本操作及哈夫曼编码译码系统的实现2.实验目的：创建一棵二叉树，实现先序、中序和后序遍历一棵二叉树，计算二叉树结点个数等操作。

哈夫曼编码/译码系统。

3. 实验任务：能成功演示二叉树的有关运算，运算完毕后能成功释放二叉树所有结点占用的系统内存。

4. 实验内容（1）在二叉链表上实现二叉树运算a) 设计递归算法，实现二叉树的基本运算：删除一棵二叉树，求一棵二叉树的高度，求一棵二叉树中叶子结点数，复制一棵二叉树，交换一棵二叉树的左右子树。

b) 设计算法，按自上到下，自左到右的次序，即按层次遍历一棵二叉树。

c) 设计main函数，测试上述每个运算。

d) 提示：队列结构可以辅助进行层次遍历，队列的元素类型是指向二叉树结点的指针类型。

（2）哈夫曼编码和译码系统a) 设计一个菜单可以循环显示B——建树：读入字符集和各字符频度，建立哈夫曼树。

T——遍历：先序和中序遍历二叉树。

E——生成编码：产生每个字符的哈夫曼编码。

C——编码：输入由字符集中字符组成的任意字符串，利用已经生成的哈夫曼编码进行编码，显示编码结果。

D——译码：利用已建成的哈夫曼树进行译码。

X——退出。

b) 提示：修改二叉树结点类BTNode，增加一个指向双亲的parent域，修改二叉树类的函数MakeTree设置该域的值；可以通过遍历哈夫曼树生成每个叶子结点的哈夫曼编码。

5. 概要设计1) 二叉树首先定义结点类BTNode包括对结点的访问，打印，交换结点左右元素等操作。

并将二叉树类BTree声明为友元类。

二叉树类中包含了建树，判断二叉树是否为空，求结点数，求高度，删除，交换左右子树，三种次序遍历及按层次遍历，清空二叉树等函数。

在主函数中调用实现这些功能。

类和类的层次设计主要算法：PreOrder：输出当前结点元素，左右孩子递归调用函数。

InOrder：左孩子递归调用函数，输出当前结点元素，右孩子递归调用。

数据结构哈夫曼编码与译码

数据结构哈夫曼编码与译码哈夫曼编码与译码是数据结构中的重要概念，它是一种可变长度编码的方法，用于压缩数据。

在本文中，我将详细介绍哈夫曼编码与译码的原理、步骤以及应用。

一、哈夫曼编码的原理哈夫曼编码是一种根据字符出现的频率来构建编码表的方法，使得频率较高的字符使用较短的编码，频率较低的字符使用较长的编码。

这样可以有效地减少数据的存储空间。

二、哈夫曼编码的步骤1. 统计字符频率：遍历待编码的文本，统计每个字符出现的频率。

2. 构建哈夫曼树：根据字符频率构建哈夫曼树。

首先将每个字符作为一个独立的树节点，然后合并频率最低的两个节点，生成一个新的节点，频率为这两个节点的频率之和。

重复此过程，直到所有节点都合并为一个根节点，得到哈夫曼树。

3. 生成编码表：从根节点开始遍历哈夫曼树，左子树路径为0，右子树路径为1，将路径上的0和1依次添加到对应字符的编码中，得到编码表。

4. 进行编码：根据编码表，将待编码的文本中的每个字符替换为对应的编码。

5. 完成编码：得到编码后的文本。

三、哈夫曼译码的步骤1. 根据编码表，将编码后的文本逐个字符地进行译码。

从根节点开始，根据字符是0还是1，选择左子树或右子树进行下一步操作。

2. 如果到达叶子节点，则找到对应的字符，并将该字符添加到译码结果中。

3. 重复上述步骤，直到译码结束，得到原始文本。

四、哈夫曼编码与译码的应用哈夫曼编码与译码广泛应用于数据压缩领域。

通过使用哈夫曼编码，可以大大减小数据的存储空间，提高数据传输的效率。

在图像、音频、视频等大数据文件的传输和存储中，哈夫曼编码被广泛使用。

总结：哈夫曼编码与译码是一种基于字符频率的编码方法，可以有效地压缩数据。

通过统计字符频率、构建哈夫曼树、生成编码表等步骤，可以实现对数据的编码和译码。

哈夫曼编码在数据压缩领域有着广泛的应用，可以大大减小数据的存储空间，提高数据传输的效率。

哈夫曼编码译码器系统

哈夫曼编码译码器系统目录(1)一、系统开发的背景 .......................................................................................................(1)二、系统剖析与设计 .......................................................................................................(2)三、系统的设计与实现 ...................................................................................................（一）设计初始化（ Initialization） (2)(3)（二）设计编码（ Encoding ） .......................................................................................(3)（三）设计译码（ Decoding ） .......................................................................................（四）设计印代码文件（ Print） (4)（五）设计印哈夫曼树（ TreePrinting） (4)(5)四、系统测试 ...................................................................................................................(5)（一）测试 main 函数 .....................................................................................................（二）测试编码（ Encoding ）及译码（ Decoding ）函数 (5)（三）测试印代码文件（ Print）函数 (6)(6)（四）测试有关的根目录 ................................................................................................(6)五、总结 ............................................................................................................................(7)六、附件（代码、部分图表） ........................................................................................哈夫曼编 / 译码器系统一、系统开发的背景为了提升信道利用率，缩短信息传输时间，降低传输成本，且在信息发送端经过一个编码系统对待传数据早先编码，在信息接收端将传来的数据进行译码（还原），所以设计哈夫曼编码/ 译码器系统。

数据结构课程设计哈夫曼编码译码器

题目一: 哈夫曼编码与译码一、任务设计一个运用哈夫曼算法的编码和译码系统, 反复地显示并解决以下项目, 直到选择退出为止。

规定：1) 将权值数据存放在数据文献(文献名为data.txt, 位于执行程序的当前目录中) ；2) 初始化：键盘输入字符集记录字符权值、自定义26个字符和26个权值、记录文献中一篇英文文章中26个字母, 建立哈夫曼树；3) 编码: 运用建好的哈夫曼树生成哈夫曼编码；4) 输出编码（一方面实现屏幕输出, 然后实现文献输出）；5）译码（键盘接受编码进行译码、文献读入编码进行译码）；6) 界面优化设计。

二、流程图三、代码分解 //头文献 #include<stdio.h> #include<string.h> #include<stdlib.h> #include <conio.h> #define N 1000 #define M 2*N-1 #define MAXcode 6000 //函数声明void count(CHar &ch,HTNode ht[]);void editHCode(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); //编码函数void printyima(HTNode ht[],HCode hcd[],int n,char bianma[]); //译码函数 void creatHT(HTNode ht[],int n);字符集记录符集记录权值权值至文献“哈夫曼树。

t xt” 菜单1.从键盘输入字符集进行编码2.从文献读入字符集进行编码1.从键盘输入编码进行译码2.从文献读入编码进行译码0.返回上级菜单 0.返回上级菜单void CreateHCode (HTNode ht[],HCode hcd[],int n);void DispHCode(HTNode ht[],HCode hcd[],int n);void input_key(CHar &ch);void input_file(CHar &ch);void input_cw(HTNode ht[]);void bianma1(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); void bianma2(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]); void yima1(HTNode ht[],HCode hcd[],int n,char bianma[]);void yima2(HTNode ht[],HCode hcd[],int n,char bianma[]);void creat_cw();void bianmacaidan();void yimacaidan();void bianmayima();int caidan();//结构体typedef struct{char data;int parent;int weight;int lchild;int rchild;}HTNode;typedef struct{char cd[N];int start;}HCode;typedef struct{char s[N];int num;}CHar;CHar ch;HTNode ht[M];HCode hcd[N];//主函数int main(){int xh;while(1){system("color 1f"); //操作菜单背景颜色 xh=caidan(); //调用菜单函数switch(xh) //switch语句 {case 1:system("cls");creat_cw();break;case 2:system("cls");creatHT(ht,n);break;case 3:system("cls");CreateHCode(ht,hcd,n);DispHCode(ht,hcd,n);break;case 4:system("cls");bianmayima();break;case 0:system("cls");printf("\n\n\n\n\n\n\n\n\n\t\t\t\t感谢使用本系统!\n\n\n\n\n\n\n \t\t\t");exit(0);default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}return 0;}//菜单函数int caidan() //菜单函数模块//{int xh;printf("\n\n\n");printf("\t\t 欢迎使用哈夫曼编码译码系统\n");printf("\t\t \n");printf("\t\t*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n");printf("\t\t*= =*\n");printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n");printf("\t\t*= 1.建立字符权值=*\n");printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 2.建立并输出哈夫曼树=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 3.生成并查看哈夫曼编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 4.编码与译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*= =*\n"); printf("\t\t*= 0.退出系统=*\n"); printf("\t\t*= =*\n"); printf("\t\t*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d", &xh);return xh; //返回从键盘接受的选项}void bianmayima(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 编码与译码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n");printf("\t\t*= 1.编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");bianmacaidan();break;case 2:system("cls");yimacaidan();break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void yimacaidan(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 译码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.键盘输入编码进行译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.文献读入编码进行译码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");yima1(ht,hcd,n,bianma);break;case 2:system("cls");yima2(ht,hcd,n,bianma);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void bianmacaidan(){int xh;while(1){printf("\n\n\n\n\n");printf("\t\t 编码\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.键盘输入字符集编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.文献读入文章编码=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh);switch(xh) //switch语句{case 1:system("cls");bianma1(ht,hcd,ch,n,bianma);break;case 2:system("cls");bianma2(ht,hcd,ch,n,bianma);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}void creat_cw(){int xh2;while(1){printf("\n\n\n\n\n");printf("\t\t 建立字符权值\n"); printf("\t\t \n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 1.从键盘输入字符集进行记录=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 2.从文献读入字符集记录=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 3.自定义字符权值=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\t\t*= 0.返回上级菜单=*\n"); printf("\t\t*= *=*=*=*=*=*=*=*=*=*=*=*=*=*=* =*\n"); printf("\n\t\t请输入序号进行选择:");scanf("%d",&xh2);switch(xh2) //switch语句{case 1:system("cls");input_key(ch);break;case 2:system("cls");input_file(ch);break;case 3:system("cls");input_cw(ht);break;case 0:system("cls");return;default:system("cls");putchar('\a');printf("\n\t\t输入有误, 请重新输入:\n");break;}}}//建立字符权值模块void input_key(CHar &ch){int i,j=0;char st[N];printf("请输入字符集（以‘#’结束）:\n");for(i=0;i<N;i++){scanf("%c",&st[i]);if(st[i]=='#'){st[i]='\0';break;}}strcpy(ch.s,st);count(ch,ht);printf("按任意键返回!");getch();system("cls");return;}void input_file(CHar &ch){int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&ch.s[i],sizeof(char),1,fp);}printf("读入成功!\n");printf("文献中的字符集为:%s\n",ch.s);fclose(fp);count(ch,ht);printf("按任意键返回!");getch();system("cls");return;}void input_cw(HTNode ht[]){int i,w,s,j;char a;printf("要输入的字符总个数是？:");scanf("%d",&s);n=s;printf("请输入字符及其权值:\n");for(i=0;i<s;i++){printf("请输入第%d个字母:",i+1);scanf("%s",&a);ht[i].data=a;printf("请输入其权值:");scanf("%d",&w);ht[i].weight=w;}FILE *fp;if((fp=fopen("data.txt","w"))==0){printf("\n\t\t文献打开失败");return;}printf("\n定义权值成功!\n\n");printf("各字符及其权值为:\n\n");fprintf(fp,"各字符及其权值为:\n");printf(" 字符\t权值");fprintf(fp," 字符\t权值");for(j=0;j<i;j++){ printf("\n");fprintf(fp,"\n");printf(" %-8c%-8d",ht[j].data,ht[j].weight);fprintf(fp," %-8c%-8d%",ht[j].data,ht[j].weight); }printf("\n");printf("\n字符权值已输出至文献“data.txt”！");fclose(fp);printf("输入完毕, 按任意键返回！");getch();system("cls");return;}//记录字符权值函数void count(CHar &ch,HTNode ht[]){int i,j,m=0;char c[N];int sum[N]={0};for(i=0;ch.s[i]!='\0';i++){for(j=0;j<m;j++)if(ch.s[i]==c[j]||(c[j]>='a'&&c[j]<='z'&&ch.s[i]+32==c[j])) break;if(j<m)sum[j]++;else{if(ch.s[i]>='A'&&ch.s[i]<='Z')c[j]=ch.s[i]+32;else c[j]=ch.s[i];sum[j]++;m++;}}for(i=0;i<m;i++){ht[i].data=c[i];ht[i].weight=sum[i];}n=m;FILE *fp;if((fp=fopen("data.txt","w"))==0) {printf("\n\t\t文献打开失败"); return;}printf("\n记录权值成功!\n\n"); printf("各字符及其权值为:\n\n"); fprintf(fp,"各字符及其权值为:\n"); printf(" 字符\t权值");fprintf(fp," 字符\t权值");for(j=0;j<m;j++){ printf("\n");fprintf(fp,"\n");printf(" %-8c%-8d",ht[j].data,ht[j].weight);fprintf(fp," %-8c%-8d%",ht[j].data,ht[j].weight);}printf("\n");printf("\n字符权值已输出至文献“data.txt”！");fclose(fp);}//构造哈夫曼树void creatHT(HTNode ht[],int n){FILE *fp;if((fp=fopen("哈夫曼树.txt","w"))==0){printf("\n\t\t文献打开失败");return;}int i,j,k,lnode,rnode;int min1,min2;for (i=0;i<2*n-1;i++)ht[i].parent=ht[i].lchild=ht[i].rchild=-1;for (i=n;i<2*n-1;i++){min1=min2=32767;lnode=rnode=-1;for(k=0;k<=i-1;k++)if(ht[k].parent==-1){if (ht[k].weight<min1){min2=min1;rnode=lnode;min1=ht[k].weight;lnode=k;}else if(ht[k].weight<min2){min2=ht[k].weight;rnode=k;}}ht[lnode].parent=i;ht[rnode].parent=i;ht[i].weight=ht[lnode].weight+ht[rnode].weight;ht[i].lchild=lnode;ht[i].rchild=rnode;}printf("建立huffman树成功!\n");printf("输出huffman树:\n");fprintf(fp,"输出huffman树:\n");printf("\t字符\t权值\t父节点\t 左子节点\t右子节点");fprintf(fp,"\t字符\t权值\t父节点\t 左子节点\t右子节点");for(j=1;j<i;j++){ printf("\n");fprintf(fp,"\n");printf("\t %-8c%-8d%-10d%-14d%-10d",ht[j].data,ht[j].weight,ht[j].parent,ht[i]. lchild,ht[j].rchild);fprintf(fp,"\t %-8c%-8d%-10d%-14d%-10d",ht[j].data,ht[j].weight,ht[j].parent,h t[i].lchild,ht[j].rchild);}printf("\n");printf("哈夫曼树已输出至文献“哈夫曼树.txt”！按任意键返回!");fclose(fp);getch();system("cls");return;}//生成哈夫曼编码void CreateHCode (HTNode ht[],HCode hcd[],int n){int i,f,c,j=0;HCode hc;for(i=0;i<n;i++){hc.start=n;c=i;hc.cd[hc.start--]='0';f=ht[i].parent;while(f!=-1){if (ht[f].lchild==c)hc.cd[hc.start--]='0';elsehc.cd[hc.start--]='1';c=f;f=ht[f].parent;}hc.start++;for(j=0;j<hc.start;j++)hc.cd[j]=' ';hcd[i]=hc;}}void DispHCode(HTNode ht[],HCode hcd[],int n) {FILE *fp;if((fp=fopen("哈夫曼编码.txt","w"))==0){printf("\n\t\t文献打开失败");return;}int i,k;int sum=0,m=0,j;printf("输出字符哈夫曼编码:\n"); fputs("输出字符哈夫曼编码:\n",fp); for (i=0;i<n;i++){j=0;printf("%c:\t",ht[i].data);fprintf(fp,"\n%c:\t",ht[i].data);for (k=hcd[i].start;k<=n;k++){printf("%c",hcd[i].cd[k]);j++;fprintf(fp,"%c",hcd[i].cd[k]); }m+=ht[i].weight;sum+=ht[i].weight*j;printf("\n");}printf("\n哈夫曼编码已保存至文献“哈夫曼编码.txt!按任意键返回！”");fclose(fp);getch();system("cls");}//编码函数void bianma1(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]){int i;char str[N];printf("请输入要编码的字符集（以‘#’结束）:\n");for(i=0;i<N;i++){scanf("%c",&str[i]);if(str[i]=='#'){str[i]='\0';break;}}strcpy(ch.s,str);ch.num=strlen(str);editHCode(ht,hcd,ch,n,bianma);getch();system("cls");}void bianma2(HTNode ht[],HCode hcd[],CHar &ch,int n,char bianma[]) {int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&ch.s[i],sizeof(char),1,fp);}ch.num=strlen(ch.s);printf("\n读入成功!\n");printf("文献中的字符集为:\n%s",ch.s);fclose(fp);editHCode(ht,hcd,ch,n,bianma);system("cls");return;}//译码函数void yima1(HTNode ht[],HCode hcd[],int n,char bianma[]) {int i;char code[MAXcode];printf("请输入编码进行译码（以‘#’结束）:\n");for(i=0;i<MAXcode;i++){scanf("%c",&code[i]);if(code[i]=='#'){code[i]='\0';break;}}strcpy(bianma,code);printyima(ht,hcd,n,bianma);printf("\n译码完毕！按任意键返回!");getch();system("cls");return;}void yima2(HTNode ht[],HCode hcd[],int n,char bianma[]) {int i;FILE*fp;char filename[20];printf("请输入要打开的文献名(*.txt):");scanf("%s",&filename);if((fp=fopen(filename,"r"))==NULL){printf("\n\t\t文献打开失败");return;}for(i=0;!feof(fp);i++){fread(&bianma[i],sizeof(char),1,fp);}printf("读入成功!\n");printf("文献中的编码是:%s\n",bianma);printyima(ht,hcd,n,bianma);printf("\n译码完毕！按任意键返回!");getch();system("cls");}四、调试结果主菜单建立字符权值选择2.从文献读入字符进行记录输入测试文献名“cs.txt”输出个字符权值建立哈夫曼树并输出至文献生成哈夫曼编码并保存至文献编码选择2.从文献读入字符集编码编码结果保存至文献译码选择2.从文献读入编码, 读入上一步的编码译码完毕, 返回！退出系统。

哈夫曼编码译码系统(树应用)

实验三哈夫曼编码/译码系统（树应用）一、实验目的1. 帮助读者复习C++语言程序设计中的知识。

2.哈夫曼树的建立，哈夫曼编码的生成，对编码信息的翻译的熟悉和运用。

[需求分析]利用哈夫曼编码进行通信，可以压缩通信的数据量，提高传输效率，缩短信息的传输时间，还有一定的保密性。

现在要求编写一程序模拟传输过程，实现在发送前将要发送的字符信息进行编码，然后进行发送，接收后将传来的数据进行译码，即将信息还原成发送前的字符信息。

二、实验内容和要求[问题要求]利用哈夫曼编码进行通信，可以压缩通信的数据量，提高传输效率，缩短信息的传输时间，还有一定的保密性。

[问题分析]在本例中设置发送者和接受者两个功能，发送者的功能包括：输入待传送的字符信息；统计字符信息中出现的字符种类数和各字符出现的次数（频率）；根据字符的种类数和各自出现的次数建立哈夫曼树；利用以上哈夫曼树求出各字符的哈夫曼编码；将字符信息转换成对应的编码信息进行传送。

接受者的功能包括：接收发送者传送来的编码信息；利用上述哈夫曼树对编码信息进行翻译，即将编码信息还原成发送前的字符信息。

本实验首先从文件中读取数据，然后分析数据对不同的元素依次存入一字符数组并统计其出现的次数并当做其权值，然后根据这些信息建立哈弗曼树，并对各个字符进行哈弗曼编码然后根据各个字符的编码对所有输入的一组字符进行哈弗曼编码。

译码是根据哈弗曼树和接收到的一组编码进行译码操作。

译码也就是对哈弗曼树的遍历三、算法设计首先读入一组字符，然后统计这些字符中不同字符出现的次数，并当做其权值，然后根据不同字符及其权值建立哈弗曼树。

建立哈弗曼树后即可得到这些不同字符的哈弗曼编码，然后即可根据这些哈弗曼编码对那组输入的一串字符进行哈弗曼编码。

译码是根据一组编码翻译成一组字符的操作，其算法就是根据这一串编码来对哈弗曼树进行遍历，每遍历到一个叶子结点即输出一个字符，直至将编码操作完即可完成多编码的翻译操作。

分析方案哈夫曼编译码系统与实现

数据结构实验报告实验题目：理解哈夫曼树的特征及其应用；在对哈夫曼树进行理解的基础上，构造哈夫曼树，并用构造的哈夫曼树进行编码和译码；通过该实验,对数据结构的应用有更深层次的理解。

实验要求：1．问题描述：利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码<复原）。

对于双工信道<即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。

试为这样的信息收发站设计一个哈夫曼编/译码系统。

2．一个完整的系统应具有以下功能：1）初始化<Initialzation）。

从数据文件DataFile.dat中读入字符及每个字符的权值，建立哈夫曼树HuffTree；2）编码<EnCoding）。

用已建好的哈夫曼树,对文件ToBeTran.dat中的文本进行编码形成报文，将报文写在文件Code.txt中；3）译码<Decoding）。

利用已建好的哈夫曼树，对文件CodeFile.dat中的代码进行译码形成原文，结果存入文件Textfile.txt中；4）输出<Output）:输出ToBeTran.dat及其报文Code.txt；输出CodeFile.dat及其原文Textfile.txt；[备注]：1）数据文件DataFile.dat中，元素类型为<字符，权值） , DataFile.dat的建立可以根据用户输入的一段原文，通过统计出现的字符及各字符出现的次数<与出现的概率作用相同）而得到。

另：为了使输出的哈夫曼树不太大，规定报文中只能出现A-H的8个字符，当然对程序稍加修改就可以对出现的所有可输和字符进行处理。

2）ToBeTran.dat中的内容由用户在程序执行时从键盘随机输入得到；3）CodeFile.dat中的内容由用户在程序执行时从键盘随机输入得到；DataFile.dat、ToBeTran.dat、CodeFile.dat在程序运行时建立是为了保证编/译码系统的通用性；三．总的设计思想，及环境语言、工具等总的设计思想：1．根据实验要求，先创建文件DataFile.dat、ToBeTran.dat和CodeFile.dat；用下面三个函数实现；void creatDataFile( >； //创建数据文件void creatToBeTran( >；//创建原文文件void creatCodeFile( >；//创建报文文件2.从文件DataFile.dat中读出各字符及相应的权值，创建哈夫曼树HT；3.根据构造的哈夫曼树，求相应字符的哈夫曼编码；4．从文件ToBeTran.dat中读出要翻译的原文，将其翻译成译文存入文件Code.txt中5．从文件CodeFile.dat中读出要翻译的报文，将其翻译成原文存入文件Textfile.txt中环境语言：Windows下的Microsoft VC++四、数据结构与模块说明下面是编译码系统中所用的数据结构。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

题目：哈夫曼编码和译码系统院系：专业：姓名：学号：指导教师：日期：实训报告目录一、前言 (1)二、需求分析 (1)1.问题描述 (1)2.基本要求 (1)3.根据需求，该系统应具备以下功能......................2.三、概要设计 (2)1.哈夫曼编码和译码的方法概述 (2)2.流程图 (3)四、详细设计 (4)1.用类来定义变量和函数 (4)2.构造哈夫曼树 (5)3.根据哈夫曼树进行哈夫曼编码 (6)4.输出对应的哈夫曼编码表 (7)5.对输入的字符进行编码 (8)6.对输入的编码进行译码 (9)7.主函数 (10)五、调试分析 (13)六、实验总结 (16)一、前言在这个信息高速发展的时代，每时每刻都进行着大量的信息传递，到处都离不开信息，它贯穿在人们日常的生活之中，对人们产生的影响日趋扩大，而利用哈夫曼码进行通信则可以大大提高信道利用率，缩短通信传输时间，降低传输成本。

在生产中则可以更大可能的降低成本从而获得更大里润，这也是信息时代发展的趋势所在。

本次实训设计的是哈夫曼编码和译码系统，建立一个简易的系统，对于给定的一篇英文文章，统计字符出现的概率，并根据概率建立Huffman树，利用Huffman 编码对文章进行编码和译码。

掌握Huffman树的建立与应用，并进一步熟练掌握程序的设计流程。

这是个拥有完整功能的系统程序，对将所学到的知识运用到实践中，在设计的同时，培养了学生各方面的能力。

二、需求分析1.问题描述在传送电文时，人们总是希望传送时间尽可能短，这就是要求使电文代码长度尽可能短。

利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

但是，这要求在发送端通过一个编码系统能够对待传输数据预先编码，在接收端将传来的数据进行译码，所以为这样的信息收发站写一个哈夫曼的编译码系统。

2.基本要求输入一段英文原文，构造哈夫曼树，生成对应的编码表，输出原文对应的编码，或者是根据已生成的编码表，输入一段二进制数编码，得到对应的字符原文。

3.根据需求，该系统应具备以下功能对给出的字符以及字符的权值构造哈夫曼树，生成对应的编码表输入一段原文，对原文进行编码输入二进制编码，输出对应的原文三、概要设计1.哈夫曼编码和译码的方法概述初始化，每个字符就是一个结点，对应节点的权值大小，选取权值最小的两个结点，以它们为儿子，构造出一个新的结点；新结点的权值就是它两个儿子的权值之和；构造之后，从原来的结点序列里删除刚才选出的那两个结点，但同时将新生成的结点加进去；如果结点序列里只剩下一个结点，表示构造完毕，退出。

否则回到第一步。

对某个结点而言，其左孩子在当前阶段的编码为0，右孩子的编码为1，这样就可以通过遍历树来生成字符一一对应的编码表来到这里，基本上艰苦的已经完成了，对某个具体的字符串编码和解码就只是简单的“查表——替换”的工作了。

译码：译码也是个简单的查表--替换过程。

如果利用该种编码发送字符串，则它的“字符——编码”对应表也必须发送过去，然后对给出的一串编码，从左向右，将编码组合起来并查表，一旦找到有匹配的字符，则将当前的编码替换为对应的字符。

因为该编码是不会出现”某一个字符的编码是另一个字符编码的缀”这种情况的，也就是不会出现类似于“A 为00而 B 为0010”这样的情况，所以译码出来的字符串是唯一的，而且就是原来进行编码的那一个。

2.流程图四、详细设计1.用类来定义变量和函数class Node //节点类{public:friend Hafuman;char data; //结点值int weight; //权值int parent; //双亲结点int lchild; //左孩子结点int rchild; //右孩子结点void CreateHT(Node ht[], int n);void CreateHCode(Node ht[], Hafuman hcd[], int n);};class Hafuman{public:friend Node;char cd[N]; //存放哈夫曼码int start; //从start开始读cd中的哈夫曼码void DispHCode(Node ht[], Hafuman hcd[], int n);void editHCode(Node ht[], Hafuman hcd[], int n);void deHCode(Node ht[], Hafuman hcd[], int n);};2.构造哈夫曼树void Node::CreateHT( Node ht[], int n) {int i, k, lnode, rnode;int min1, min2;for (i = 0; i<2 * n - 1; i++)ht[i].parent = ht[i].lchild = ht[i].rchild = -1; //所有结点的相关域置初值-1for (i = n; i<2 * n - 1; i++) //构造哈夫曼树{min1 = min2 = 32767; //int的围是-32768—32767lnode = rnode = -1； //记录最小权值的两个结点位置for (k = 0; k <= i - 1; k++){if (ht[k].parent == -1) //只在尚未构造二叉树的结点中查找{if (ht[k].weight<min1) //若权值小于最小的左节点的权值{min2 = min1; rnode = lnode;min1 = ht[k].weight; lnode = k;}else if (ht[k].weight<min2){min2 = ht[k].weight; rnode = k;}}}ht[lnode].parent = i; ht[rnode].parent = i; //两个最小节点的父节点是iht[i].weight = ht[lnode].weight + ht[rnode].weight;//两个最小节点的父节点权值为两个最小节点权值之和ht[i].lchild = lnode; ht[i].rchild = rnode; //父节点的左节点和右节点}}3.根据哈夫曼树进行哈夫曼编码void Node::CreateHCode(Node ht[], Hafuman hcd[], int n){int i, f, c;Hafuman hc;for (i = 0; i<n; i++) //根据哈夫曼树求哈夫曼编码{hc.start = n; c = i;f = ht[i].parent;while (f != -1) //循序直到树根结点结束循环{if (ht[f].lchild == c) //处理左孩子结点hc.cd[hc.start--] = '0';else //处理右孩子结点hc.cd[hc.start--] = '1';c = f; f = ht[f].parent;}hc.start++; //start指向哈夫曼编码hc.cd[]中最开始字符hcd[i] = hc;}}4.输出对应的哈夫曼编码表void Hafuman::DispHCode(Node ht[], Hafuman hcd[], int n) {int i, k;cout << " 输出哈夫曼编码:\n";for (i = 0; i<n; i++) //输出data中的所有数据，即A-Z{ cout<<"\t"<<ht[i].data<<":";for (k = hcd[i].start;k<=n; k++)//输出所有data中数据的编码{ cout<< hcd[i].cd[k];}cout<<"\n";}}5.对输入的字符进行编码void Hafuman::editHCode(Node ht[], Hafuman hcd[], int n) { char string[MAXSIZE];int i, j, k;cin>> string; //把要进行编码的字符串存入string数组中cout<<"\n输出编码结果:\n";for (i = 0; string[i] != '#'; i++) //#为终止标志{for (j = 0; j<n; j++){if (string[i] == ht[j].data || string[i] == ht[j].data+32)//循环查找与输入字符相同的编号，相同的就输出这个字符的编码{for (k = hcd[j].start; k <= n; k++){cout<< hcd[j].cd[k];}break; //输出完成后跳出当前for循环}}}}6.对输入的编码进行译码void Hafuman::deHCode(Node ht[], Hafuman hcd[], int n) //译码函数{char code[MAXSIZE];int i, j, k, m, x,Knum = 50;cin>> code; //把要进行译码的字符串存入code数组中while (code[0] != '#')for (i = 0; i<n; i++){m = 0; //m为想同编码个数的计数器for (k = hcd[i].start,j=0;k<=n;k++,j++) //j为记录所存储这个字符的编码个数if (code[j] == hcd[i].cd[k]) //当有相同编码时m值加1 m++;}if (m == j) //当输入的字符串与所存储的编码字符串个数相等时则输出这个的data数据{cout<< ht[i].data;for (x = 0; code[x - 1] != '#'; x++) //把已经使用过的code数组里的字符串删除{code[x] = code[x + j];}}Knum--;if (Knum < 1) { code[0] = '#';}}}7.主函数void main(){int n = 26, i;int x, flag = 1;Node a; Hafuman b;Charstr[]={ 'A','B','C','D','E','F','G','H','I','J','K','L','M','N ','O','P','Q','R','S','T','U','V','W','X','Y','Z' };//初始化Int fnum[]= { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20, 21,22,23,24,25,26 }; //初始化Node ht[M];Hafuman hcd[N];for (i = 0; i<n; i++) //把初始化的数据存入ht结构体中{ht[i].data = str[i];ht[i].weight = fnum[i];}while (flag) //菜单函数，当flag为0时跳出循环{cout<<"\n";cout<<"\n*************************************************";cout<<"\n ** 1--------------显示编码-----------1 **";cout<<"\n ** 2--------------进行编码-----------2 **";cout<<"\n ** 3--------------进行译码-----------3 **";cout<<"\n ** 4----------------退出-------------4 **";cout<<"\n*************************************************";cout<<"\n";cout<<"请输入选择的编号:";cin >>x;switch (x){case 1:system("cls"); //清屏函数a.CreateHT(ht, n);a.CreateHCode(ht, hcd, n);b.DispHCode(ht, hcd, n);cout<<"\n按任意键返回...";_getch();system("cls");break;case 2:system("cls");cout<<"请输入要进行编码的字符串(以#结束):\n";b.editHCode(ht, hcd, n);cout<<"\n按任意键返回...";_getch();system("cls");break;case 3:system("cls");b.DispHCode(ht, hcd, n);cout<<"请输入编码(以#结束):\n";b.deHCode(ht, hcd, n);cout<<"\n按任意键返回...";_getch();system("cls");break;case 4:flag = 0;break;default:system("cls");}}}五、调试分析一般情况下，为解决一个问题所编写的程序代码较长，可能包括几百条甚至成千上万条语句。