哈夫曼实验报告材料附代码.docx
《哈夫曼实验报告材料附代码.docx》由会员分享，可在线阅读，更多相关《哈夫曼实验报告材料附代码.docx（24页珍藏版）》请在冰豆网上搜索。
哈夫曼实验报告材料附代码
哈弗曼编码/译码器
一、程序的功能分析
1．构造哈夫曼树及哈夫曼编码：
从终端读入字符集大小n、n个字符以及n个对应的权值，建立哈夫曼树；利用已经建好的哈夫曼树求每个叶结点的哈夫曼编码，并保存。
2．编码：
利用已构造的哈夫曼编码对“明文”文件中的正文进行编码，然后将结果存入“密文”文件中。
3．译码：
将“密文”文件中的0、1代码序列进行译码。
（读文件）
4．打印“密文”文件：
将文件以紧凑格式显示在终端上，每行30个代码；同时，将此字符形式的编码文件保存。
5．打印哈夫曼树及哈夫曼编码：
将已在存中的哈夫曼树以凹入表形式显示在终端上，同时将每个字符的哈夫曼编码显示出来；并保存到文件。
二、基本要求分析
1、输入输出的要求
按提示容从键盘输入命令，系统根据用户输入的需求在保证界面友好的前提下输出用户所需信息，并按要求保存文件，以便保存备份信息。
2、测试数据
（1）．令叶子结点个数N为4，权值集合为{1,3,5,7}，字符集合为{A,B,C,D}，且字符集与权值集合一一对应。
（2）．令叶子结点个数N为7，权值集合为{12,6,8,18,3,20,2}，字符集合为{A,B,C,D,E,F,G}，且字符集与权值集合一一对应。
（3）．请自行选定一段英文文本，统计给出的字符集，实际统计字符的频度，建立哈夫曼树，构造哈夫曼编码，并实现其编码和译码。
三、概要设计
1.主模块的流程及各子模块的主要功能
主函数负责提供选项功能，循环调控整个系统。
创建模块实现接收字符、权值、构建哈夫曼树，并保存文件，此功能是后续功能的基础。
编码模块实现利用已编好的哈夫曼树对每个字符进行哈夫曼编码，即对每个字符译出其密文代码，并保存文件。
译码模块实现对用户输入的密文翻译成明文，即用户所需的字符串信息。
输出模块实现对已编好的哈夫曼树以凹入表的的形式输出。
2、模块之间的层次关系
主函数
四、详细设计
1.采用c语言定义的相关数据类型
（1）结点的类型定义描述如下：
#defineN叶子结点的个数
typedefstrcut
{intweight;/*结点权值*/
intparent;
intlchild;
intrchild;
}HNodeType;
HNodeTypeHNode[2*N-1];
（2）编码的类型定义描述如下：
#defineMAXBIT10
typedefstruct
{intbit[MAXBIT];
intstart;
}HCodeType;
HCodeTypeHCode[N];
2.各模块伪算法
（1）主函数
intmain（）
{
do:
{
界面友好设计;
cout<<各个选项功能容;
cin>>ch;
容错处理;
switch（ch）
{
case1:
.....
}
}while（）;
return0;
}
（2）系统初始化模块
voidcreate（）//系统初始化
{
for（i=0;i<2*N-1;i++）//数组HNode初始化
{};
从键盘接收字符;
for（i=0;i{cout<<"输入字符"<cin>>HNode[i].data;
}
接收权值;
构造哈夫曼树;
for（i=0;i{找最小和次小两个权值；
将找出的两棵子树合并为一棵子数；
}
将已建好的哈夫曼树存入文件hfmtree.txt中;
调用哈夫曼编码子函数；
}
voidHaffmanCode（）//对哈夫曼树进行编码
{
从hfmtree.txt文件中读出哈夫曼树的信息存入存HNodeTypea[2*N-1]；
求每个叶子结点的哈夫曼编码；
for（i=0;i{
从叶节点回溯，回溯到根结点（parent==-1）;
记录回溯路径；
}
打印出每个字符对应的密文；
将密文信息存入文件codefile.dat中；
}
（3）编码模块
voidHfmanCode（）//对用户输入的字符串进行编码
{
提示输入信息；
接收用户输入的要编译的字符串；
cin>>s;
//从文件中读取哈夫曼编码信息
infile.open（"F:
\\codefile.dat",ios:
:
in|ios:
:
binary）;//读文件
for（i=0;i//从文件中读字节到指定的存储器区域。
infile.read（（char*）&temp[i],sizeof（temp[i]））;
循环实现将用户输入的字符串转换成对应的密文，并保存；
将保存结果存入密文文件；
}
（4）译码模块
（5）输出模块
五、调试分析
1.调试过程中遇到的问题和对问题的解决方法
对文件的读写操作不熟悉，调试时，将已写入的文件不能读出，以至于后续操作无法实现，对此，我有翻看C++程序设计课本，了解关于文件操作的具体容，明白二进制文件和文本文件的读写方式是有很大区别的，不可混淆操作。
另外，对于程序的输出阶段开始时出现了问题，递归调用没有分析清楚，递归思想是层次分明，逐层深入。
2.算法的时间复杂度
（1）创建模块O（N^3）
（2）编码模块O（N）
（3）译码模块O（n）其中n为用户输入的密文位数
（4）打印模块O（N）
六、使用说明及测试结果
用户根据提示信息，初次使用本系统时要首先选择创建选项来初始化系统，根据提示信息输入信息，存入文件，使得后续功能顺利实现。
非初次使用时，用户可根据自己的需求来选择功能选项，根据提示信息输入、获得所需信息。
测试：
1.令叶子结点个数N为4，权值集合为{1,3,5,7}，字符集合为{A,B,C,D}，且字符集与权值集合一一对应。
2．令叶子结点个数N为7，权值集合为{12,6,8,18,3,20,2}，字符集合为{A,B,C,D,E,F,G}，且字符集与权值集合一一对应。
3．自行选定一段英文文本，统计给出的字符集，实际统计字符的频度，建立哈夫曼树，构造哈夫曼编码，并实现其编码和译码。
字符串：
whilwitchhiwwppppp频率统计为
w
h
i
l
c
t
p
4
3
3
1
1
1
5
4.可实现多个编码文件共存以及容错处理
七、程序代码
#include
#include
#include
#include
#defineN7//叶子结点的个数
#defineMAXBIT50//编码位数
#defineMaxvalue100//定义最大权值整数常量
//结点的类型定义描述如下：
typedefstruct
{
chardata;
intweight;/*结点权值*/
intparent;
intlchild;
intrchild;
}HNodeType;
HNodeTypeHNode[2*N-1];
//编码类型描述如下：
typedefstruct
{intbit[MAXBIT];
intstart;
chars;
}HCodeType;
HCodeTypeHCode[N];
//密文格式类型
typedefstruct
{
intcode[MAXBIT];
intnum;
}CD;
voidcreate（）;
voidHaffmanCode（）;
voidprint（）;
voidprint_t（HNodeTypetemp[],HNodeTypeT,inth）;
voidtranslate（）;
voidHfmanCode（）;
charname[50][30];//用来记录用户输入的密文文件
intfilenum=0;
inttextnum=0;
intmain（）
{
charch;
inth=1;
HNodeType*pNode;
pNode=HNode;
do{
cout<cout<--------------"<cout<初始化编译系统"<编码"<译码"<打印哈弗曼树"<退出"<cout<cout<<"请选择（0~5）：
";
cin>>ch;
while（!
（ch<='5'&&ch>='0'））/*输入不在0到5之间无效*/
{
cout<<"数据输入错误，请重新选择（0~7）：
";
cin>>ch;
}
switch（ch）
{
case'1':
create（）;break;//系统初始化，构造哈夫曼树
case'2':
HfmanCode（）;break;//对哈夫曼树进行编码
case'3':
translate（）;break;//译码
case'4':
print（）;//将哈夫曼树以凹入表的形式输出
case'5':
break;
}
}while（ch!
='5'）;
return0;
}
voidcreate（）//模块一，系统初始化
{
fstreamoutfile;
inti,j;
intm1,m2,x1,x2;
for（i=0;i<2*N-1;i++）//数组HNode初始化
{
HNode[i].data='\0';
HNode[i].weight=0;
HNode[i].parent=-1;
HNode[i].lchild=-1;
HNode[i].rchild=-1;
}
cout<<"分别输入"<"<for（i=0;i{
cout<<"输入字符"<cin>>HNode[i].data;
}
cout<<"分别输入"<"<for（i=0;i{
cout<<"输入权值"<cin>>HNode[i].weight;
}
for（i=0;i{
m1=m2=Maxvalue;
x1=x2=0;
for（j=0;j{
if（HNode[j].parent==-1&&HNode[j].weight{
m2=m1;
x2=x1;
m1=HNode[j].weight;
x1=j;
}
else
if（HNode[j].parent==-1&&HNode[j].weight{
m2=HNode[j].weight;
x2=j;
}
}
//将找出的两棵子树合并为一棵子数
HNode[x1].parent=N+i;
HNode[x2].parent=N+i;
HNode[N+i].weight=HNode[x1].weight+HNode[x2].weight;
HNode[N+i].lchild=x1;
HNode[N+i].rchild=x2;
}
outfile.open（"F:
\\hfmtree.txt",ios:
:
out|ios:
:
binary）;//建立进行写入的文件
if（!
outfile）//没有创建成功则显示相应信息
{
cout<<"hfmtree.txt文件不能打开"<return;
}
//将存中从HNode[i]地址开始的sizeof（HNode[i]）的容写入文件中
for（i=0;i<2*N-1;i++）
{
outfile.write（（char*）&HNode[i],sizeof（HNode[i]））;
}
cout<<"哈夫曼树信息已存入文件hfmtree.tet中."<outfile.close（）;//关闭文件
HaffmanCode（）;//调用函数对哈夫曼树进行编码
}
voidHaffmanCode（）//对哈夫曼树进行编码
{
fstreamoutfile,infile;
inti,j,c,p;
HCodeTypecd;
HNodeTypea[2*N-1];
infile.open（"F:
\\hfmtree.txt",ios:
:
in|ios:
:
binary）;
if（!
infile）
{
cout<<"hfmtree.dat文件不能打开"<return;
}
else
{
for（i=0;i<2*N-1;i++）//将文件中的数据读出放在a[i]
//从文件中读字节到指定的存储器区域。
infile.read（（char*）&a[i],sizeof（a[i]））;
}
infile.close（）;
//求每个叶子结点的哈夫曼编码
for（i=0;i{
cd.start=N-1;
c=i;
p=a[c].parent;
while（p!
=-1）
{
if（a[p].lchild==c）
cd.bit[cd.start]=0;
else
cd.bit[cd.start]=1;
cd.start--;
c=p;
p=a[c].parent;
}
cout<<"字符对应密文：
"<cout<for（j=cd.start+1;j//保存求出的每个叶节点的哈夫曼编码和编码的起始位
{
HCode[i].bit[j]=cd.bit[j];
cout<}
cout<HCode[i].start=cd.start;
HCode[i].s=a[i].data;
}
outfile.open（"F:
\\codefile.dat",ios:
:
out|ios:
:
binary）;//建立进行写入的文件
if（!
outfile）//没有创建成功则显示相应信息
{
cout<<"codefile.dat文件不能打开"<return;
}
//将存中从HCode[i]地址开始的sizeof（HCode[i]）的容写入文件中
for（i=0;ioutfile.write（（char*）&HCode[i],sizeof（HCode[i]））;
outfile.close（）;//关闭文件n
cout<<"密文信息已存入文件codefile.dat中."<}
voidprint（）//将哈夫曼树以凹入表的形式输出
{
inti,h=1;
HNodeTypetemp[2*N-1];
fstreaminfile;
infile.open（"F:
\\hfmtree.txt",ios:
:
in|ios:
:
binary）;
if（!
infile）
{
cout<<"hfmtree.txt文件不能打开"<return;
}
else
{
for（i=0;i<2*N-1;i++）//将文件中的数据读出放在temp[i]
//从文件中读字节到指定的存储器区域。
infile.read（（char*）&temp[i],sizeof（temp[i]））;
}
infile.close（）;
print_t（temp,temp[2*N-2],h）;
}
voidprint_t（HNodeTypetemp[],HNodeTypeT,inth）
{
inti;
for（i=1;icout<<"";
if（T.data!
='\0'）
cout<else
cout<if（T.lchild==-1）
return;
print_t（temp,temp[T.lchild],h+1）;//递归遍历左子树
print_t（temp,temp[T.rchild],h+1）;//递归遍历右子树
}
voidHfmanCode（）//对用户输入的字符串进行编码
{
chars[50]={'\0'};
inti,j,k,n=0,m;
CDc;
c.num=0;
fstreaminfile,outfile;
HCodeTypetemp[N];
cout<<"输入字符串"<cin>>s;
m=strlen（s）;
infile.open（"F:
\\codefile.dat",ios:
:
in|ios:
:
binary）;//读文件
if（!
infile）
{
cout<<"codefile.dat文件不能打开"<return;
}
else
{
for（i=0;i//从文件中读字节到指定的存储器区域。
infile.read（（char*）&temp[i],sizeof（temp[i]））;
}
infile.close（）;
cout<<"输入要将密文存放的文件名"<cin>>name[filenum];
filenum++;
for（i=0;ifor（j=0;jif（s[i]==temp[j].s）
for（k=temp[j].start+1;k{
cout<c.code[c.num]=temp[j].bit[k];//将字符对应密文存入c中
c.num++;//记录密文长度
n++;
if（n==30）//实现每行输出30个密文
{
cout<n=0;
}
}
cout<outfile.open（name[filenum-1],ios:
:
out|ios:
:
binary）;//建立进行写入的文件
if（!
outfile）//没有创建成功则显示相应信息
{
cout<return;
}
//将存中从c容写入文件中
else
outfile.write（（char*）&c,sizeof（c））;
outfile.close（）;//关闭文件n
cout<<"密文信息已存入文件"<}
voidtranslate（）//译码
{
CDc;
HNodeTypetemp[2*N-1],q;
fstreaminfile,outfile;
charch,r[50]={'\0'},tempname[30]={'\0'};
intn=0,t=0,i;
cout<<"输入要译码的文件"<cin>>tempname;
for（i=0;iif（strcmp（tempname,name[i]）==0）
break;
if（i==filenum）
{
cout<<"密文文件中没有"<return;
}
infile.open（name[i],ios:
:
in|ios:
:
binary）;
if（!
infile）
{
cout<<"密文文件不能打开"<return;
}
else
{
//从文件中读字节到指定的存储器区域。
infile.read（（char*）&c,sizeof（c））;
}
infile.close（）;
infile.open（"F:
\\hfmtree.txt",ios:
:
in|ios:
:
binary）;
if（!
infile）
{
cout<<"hfmtree.dat文件不能打开"<return;
}
else
{
for（i=0;i<2*N-1;i++）//将文件中的数据读出放在temp[i]
//从文件中读字节到指定的存储器区域。
infile.read（（char*）&temp[i],sizeof（temp[i]））;
}
infile.close（）;
q=temp[2*N-2];//将根结点信息赋给q
cout<<"对应的明文信息为：
";
for（i=0;i{
if（c.code[i]!
=0&&c.code[i]!
=1）//容错处理
{
t=0;
break;
}
if（c.code[i]==0）
{
ch=temp[q.lchild].data;
升级会员 