哈夫曼编译码器数据结构实践环节实验报告课程设计Word格式文档下载.docx

哈夫曼编译码器数据结构实践环节实验报告课程设计Word格式文档下载.docx

《哈夫曼编译码器数据结构实践环节实验报告课程设计Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《哈夫曼编译码器数据结构实践环节实验报告课程设计Word格式文档下载.docx（26页珍藏版）》请在冰豆网上搜索。

C

D

E

F

G

H

I

J

K

L

M

频度

186

64

13

22

32

103

21

15

47

57

1

5

20

N

O

P

Q

R

S

T

U

V

W

X

Y

Z

63

48

51

80

23

8

18

16

【算法思想】

哈夫曼编\译码器的主要功能是先建立哈夫曼树，然后利用建好的哈夫曼树生成哈夫曼编码后进行译码。

在数据通信中，经常需要将传送的文字转换成由二进制字符0、1组成的二进制串，称之为编码。

构造一棵哈夫曼树，规定哈夫曼树中的左分之代表0，右分支代表1，则从根节点到每个叶子节点所经过的路径分支组成的0和1的序列便为该节点对应字符的编码，称之为哈夫曼编码。

最简单的二进制编码方式是等长编码。

若采用不等长编码，让出现频率高的字符具有较短的编码，让出现频率低的字符具有较长的编码，这样可能缩短传送电文的总长度。

哈夫曼树课用于构造使电文的编码总长最短的编码方案。

（1）其主要流程图如图1-1所示。

（2）设计包含的几个方面：

①赫夫曼树的建立

哈夫曼树的建立由赫夫曼算法的定义可知，初始森林中共有n棵只含有根结点的二叉树。

算法的第二步是：

将当前森林中的两棵根结点权值最小的二叉树，合并成一棵新的二叉树；

每合并一次，森林中就减少一棵树，产生一个新结点。

显然要进行n－1次合并，所以共产生n－1个新结点，它们都是具有两个孩子的分支结点。

由此可知，最终求得的哈夫曼树中一共有2n－1个结点，其中n个结点是初始森林的n个孤立结点。

并且赫夫曼树中没有度数为1的分支结点。

我们可以利用一个大小为2n--1的一维数组来存储赫夫曼树中的结点。

②哈夫曼编码

要求电文的哈夫曼编码，必须先定义哈夫曼编码类型，根据设计要求和实际需要定义的类型如下：

typedetstruct{

charch;

//存放编码的字符

charbits[N＋1];

//存放编码位串

intlen;

//编码的长度

}CodeNode;

//编码结构体类型

③代码文件的译码

译码的基本思想是：

读文件中编码，并与原先生成的哈夫曼编码表比较，遇到相等时，即取出其对应的字符存入一个新串中。

【模块划分】

1）问题分析哈夫曼树的定义

1.哈夫曼树节点的数据类型定义为：

typedefstruct{//哈夫曼树的结构体

charch;

intweight;

//权值

intparent,lchild,rchild;

}htnode,*hfmtree;

2）所实现的功能函数如下

1、voidhfmcoding（hfmtree&

HT,hfmcode&

HC,intn）初始化哈夫曼树，处理InputHuffman（HuffmanHfm）函数得到的数据，按照哈夫曼规则建立2叉树。

此函数块调用了Select（）函数。

2、voidSelect（hfmtree&

HT,inta,int*p1,int*p2）//Select函数，选出HT树到a为止，权值最小且parent为0的2个节点

3、Encoding

编码功能：

对输入字符进行编码

4、Decoding

译码功能：

利用已建好的哈夫曼树将文件codefile.txt中的代码进行译码，结果存入文件textfile.dat中。

5.主函数的简要说明，主函数主要设计的是一个分支语句，让用户挑选所实现的功能。

使用链树存储，然后分别调用统计频数函数，排序函数，建立哈夫曼函数，编码函数，译码函数来实现功能。

3）系统功能模块图：

【数据结构】

（1）①哈夫曼树的存储结构描述为：

#defineN50//叶子结点数

#defineM2*N-1//哈夫曼树中结点总数

typedefstruct{

intweight;

//叶子结点的权值

intlchild,rchild,parent;

//左右孩子及双亲指针

}HTNode;

//树中结点类型

typedefHTNodeHuffmanTree[M+1];

②哈夫曼树的算法

voidCreateHT（HTNodeht[],intn）//调用输入的数组ht[],和节点数n

{

inti,k,lnode,rnode;

intmin1,min2;

for（i=0;

i<

2*n-1;

i++）

ht[i].parent=ht[i].lchild=ht[i].rchild=-1;

//所有结点的相关域置初值-1

for（i=n;

i++）//构造哈夫曼树

{

min1=min2=32767;

//int的范围是-32768—32767

lnode=rnode=-1;

//lnode和rnode记录最小权值的两个结点位置

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;

}

elseif（ht[k].weight<

min2）

min2=ht[k].weight;

rnode=k;

}

}

ht[lnode].parent=i;

ht[rnode].parent=i;

//两个最小节点的父节点是i

ht[i].weight=ht[lnode].weight+ht[rnode].weight;

//两个最小节点的父节点权值为两个最小节点权值之和

ht[i].lchild=lnode;

ht[i].rchild=rnode;

//父节点的左节点和右节点

}

}

（2）哈夫曼编码

voidCreateHCode（HTNodeht[],HCodehcd[],intn）

inti,f,c;

HCodehc;

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//处理右孩子结点

1'

c=f;

f=ht[f].parent;

hc.start++;

//start指向哈夫曼编码hc.cd[]中最开始字符

hcd[i]=hc;

voidDispHCode（HTNodeht[],HCodehcd[],intn）//输出哈夫曼编码的列表

inti,k;

printf（"

输出哈夫曼编码:

\n"

）;

i++）//输出data中的所有数据，即A-Z

%c:

\t"

ht[i].data）;

for（k=hcd[i].start;

=n;

k++）//输出所有data中数据的编码

%c"

hcd[i].cd[k]）;

voideditHCode（HTNodeht[],HCodehcd[],intn）//编码函数

charstring[MAXSIZE];

inti,j,k;

scanf（"

%s"

string）;

//把要进行编码的字符串存入string数组中

\n输出编码结果:

string[i]!

='

#'

i++）//#为终止标志

for（j=0;

j<

j++）

{

if（string[i]==ht[j].data）//循环查找与输入字符相同的编号，相同的就输出这个字符的编码

for（k=hcd[j].start;

hcd[j].cd[k]）;

break;

//输出完成后跳出当前for循环

（3）哈夫曼译码

voiddeHCode（HTNodeht[],HCodehcd[],intn）//译码函数

charcode[MAXSIZE];

inti,j,l,k,m,x;

code）;

//把要进行译码的字符串存入code数组中

while（code[0]!

）

i++）

m=0;

//m为想同编码个数的计数器

for（k=hcd[i].start,j=0;

k++,j++）//j为记录所存储这个字符的编码个数

if（code[j]==hcd[i].cd[k]）//当有相同编码时m值加1

m++;

if（m==j）//当输入的字符串与所存储的编码字符串个数相等时则输出这个的data数据

printf（"

for（x=0;

code[x-1]!

x++）//把已经使用过的code数组里的字符串删除

code[x]=code[x+j];

【测试情况】

（1）程序运行时，进入的主界面如图：

（2）选择1进入，创建名称为yuanwen的文件，如图：

（3）输入英语原文为Ilikeplayingfootball,如图所示：

（4）程序对原文进行编码运行输出结果，程序如图：

【心得】

在我自己课程设计中，就在编写好源代码后的调试中出现了不少的错误，遇到了很多麻烦及困难，我的调试及其中的错误和我最终找出错误，修改为正确的能够执行的程序中，通过分析，我学到了：

在定义头文件时可多不可少，即我们可多写些头文件，肯定不会出错，但是若没有定义所引用的相关头文件，必定调试不通过；

在执行译码操作时，不知什么原因，总是不能把要编译的二进制数与编译成的字符用连接号连接起来，而是按顺序直接放在一起，视觉效果不是很好。

还有就是，很遗憾的是，我们的哈夫曼编码/译码器没有像老师要求的那样完成编一个文件的功能，这是我们设计的失败之处。

通过本次数据结构的课程设计，我学习了很多在上课没懂的知识，并对求哈夫曼树及哈夫曼编码/译码的算法有了更加深刻的了解，更巩固了课堂中学习有关于哈夫曼编码的知识

【源程序】

#include<

stdio.h>

stdlib.h>

string.h>

#defineN5000

#definem128//叶子结点个数，即字符总类数

#defineM2*m-1//哈夫曼树的节点数

charCH[N];

//记录原文字符数组

charYW[N];

//记录译文字符数组

typedefchar*Hcode[m+1];

//存放哈夫曼字符编码串的头指针的数组

typedefstruct

chara;

intnum;

}dangenode;

//记录单个字符的类别和出现的次数

dangenodeb[129];

inttag;

}jilunode;

//统计原文出现的字符种类数

typedefstructnode

//结点权值

intparent;

//双亲下标

intLchild;

//左孩子结点的下标

intRchild;

//右孩子的下标

}htnode,hn[M];

//静态三叉的哈夫曼树的定义

voidjianliwenjian（）

FILE*fp;

现在建立文件，以存储原文（文件名称默认为yuanwen）\n"

文件建立中......\n"

if（（fp=fopen（"

yuanwen"

"

wb"

））==NULL）//建立文件

printf（"

Cannotopenfile\n"

exit（0）;

文件已建立,名称为：

fclose（fp）;

//关闭文件

voidluruyuanwen（）//原文输入完后，将其保存到文件yuanwen中

））==NULL）//打开文件

请输入原文（结束标志为：

^）\n"

do

ch=getchar（）;

fputc（ch,fp）;

//将字符保存到文件中

}while（ch!

^'

//判断结束

getchar（）;

//接收回车命令符

}

voidmin_2（hnht,intn,int*tag1,int*tag2）//在建哈夫曼树的过程中，选择权值小的两

{//个结点

inti,min,s;

min=N;

for（i=1;

if（ht[i].weight<

min&

&

ht[i].parent==0）

{

min=ht[i].weight;

*tag1=i;

//记录权值最小的结点下标

}

if（ht[i].weight<

ht[i].parent==0&

i!

=*tag1）

*tag2=i;

if（ht[*tag1].weight==ht[*tag2].weight&

ht[*tag2].Lchild!

=0）

s=（*tag1）;

//如果结点权值相同，先出现的放在哈夫曼树的左边

（*tag1）=（*tag2）;

（*tag2）=s;

voidchuangjian（jilunode*jilu,hnht）//建立哈夫曼树、以及对原

{

//文字符的类别和数量统计

inti=-1,j,s=0,tag1,tag2;

//s=0;

//i=-1;

//charch;

rb"

））==NULL）//以只读的方式打开文件

while（!

feof（fp））//判断文件指示标志是否移动到了文件尾处

ch=fgetc（fp）;

if（ch!

）//判断字符是否是结束标志

++i;

CH[i]=ch;

for（j=1;

=jilu->

tag;

j++）

if（CH[i]==jilu->

b[j].a）

jilu->

b[j].num++;

break;

if（j-1==jilu->

tag&

CH[i]!

b[j-1].a）

jilu->

tag++;

b[jilu->

tag].a=CH[i];

tag].num=1;

tag--;

原文中的各字符统计状况如下：

*^*^*^*^*^*^*^*^**^*^*^**^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*^*\n"

s++;

'

%c'

的个数为:

%d"

jilu->

b[i].a,jilu->

b[i].num）;

if（s%4==0）//每行放四个数据

=2*（jilu->

tag）-1;

if（i<

tag）

ht[i].weight=jilu->

b[i].num;

//初始化叶子结点权值

ht[i].Lchild=0;

//初始化叶子结点左孩子

ht[i].parent=0;

//初始化叶子结点父母

ht[i].Rchild=0;

//初始化叶子结点右孩子

else

//初始化非叶子结点左孩子

//初始化非叶子结点父母

//初始化非叶子结点右孩子

ht[i].weight=0;

//初始化非叶子结点权值

for（i=jilu->

tag+1;

min_2（ht,i-1,&

tag1,&

tag2）;

//需找权值小的两个父母为0的结点

ht[tag1].parent=i;

ht[tag2].parent=i;

ht[i].Lchild=tag1;

ht[i].Rchild=tag2;

ht[i].weight=ht[tag1].weight+ht[tag2].weight;

voidbianma（jilunode*jilu,hnht,Hcodehc,intn）//哈夫曼树建完后，对叶

{//子结点逐个编码

char*cd;

intstart,i,p,c;

cd=（char*）malloc（（n+1）*sizeof（char））;

//申请存储字符的临时空间

cd[n-1]='

\0'

//加结束标志

start=n-1;

c=i;

p=ht[i].parent;

while（p!

--start;

if（ht[p].Lchild==c）

cd[start]='

//结点在左边置1

if（ht[p].Rchild==c）

//结点在右边置0

c=p;

p=ht[p].parent;

%c的编码为：

%s\n"

b[i].a,&

cd[start]）;

hc[i]=（char*）malloc（（n-start）*sizeof（char））;

//为字符数组分配空间

strcpy（hc[i],&

//将临时空间中的编码复制到字符数组中

free（cd）;

//释放临时空间

voidbianmabaocun（Hcodehc,jilunode*jilu）//将原文以编码的形式保存到

{//文件yiwen中

inti,j;

yiwen"

））==NULL）//以写的方式打开文件

//文件打开失败退出

for（i=0;

=N&