数据结构综合实验报告.docx

数据结构综合实验报告.docx

《数据结构综合实验报告.docx》由会员分享，可在线阅读，更多相关《数据结构综合实验报告.docx（20页珍藏版）》请在冰豆网上搜索。

数据结构综合实验报告

实验报告

课程名称数据结构B

实验学期2018至2019学年第一学期

学生所在系部

年级专业班级

学生姓名学号2017

任课教师

实验成绩

计算机学院制

《数据结构》课程综合性实验报告

开课实验室：

软件工程实验室2018年11月23日

实验题目

用赫夫曼编码实现文件压缩

一、实验目的

1、了解文件的概念。

2、掌握线性链表的插入、删除等算法。

3、掌握Huffman树的概念及构造方法。

4、掌握二叉树的存储结构及遍历算法。

5、利用Huffman树及Huffman编码，掌握实现文件压缩的一般原理。

二、设备与环境

微型计算机、Windows系列操作系统、VisualC++6.0软件

三、实验内容

1、实验内容

根据ascii码文件中各ascii字符出现的频率情况创建Haffman树，再将各字符对应的哈夫曼编码写入文件中，实现文件压缩。

2、实验要求

a、用C语言编程实现上述实验内容中的结构定义和算法。

b、要有main（）函数，并且在main（）函数中使用检测数据调用上述算法。

3、最后结果输出。

要求：

输出格式要界面直观、清晰大方、格式规范。

四、实验方法或步骤

1、实验的预备知识

（1）构造Hufffman树的方法—Hufffman算法

构造Huffman树步骤：

I.根据给定的n个权值{w1,w2,……wn}，构造n棵只有根结点的二叉树，令起权值为wj。

II.在森林中选取两棵根结点权值最小的树作左右子树，构造一棵新的二叉树，置新二叉树根结点权值为其左右子树根结点权值之和。

III.在森林中删除这两棵树，同时将新得到的二叉树加入森林中。

IV.重复上述两步，直到只含一棵树为止，这棵树即哈夫曼树。

（2）Huffman编码：

数据通信用的二进制编码

思想：

根据字符出现频率编码，使电文总长最短

编码：

根据字符出现频率构造Huffman树，然后将树中结点引向其左孩子的分支标“0”，引向其右孩子的分支标“1”；每个字符的编码即为从根到每个叶子的路径上得到的0、1序列。

（3）二叉树的存储结构

typedefstructnode

{

datatypedata;

structnode*lchild,*rchild;

}BtTree

2、设计思想

（1）实现的Haffman树的结构及创建算法，有两点说明：

a）这里的Haffman树采用的是基于数组的带左右儿子结点及父结点下标作为存储结点的二叉树形式，这种空间上的消耗带来了算法实现上的便捷。

b）由于对于最后生成的Haffman树，其所有叶子结点均为从一个内部树扩充出去的，所以，当外部叶子结点数为m个时，内部结点数为m-1，整个Haffman树的需要的结点数为2m-1。

编码部分

（2）压缩过程的实现：

压缩过程的流程是清晰而简单的：

1创建Haffman树2打开需压缩文件3将需压缩文件中的每个ascii码对应的haffman编码按bit单位输出4文件压缩结束。

其中，步骤1和步骤3是压缩过程的关键。

步骤1:

这里所要做工作是得到Haffman数中各叶子结点字符出现的频率并进行创建。

统计字符出现的频率可以有很多方法:

如每次创建前扫描被创建的文件，“实时”的生成各字符的出现频率；或者是创建前即做好统计。

本文采用后一种的方案,统计了十篇不同的文章中字符出现的频率。

当前，也可以根据被压缩文件的特性有针对性的进行统计，如要压缩C语言的源文件，则可事先对多篇C语言源文件中出现的字符进行统计,这样，会创建出高度相对较“矮”的Haffman树，从而提高压缩效果。

步骤3:

将需压缩文件中的每个ascii码对应的haffman编码按bit单位输出，这是本压缩程序中最关键的部分。

这里涉及“转换”和“输出”两个关键步骤：

“转换”部分大可不必去通过遍历Haffman树来找到每个字符对应的哈夫曼编码，可以将每个Haffman码值及其对应的ascii码存放于如下所示的结构体中：

typedefstruct

{

charasciiCode;

unsignedlonghaffCode;

inthaffCodeLen;

}HaffCode;

创建由该结构体结点所组成的，长度为128的一维数组codeList[128]

且codeList中的下标和asciiCode满足下面的顺序存放关系：

codeList[i].asciiCode=i;

这样的话，查找某个字符inChar的haffman编码的工作便变得相当轻松了,如下：

sHaffCode=codeList[inChar].haffCode;

数组codeList[128]的创建可以采用某种遍历方式下的按找到的字符进行置数的方式，十分的方便。

/*Code2:

codeList的创建算法,采用前序遍历的方式进行创建.

*/

voidpreHaffListMake（PHtTreeinTree,introotIndex,unsignedlongyouBiao,intsDepth,

HaffCode*inList）

{

if（inTree->ht[rootIndex].llinkIndex==-1&&inTree->ht[rootIndex].rlinkIndex==-1）

{

inList[inTree->ht[rootIndex].info].haffCode=youBiao;

inList[inTree->ht[rootIndex].info].haffCodeLen=sDepth;

}

else

{

preHaffListMake（inTree,inTree->ht[rootIndex].llinkIndex,youBiao<<1,sDepth+1,inList）;

preHaffListMake（inTree,inTree->ht[rootIndex].rlinkIndex,（youBiao<<1）|0x01,sDepth+1,inList）;

}

}

“输出”部分是最重要的部分，也是最易出错的部分。

这里，涉及到C语言的位操作,要求这个算法能处理好以下几个问题：

1）每个字符所对应的haffCode的比特位长度由5~23位不等长，不可少输，多输，输错任何一位，后一个字符的haffCode要紧跟在前一个字符的haffCode后面。

2）最后一个字符要能合理的结束。

这主要是为解压缩考虑的，比如，在最后一个要输出的haffCode的最后一位，它恰好是位于最后一个有效字符的第一位，剩下的七个比特位是要用无效的haffCode加以填充的。

否则，如果填充的haffCode亦为某个ascii字符的haffCode时，那么在解压缩时，则该在原被压缩文件中不存在的字符便会无中生有的在解压后的文件中出现，这显然是不正确的，应在程序中加以处理。

编码部分的流程如图3-1所示：

图3-1

#include

#include

#include

#include

structhead

{

unsignedcharb;//记录字符在数组中的位置

longcount;//字符出现频率（权值）

longparent,lch,rch;//定义哈夫曼树指针变量

charbits[256];//定义存储哈夫曼编码的数组

}header[512],tmp;

/*压缩*/

voidcompress（）

{

charfilename[255],outputfile[255],buf[512];

unsignedcharc;

longi,j,m,n,f;

longmin1,pt1,flength,length1,length2;

doublediv;

FILE*ifp,*ofp;

//printf（"\t请您输入需要压缩的文件：

"）;

//gets（filename）;

strcpy（filename,"yuan.txt"）;

ifp=fopen（filename,"rb"）;

if（ifp==NULL）

{

printf（"\n\t文件打开失败!

\n\n"）;

return;

}

//printf（"\t请您输入压缩后的文件名：

"）;

//gets（outputfile）;

strcpy（outputfile,"yuanys.txt"）;

//ofp=fopen（strcat（outputfile,".hub"）,"wb"）;

ofp=fopen（outputfile,"wb"）;

if（ofp==NULL）

{

printf（"\n\t压缩文件失败!

\n\n"）;

return;

}

flength=0;

while（!

feof（ifp））

{

fread（&c,1,1,ifp）;

header[c].count++;//字符重复出现频率+1

flength++;//字符出现原文件长度+1

}

flength--;

length1=flength;//原文件长度用作求压缩率的分母

header[c].count--;

for（i=0;i<512;i++）

{

if（header[i].count!

=0）

header[i].b=（unsignedchar）i;

/*将每个哈夫曼码值及其对应的ASCII码存放在一维数组header[i]中，

且编码表中的下标和ASCII码满足顺序存放关系*/

else

header[i].b=0;

header[i].parent=-1;header[i].lch=header[i].rch=-1;//对结点进行初始化

}

for（i=0;i<256;i++）//根据频率（权值）大小，对结点进行排序，选择较小的结点进树

{

for（j=i+1;j<256;j++）

{

if（header[i].count

{

tmp=header[i];

header[i]=header[j];

header[j]=tmp;

}

}

}

for（i=0;i<256;i++）

if（header[i].count==0）

break;

n=i;//外部叶子结点数为n个时，内部结点数为n-1，整个哈夫曼树的需要的结点数为2*n-1.

m=2*n-1;

for（i=n;i

{

min1=999999999;//预设的最大权值，即结点出现的最大次数

for（j=0;j

{

if（header[j].parent!

=-1）//parent!

=-1说明该结点已存在哈夫曼树中，跳出循环重新选择新结点*/

continue;

if（min1>header[j].count）

{

pt1=j;

min1=header[j].count;

continue;

}

}

header[i].count=header[pt1].count;

header[pt1].parent=i;//依据parent域值（结点层数）确定树中结点之间的关系

header[i].lch=pt1;//计算左分支权值大小

min1=999999999;

for（j=0;j

{

if（header[j].parent!

=-1）

continue;

if（min1>header[j].count）

{

pt1=j;

min1=header[j].count;

continue;

}

}

header[i].count+=header[pt1].count;

header[i].rch=pt1;//计算右分支权值大小

header[pt1].parent=i;

}

for（i=0;i

{

f=i;

header[i].bits[0]=0;//根结点编码0

while（header[f].parent!

=-1）

{

j=f;

f=header[f].parent;

if（header[f].lch==j）//置左分支编码0

{

j=strlen（header[i].bits）;

memmove（header[i].bits+1,header[i].bits,j+1）;

//依次存储连接“0”“1”编码

header[i].bits[0]='0';

}

else//置右分支编码1

{

j=strlen（header[i].bits）;

memmove（header[i].bits+1,header[i].bits,j+1）;

header[i].bits[0]='1';

}

}

}

fseek（ifp,0,SEEK_SET）;//从文件开始位置向前移动0字节，即定位到文件开始位置

fwrite（&flength,sizeof（int）,1,ofp）;

/*用来将数据写入文件流中，参数flength指向欲写入的数据地址，

总共写入的字符数以参数size*int来决定，返回实际写入的int数目1*/

fseek（ofp,8,SEEK_SET）;

buf[0]=0;//定义缓冲区,它的二进制表示00000000

f=0;

pt1=8;

/*假设原文件第一个字符是"A"，8位2进制为01000001，编码后为0110识别编码第一个'0'，

那么我们就可以将其左移一位，看起来没什么变化。

下一个是'1'，应该|1，结果00000001

同理4位都做完，应该是00000110，由于字节中的8位并没有全部用完，我们应该继续读下一个字符，

根据编码表继续拼完剩下的4位，如果字符的编码不足4位，还要继续读一个字符，

如果字符编码超过4位，那么我们将把剩下的位信息拼接到一个新的字节里*/

while（!

feof（ifp））

{

c=fgetc（ifp）;

f++;

for（i=0;i

{

if（c==header[i].b）

break;

}

strcat（buf,header[i].bits）;

j=strlen（buf）;

c=0;

while（j>=8）//对哈夫曼编码位操作进行压缩存储

{

for（i=0;i<8;i++）

{

if（buf[i]=='1'）

c=（c<<1）|1;

else

c=c<<1;

}

fwrite（&c,1,1,ofp）;

pt1++;//统计压缩后文件的长度

strcpy（buf,buf+8）;//一个字节一个字节拼接

j=strlen（buf）;

}

if（f==flength）break;

}

if（j>0）//对哈夫曼编码位操作进行压缩存储

{

strcat（buf,"00000000"）;

for（i=0;i<8;i++）

{

if（buf[i]=='1'）

c=（c<<1）|1;

else

c=c<<1;

}

fwrite（&c,1,1,ofp）;

pt1++;

}

fseek（ofp,4,SEEK_SET）;

fwrite（&pt1,sizeof（long）,1,ofp）;

fseek（ofp,pt1,SEEK_SET）;

fwrite（&n,sizeof（long）,1,ofp）;

for（i=0;i

{

fwrite（&（header[i].b）,1,1,ofp）;

c=strlen（header[i].bits）;

fwrite（&c,1,1,ofp）;

j=strlen（header[i].bits）;

if（j%8!

=0）//若存储的位数不是8的倍数，则补0

{

for（f=j%8;f<8;f++）

strcat（header[i].bits,"0"）;

}

while（header[i].bits[0]!

=0）

{

c=0;

for（j=0;j<8;j++）//字符的有效存储不超过8位，则对有效位数左移实现两字符编码的连接

{

if（header[i].bits[j]=='1'）

c=（c<<1）|1;//|1不改变原位置上的“0”“1”值

else

c=c<<1;

}

strcpy（header[i].bits,header[i].bits+8）;//把字符的编码按原先存储顺序连接

fwrite（&c,1,1,ofp）;

}

}

length2=pt1--;

div=（（double）length1-（double）length2）/（double）length1;//计算文件的压缩率

fclose（ifp）;

fclose（ofp）;

printf（"\n\t压缩文件成功!

\n"）;

printf（"\t压缩率为%f%%\n\n",div*100）;

}

/*解压缩*/

voiduncompress（）

{

charfilename[255],outputfile[255],buf[255],bx[255];

unsignedcharc;

longi,j,m,n,f,p,l;

longflength;

FILE*ifp,*ofp;

//printf（"\t请您输入需要解压缩的文件：

"）;

//gets（filename）;

strcpy（filename,"yuanys.txt"）;

//ifp=fopen（strcat（filename,".hub"）,"rb"）;

ifp=fopen（filename,"rb"）;

if（ifp==NULL）

{

printf（"\n\t文件打开失败!

\n"）;

return;

}

//printf（"\t请您输入解压缩后的文件名：

"）;

//gets（outputfile）;

strcpy（outputfile,"yuanjy.txt"）;

ofp=fopen（outputfile,"wb"）;

if（ofp==NULL）

{

printf（"\n\t解压缩文件失败!

\n"）;

return;

}

fread（&flength,sizeof（long）,1,ifp）;//读取原文件长度，对文件进行定位

fread（&f,sizeof（long）,1,ifp）;

fseek（ifp,f,SEEK_SET）;

fread（&n,sizeof（long）,1,ifp）;

for（i=0;i

{

fread（&header[i].b,1,1,ifp）;

fread（&c,1,1,ifp）;

p=（long）c;//读取原文件字符的权值

header[i].count=p;

header[i].bits[0]=0;

if（p%8>0）

m=p/8+1;

else

m=p/8;

for（j=0;j

{

fread（&c,1,1,ifp）;

f=c;

itoa（f,buf,2）;//将f转换为二进制表示的字符串

f=strlen（buf）;

for（l=8;l>f;l--）

{

strcat（header[i].bits,"0"）;

}

strcat（header[i].bits,buf）;

}

header[i].bits[p]=0;

}

for（i=0;i

{

for（j=i+1;j

{

if（strlen（header[i].bits）>strlen（header[j].bits））

{

tmp=header[i];

header[i]=header[j];

header[j]=tmp;

}

}

}

p=strlen（header[n-1].bits）;

fseek（ifp,8,SEEK_SET）;

m=0;

bx[0]=0;

while

（1）//通过哈夫曼编码的长短，依次解码，从原来的位存储还原到字节存储

{

while（strlen（bx）<（unsignedint）p）

{

fread（&c,1,1,ifp）;

f=c;

itoa（f,buf,2）;

f=strlen（buf）;

for（l=8;l>f;l--）//在单字节内对相应位置补0

{

strcat（bx,"0"）;

}

strcat（bx,buf）;

}

for（i=0;i

{

if（memcmp（header[i].bits,bx,header[i].count）==0）break;

}

strcpy（bx,bx+header[i].count）;/*从压缩文件中的按位存储还原到按字节存储字符，字符位置不改变*/

c=header[i].b;

fwrite（&c,1,1,ofp）;

m++;//统计解压缩后文件的长度

if（m==flength）

break;//flength是原文件长度

}

fclose（ifp）;

fclose（ofp）;

printf（"\n\t解压缩文件成功!

\n"）;

if（m==flength）//对解压缩后文件和原文件相同性比较进行判断（根据文件大小）

printf（"\t解压缩文件与原文件相同!

\n\n"）;

else

printf（"\t解压缩文件与原文件不同!

\n\n"）;

}

/*主函数*/

voidmain（）

{

intc;

while

（1）//菜单工具栏

{

printf（"\t