哈夫曼编译码器课程设计报告完整版Word文件下载.docx

哈夫曼编译码器课程设计报告完整版Word文件下载.docx

《哈夫曼编译码器课程设计报告完整版Word文件下载.docx》由会员分享，可在线阅读，更多相关《哈夫曼编译码器课程设计报告完整版Word文件下载.docx（29页珍藏版）》请在冰豆网上搜索。

数据结构（C语言版）严蔚敏、吴伟民编著；

数据结构标准教程胡超、闫宝玉编著

完成期限：

2012年6月21日

指导教师签名：

课程负责人签名：

2012年6月21日

一、设计题目（任选其一）

二、实验目的

1巩固和加深对数据结构的理解，提高综合运用本课程所学知识的能力；

2深化对算法课程中基本概念、理论和方法的理解；

3巩固构造赫夫曼树的算法；

4设计试验用程序实验赫夫曼树的构造。

三、运行环境（软、硬件环境）

Windowsxpsp3，VisualC++6.0英文版

四、算法设计的思想

（1）初始化赫夫曼树，输入文件tobetrans.txt中各字符及其权值，并保存于hfmtree.txt文件中

（2）编码（Coding）。

对文件tobetrans中的正文进行编码，然后将结果存入文件codefile中

（3）D：

（4）P：

（5）T：

将已在存中的哈夫曼树以直观的方式显示在终端上，同时将此字符形式的哈夫曼树写入文件treeprint中。

五、流程图

六、算法设计分析

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

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

charch;

intweight;

//权值

intparent,lchild,rchild;

}HTNode,*HuffmanTree;

2.voidHuffmanCoding（HuffmanTree&

char*,int*,int）;

建立赫夫曼树的算法，此函数块调用了Select（）函数。

voidselect（HuffmanTreeHT,intj,int*x,int*y）;

从已建好的赫夫曼树中选择parent为0，weight最小的两个结点。

3．利用已建好的哈夫曼树从文件hfmtree.txt中读入，对文件中的正文进行编码，然后将结果存入文件codefile.txt中。

4.coding

编码功能：

对输入字符进行编码

5.Decoding

译码功能：

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

6.Print（）打印功能函数：

输出哈夫曼树以及对应的编码。

七、源代码

//////////////////////////////////////////////////////////////////////////////////////////

#include<

stdio.h>

stdlib.h>

string.h>

//定义赫夫曼树结点的结构体

typedefstruct{

//增加一个域，存放该节点的字符

intweight;

}HTNode,*HuffmanTree;

typedefchar**HuffmanCode;

//指向赫夫曼编码的指针

voidtips（）;

//打印操作选择界面

voidHuffmanCoding（HuffmanTree&

//建立赫夫曼树的算法

//从已建好的赫夫曼树中选择parent为0，weight最小的两个结点

voidInit（）;

voidCoding（）;

//编码

voidDecoding（）;

//译码

voidPrint_code（）;

//打印译码好的代码

voidPrint_tree（）;

//打印哈夫曼树

intRead_tree（HuffmanTree&

）;

//从文件中读入赫夫曼树

voidfind（HuffmanTree&

HT,char*code,char*text,inti,intm）;

//译码时根据01字符串寻找相应叶子节点的递归算法

voidConvert_tree（unsignedcharT[100][100],ints,int*i,intj）;

//将存中的赫夫曼树转换成凹凸表形式的赫夫曼树

HuffmanTreeHT;

//全局变量

intn=0;

//全局变量，存放赫夫曼树叶子结点的数目

intmain（）

{

charselect;

while

（1）

tips（）;

scanf（"

%c"

&

select）;

switch（select）//选择操作，根据不同的序号选择不同的操作

{

case'

1'

:

Init（）;

break;

2'

Coding（）;

3'

Decoding（）;

4'

Print_code（）;

5'

Print_tree（）;

0'

exit

（1）;

default:

printf（"

Inputerror!

\n"

}

getchar（）;

}

return0;

voidtips（）//操作选择界面

-----------------------------------------------------\n"

--请选择操作--\n"

\n"

---------------------1初始化赫夫曼树---------------\n"

---------------------2编码---------------\n"

---------------------3译码---------------\n"

---------------------4打印代码文件---------------\n"

---------------------5打印赫夫曼树---------------\n"

---------------------0退出---------------\n"

//初始化函数，输入n个字符及其对应的权值，根据权值建立哈夫曼树，并将其存于文件hfmtree中

voidInit（）

FILE*fp;

inti,n,w[52];

//数组存放字符的权值

charcharacter[52];

//存放n个字符

\n输入字符个数n:

"

scanf（"

%d"

n）;

//输入字符集大小

输入%d个字符及其对应的权值:

n）;

for（i=0;

i<

n;

i++）

charb=getchar（）;

character[i]）;

w[i]）;

//输入n个字符和对应的权值

HuffmanCoding（HT,character,w,n）;

//建立赫夫曼树

if（（fp=fopen（"

hfmtree.txt"

"

w"

））==NULL）

printf（"

Openfilehfmtree.txterror!

for（i=1;

=2*n-1;

if（fwrite（&

HT[i],sizeof（HTNode）,1,fp）!

=1）//将建立的赫夫曼树存入文件hfmtree.txt中

Filewriteerror!

\n赫夫曼树建立成功，并已存于文件hfmtree.txt中\n"

fclose（fp）;

//建立赫夫曼树的算法

HT,char*character,int*w,intn）

intm,i,x,y;

HuffmanTreep;

if（n<

=1）return;

m=2*n-1;

HT=（HuffmanTree）malloc（（m+1）*sizeof（HTNode））;

for（p=HT+1,i=1;

=n;

++i,++p,++character,++w）

{p->

ch=*character;

p->

weight=*w;

parent=0;

lchild=0;

rchild=0;

for（;

=m;

++i,++p）{p->

ch=0;

weight=0;

for（i=n+1;

++i）

select（HT,i-1,&

x,&

y）;

HT[x].parent=i;

HT[y].parent=i;

HT[i].lchild=x;

HT[i].rchild=y;

HT[i].weight=HT[x].weight+HT[y].weight;

//从HT[1]到HT[j]中选择parent为0，weight最小的两个结点，用x和y返回其序号

voidselect（HuffmanTreeHT,intj,int*x,int*y）

inti;

//查找weight最小的结点

=j;

i++）

if（HT[i].parent==0）

{*x=i;

for（;

if（（HT[i].parent==0）&

&

（HT[i].weight<

HT[*x].weight））

*x=i;

HT[*x].parent=1;

//查找weight次小的结点

{*y=i;

（i!

=*x）&

HT[*y].weight））

*y=i;

//对文件tobetrans中的正文进行编码，然后将结果存入文件codefile中

voidCoding（）

FILE*fp,*fw;

inti,f,c,start;

char*cd;

HuffmanCodeHC;

if（n==0）

n=Read_tree（HT）;

//从文件hfmtree.txt中读入赫夫曼树,返回叶子结点数

//求赫夫曼树中各叶子节点的字符对应的的编码，并存于HC指向的空间中

HC=（HuffmanCode）malloc（（n+1）*sizeof（char*））;

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

cd[n-1]='

\0'

;

for（i=1;

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]='

elsecd[--start]='

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

strcpy（HC[i],&

cd[start]）;

free（cd）;

tobetrans.txt"

rb"

Openfiletobetrans.txterror!

if（（fw=fopen（"

codefile.txt"

wb+"

Openfilecodefile.txterror!

chartemp;

fscanf（fp,"

temp）;

//从文件读入第一个字符

while（!

feof（fp））

for（i=1;

if（HT[i].ch==temp）break;

//在赫夫曼树中查找字符所在的位置

for（intr=0;

HC[i][r]!

='

r++）//将字符对应的编码存入文件

fputc（HC[i][r],fw）;

fscanf（fp,"

//从文件读入下一个字符

fclose（fw）;

\n已将文件hfmtree.txt成功编码,并已存入codefile.txt中！

\n\n"

//将文件codefile中的代码进行译码，结果存入文件textfile中

voidDecoding（）

intm,i;

char*code,*text,*p;

if（n==0）

if（（fw=fopen（"

textfile.txt"

Openfiletextfile.txterror!

code=（char*）malloc（sizeof（char））;

code）;

//从文件读入一个字符

!

feof（fp）;

code=（char*）realloc（code,（i+1）*sizeof（char））;

//增加空间

code[i]）;

//从文件读入下一个字符

code[i-1]='

//codefile.txt文件中的字符已全部读入，存放在code数组中

text=（char*）malloc（100*sizeof（char））;

p=text;

m=2*n-1;

if（*code=='

）

find（HT,code,text,HT[m].lchild,m）;

//从根节点的左子树去找

else

find（HT,code,text,HT[m].rchild,m）;

//从根节点的右子树去找

for（i=0;

p[i]!

i++）//把译码好的字符存入文件textfile.txt中

fputc（p[i],fw）;

\n已将codefile.txt文件成功译码，兵已存入textfile.txt文件！

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

voidPrint_code（）

if（（fp=fopen（"

codeprint.txt"

Openfilecodeprint.txterror!

\n文件codefi1e显示如下:

{

temp）;

if（i%50==0）printf（"

fputc（temp,fw）;

//将该字符存入文件codeprint.txt中

\n\n已将此字符形式的编码写入文件codeprint.txt中！

//将已在存中的哈夫曼树显示在屏幕上，并将此字符形式的哈夫曼树写入文件treeprint中。

voidPrint_tree（）

unsignedcharT[100][100];

inti,j,m=0;

//从文件hfmtree.txt中读入赫夫曼树,返回叶子结点数

Convert_tree（T,0,&

m,2*n-1）;

//将存中的赫夫曼树转换成凹凸表形式的树，存于数组T中

treeprint.txt"

Openfiletreeprint.txterror!

\n打印已建好的赫夫曼树：

for（j=0;

T[i][j]!

j++）

if（T[i][j]=='

'

）{printf（"

"

fputc（T[i][j],fp）;

else

{printf（"

T[i][j]）;

fprintf（fp,"

%d\n"

\n已将该字符形式的哈夫曼树写入文件treeprint.txt中！

//从文件hfmtree.txt中读入赫夫曼树，返回叶子节点数

HT）

inti,n;

HT=（HuffmanTree）malloc（sizeof（HTNode））;

r"

HT=（HuffmanTree）realloc（HT,（i+1）*sizeof（HTNode））;

fread（&

HT[i],sizeof（HTNode）,1,fp）;

//读入一个节点信息

n=（i-1）/2;

returnn;

//译码时根据01字符串寻找相应叶子节点的递归算法

HT,char*code,char*text,inti,intm）

if（*code!

）//若译码未结束

code++;

if（HT[i].lchild==0&

HT[i].rchild==0）//若找到叶子节点

*text=HT[i].ch;

//将叶子节点的字符存入text中

text++;

if（（*code=='

））

//从根节点的左子树找

//从根节点的右子树找

else//如果不是叶子节点

if（*code=='

find（HT,code,text,HT[i].lchild,m）;

//从该节点的左子树去找

find（HT,code,text,HT[i].rchild,m）;

//从该节点的右子树去找

*text='

//译码结束

//将文件中的赫夫曼树转换成凹凸表形式的赫夫曼树打印出来

voidConvert_tree（unsignedcharT[100][100],ints,int*i,intj）

intk,l;

l=++（*i）;

for（k=0;

k<

s;

k++）

T[l][k]='

T[l][k]=HT[j].weight;

if（HT[j].lchild）

Convert_tree（T,s+1,i,HT[j].lchild）;

if（HT[j].rchild）

Convert_tree（T,s+1,i,HT[j].rchild）;

T[l][++k]='

/////////////////////////////////////