哈夫曼编码

课程设计说明书

课程名称：数据结构与算法

设计题目：哈夫曼树与哈夫曼编码

院系：计算机科学与信息工程学院

学生姓名：

学号：

专业班级：

指导教师：

20 年6 月日

课程设计任务书

哈夫曼树与哈夫曼编码

摘要：

哈夫曼编码是哈夫曼于1952年提出的一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，也称之为最佳编码。利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传输数据预先编码，在接收端将传来的数据进行译码。这需要我们有一个编码系统。

哈夫曼树定义为：给定n个权值作为n个叶子结点，构造出的一棵二叉树带权路径长度达到最小。在这个定义中有几个基本术语：

路径和路径长度在一棵树中，从一个结点往下可以达到的孩子或子孙结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。结点的权及带权路径长度若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。树的带权路径长度树的带权路径长度规定为所有叶子结点的带权路径长度之和。

关键词：

哈夫曼树；哈夫曼编码；字符；权值

目录

1设计背景 (4)

1.1树形结构的广泛应用 (4)

1.2哈夫曼编码的需求 (4)

1.3哈夫曼编码系统的广泛应用 (4)

2．设计方案 (5)

2.1总体设计流程 (5)

2.2哈夫曼编码系统的模块化 (5)

3.方案实施 (5)

3.1哈夫曼编码功能 (5)

3.2 Huffman算法 (5)

4．结果与结论 (6)

4.1源程序代码概要 (6)

4.2关键程序代码段详细描述 (6)

4.3运行结果 (13)

4.4课程设计总结 (17)

5.收获与致谢 (17)

6.参考文献 (18)

7.附件 (18)

1.1树形结构的广泛应用

树形结构是一类重要的非线性数据结构。其中以树和二叉树最为常用，直观看来，树是以分支关系定义的层次结构。树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可用树来形象表示。树在计算机领域中也得到广泛应用，如在编译程序中，可用树来表示源程序的语法结构。又如在数据库系统中，树形结构也是信息的重要组织形式之一。

1.2哈夫曼编码的需求

目前，进行快速远距离通信的主要手段是电报，即将需传送的文字转换成由二进制的字符组成的字符串。例如，假设需传送的的电文为‘A B A C C D A’，它只有四种字符，只需两个字符的串便可分辨。假设A、B、C、D的编码分别为00、01、10、11，则上述7个字符的电文便为‘00010010101100’，总长14位，对方接收拾，可按二位一分进行译码。

当然，在传送报文时，希望总长尽可能的短。如果对每个字符设计长度不等的编码，且让电文中出现次数较多的字符采用尽可能短的编码，则传送电文的总长便可减少。于是可利用二叉树来设计二进制的前缀编码。如此设计一颗哈夫曼树，便可得到哈夫曼编码。利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

1.3哈夫曼编码系统的广泛应用

哈夫曼树─即最优二叉树，带权路径长度最小的二叉树，经常应用于数据压缩。在计算机信息处理中，哈夫曼编码是一种一致性编码法，用于数据的无损耗压缩。这一术语是指使用一张特殊的编码表将源字符（例如某文件中的一个符号）进行编码。这张编码表的特殊之处在于，它是根据每一个源字符出现的估算概率而建立起来的（出现概率高的字符使用较短的编码，反之出现概率低的则使用较长的编码，这便使编码之后的字符串的平均期望长度降低，从而达到无损压缩数据的目的）。这种方法David.A.Huffman 发展起来的。例如，在英文中，e的出现概率很高，而z的出现概率则最低。当利用哈夫曼编码对一篇英文进行压缩时，e极有可能用一个位（bit)来表示，而z则可能花去25个位（不是26）。

2.1总体设计流程

1.实现哈夫曼编码界面

（1）界面的实现算法；

（2）建立正文的编码文件。

2.实现输出哈夫曼树系统

（1）Huffman算法。

（2）建立正文的编码文件。

3.实现代码文件的译码

2.2 交通咨询系统的模块化

1.程序用到的抽象数据类型的定义；

2.系统子程序及功能；

3.代码文件的译码。

3. 方案实施

3.1 哈夫曼编码功能

哈夫曼编码功能：

（1）初始化哈夫曼链表并输出对应编码。

（2）编码特定的字符。

（3）输出特定的字符编码。

（4）输出哈夫曼树。

（5）退出。

3.2 Huffman算法

Huffman算法基本思想：

第一步在森林里选取两棵根节点权值最小的二叉树作为左右子树，构造一棵新的二叉树，新二叉树的跟结点权值为这两颗树根的权值之和。第二步在森林中，将上面选择的这两颗树根权值最小的二叉树从森林中删除，并将刚刚新构造的二叉树加入到森林中。重复上面的两步，直到森林中只有一颗二叉树为止。

4. 结果与结论

4.1源程序代码概要

?系统用到的抽象数据类型定义：

typedef struct{

int weight; //权值

int parent,lchild,rchild; //父节点，左孩子结点，右孩子结点

}HTNode,* HuffmanTree;

?系统中子程序及功能要求：

1．int min(HuffmanTree t,int i)最小二叉树

2．void select(HuffmanTree t,int i,int &s1,int &s2)选择最小二叉树

3．void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)创

建哈夫曼树

4．void init()初始化

5．void inputcode() 输入

6．void encode() 编码功能

7．void coprint(HuffmanTree start,HuffmanTree HT)输出哈夫曼树的函数

8．void printree(HuffmanTree HT,int w) //输出哈夫曼树

9．void printhead()打印界面

?各程序模块之间的调用关系（子程序编号见上）：

主函数可调用子程序4,6,8,9

子程序3可调用子程序1,2

子程序4可调用子程序3，5，7

4.2关键程序代码段详细描述

?创建最优二叉树算法描述如下：

int min(HuffmanTree t,int i)

{

int j,flag;

int k=UINT_MAX; // 取k为不小于可能的值

for(j=1;j<=i;j++)

if(t[j].weight

k=t[j].weight,flag=j;

t[flag].parent=1;

return flag; //返回标识符

}

void select(HuffmanTree t,int i,int &s1,int &s2)//选择最小的两个值建立二叉树{

int j;

s1=min(t,i);

s2=min(t,i);

if(s1>s2)// s1为最小的两个值中序号小的那个

{

j=s1;

s1=s2;

s2=j;

}

}

逆向求哈夫曼编码描述如下：

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)

{

int m,i,s1,s2,start;

int c,f;

HuffmanTree p;

char *cd;

if(n<=1)

return;

m=2*n-1;

HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); // 0号单元未用

for(p=HT+1,i=1;i<=n;++i,++p,++w)

{

p->weight=*w;

p->parent=0;

p->lchild=0;

p->rchild=0;

}

for(;i<=m;++i,++p)

p->parent=0;

for(i=n+1;i<=m;++i) // 建哈夫曼树

{

select(HT,i-1,s1,s2);

HT[s1].parent=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*));

cd=(char*)malloc(n*sizeof(char));

cd[n-1]='\0';

for(i=1;i<=n;i++)

{

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]);

}

free(cd);

}

初始化哈夫曼树求算法描述如下：

void init()

{

flag=1;

int num;

int num2;

cout<<"下面初始化赫夫曼链表"<>num;

n=num;

line();

w=(int*)malloc(n*sizeof(int));//weight

z=(char*)malloc(n*sizeof(char));//word

cout<<"\n请依次输入"<

char temp[2];

line();

for(i=0;i

{

cout<<"第"<

gets(temp);

*(z+i)=*temp;

}

line();

for(i=0;i<=n-1;i++)

{

cout<

}

line();

cout<<"\n请依次输入"<

line();

for(i=0;i<=n-1;i++)

{

cout<

cin>>num2;

*(w+i)=num2;

}

//输入部分结束

HuffmanCoding(HT,HC,w,n);//输出编码

line();

cout<<"字符对应的编码为:"<

for(i=1;i<=n;i++)

{

cout<<"字符"<<*(z+i-1)<<"的编码";

puts(HC[i]);

}

将获取的字符哈夫曼树编码写入文件算法描述如下：

void inputcode()

{

FILE *virttran,*tobetran;

char str[100];

if((tobetran=fopen("tobetran.txt","w"))==NULL)

{

cout<<"不能打开文件"<

return;

}

cout<<"请输入你想要编码的字符"<

gets(str);

fputs(str,tobetran);

cout<<"获取字符成功"<

fclose(tobetran);

}

line();

cout<<"下面将哈夫曼编码写入文件"<

FILE *htmTree;

char r[]={' ','\0'};

if((htmTree=fopen("htmTree.txt","w"))==NULL)

{

cout<<"文件打开失败"<

return;

}

fputs(z,htmTree);

for(i=0;i

{

fprintf(htmTree,"%6d",*(w+i));

fputs(r,htmTree);

}

for(i=1;i<=n;i++)

{

fputs(HC[i],htmTree);

fputs(r,htmTree);

}

fclose(htmTree);

cout<<"已将字符与对应编码写入根目录下文件htmTree.txt中"<

}

哈夫曼树编码算法描述如下：

void encode() //完成编码功能

{

cout<<"下面对目录下文件tobetran.txt中的字符进行编码"<

FILE *tobetran,*codefile;

if((tobetran=fopen("tobetran.txt","rb"))==NULL)

{

cout<<"不能打开文件"<

}

if((codefile=fopen("codefile.txt","wb"))==NULL)

{

cout<<"不能打开文件"<

}

char *tran;

i=99;

tran=(char*)malloc(100*sizeof(char)); //为tuan分配100个字节

while(i==99)

{

if(fgets(tran,100,tobetran)==NULL)

{

cout<<"不能打开文件"<

break;

}

for(i=0;*(tran+i)!='\0';i++)

{

for(j=0;j<=n;j++)

{

if(*(z+j-1)==*(tran+i))

{

fputs(HC[j],codefile);

puts(HC[j]);

if(j>n)

{

cout<<"字符错误，无法编码!"<

break;

}

}

}

}

}

cout<<"编码工作完成"<

fclose(tobetran);

fclose(codefile);

free(tran);

}

输出哈夫曼树算法描述：

void coprint(HuffmanTree start,HuffmanTree HT)

{char t=' ';

if(start!=HT)

{

FILE * TreePrint;

if((TreePrint=fopen("TreePrint.txt","a"))==NULL)

{cout<<"创建文件失败"<

return;

}

numb++;//该变量为已被声明为全局变量

coprint(HT+start->rchild,HT);

if(start->lchild!=NULL&&start->rchild!=NULL) t='<';

cout<weight<

fprintf(TreePrint,"%d\n",start->weight);

coprint(HT+start->lchild,HT);

numb--;

fclose(TreePrint);

}

}

void printree(HuffmanTree HT,int w) //输出哈夫曼树

{

HuffmanTree p;

p=HT+w;

cout<<"下面输出赫夫曼树"<

coprint(p,HT);

line();

cout<<"输出工作结束"<

}

4.3程序运行结果

（1）系统初始化界面如图4.1所示。

图4.1 系统初始化界面

（2）初始化哈夫曼链表界面如图4.2所示。

图4.2.1 初始化哈夫曼链表输入字符界面

图4.2.2 初始化哈夫曼链表输入权值界面

图4.2.3 初始化哈夫曼链表输出编码界面（3）系统输出特定字符编码如图4.3所示。

图4.3 系统输出特定字符编码（4）输出哈夫曼树如图4.4所示。

图4.4 输出哈夫曼树界面（5）哈夫曼编码系统退出的界面如图4.5所示。

图4.5 哈夫曼编码系统退出界面

4.4 课程设计总结

通过本次设计，明白了利用哈夫曼编码进行信息通讯可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对传输数据预先进行编码，在接收端将传来的数据进行复原。在当今信息爆炸时代，如何采用有效的数据压缩技术节省数据文件的存储空间和计算机网络的传送时间已越来越引起人们的重视，哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。对于于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编码系统。哈夫曼编码正是一种应用广泛且非常有效的数据压缩技术。

在设计中遇到的困难有：

(1)对数组、链表及结构体掌握不牢,使得在编程时不能灵活运用，以后需加强;

(2)专业英语能力不强，在调试过程中不能理解错误提示,此方面也需努力.

5. 收获与致谢

总的来说,在整个设计的过程中,对文件的知识有了相当程度的了解掌握,基本上学会了对文件的设计和对文件的操作等。在对文件的自学过程中也认识，在学习的过程中要灵活的把所学的知识运用到实践当中，并且还要巩固练习和运用，这样才可以牢牢的记住。试验也对数据结构的知识进行了复习，尤其是二叉树及哈夫曼编码等知识点，在对程序不断的修改和逐步改进提升的过程中，积累了不少经验，为在以后的学习和实

践应用奠定了一定的基础。

这次课程设计受益非浅，学到了不少知识，同时也认识到自身的不足，需要加强自身训练，学以致用，学会自我总结，吸取教训，积累经验，在学习和实践中来不断的提升自己。

6. 参考文献

[1] C++程序设计教程（钱能修订版，清华大学出版社）；

[2] 数据结构（吴伟民等c 语言版，清华大学出版社）；

[3] 数据结构实验教程（高晓兵等，清华大学出版社）；

[4] 算法分析与设计（郑宗汉、郑晓明，清华大学出版社）。

7. 附件

附源程序：

#include

#include

#include

#include

#include

const int UINT_MAX=1000;

typedef struct

{

int weight; //权值

int parent,lchild,rchild; //父节点，左孩子结点，右孩子结点

}HTNode,* HuffmanTree;

typedef char **HuffmanCode;

HuffmanTree HT; //代表哈夫曼树

HuffmanCode HC; //代表哈夫曼编码

int *w,i,j,n;

char *z;

int flag=0;

int numb=0;

// 求哈夫曼编码

void line()

{cout<<"\n--------------------------------------------------\n";}

int min(HuffmanTree t,int i)

{

int j,flag;

int k=UINT_MAX; // 取k为不小于可能的值

for(j=1;j<=i;j++)

if(t[j].weight

k=t[j].weight,flag=j;

t[flag].parent=1;

return flag; //返回标识符

}

void select(HuffmanTree t,int i,int &s1,int &s2)

{

int j;

s1=min(t,i);

s2=min(t,i);

if(s1>s2)// s1为最小的两个值中序号小的那个

{

j=s1;

s1=s2;

s2=j;

}

}

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n) {

int m,i,s1,s2,start;

int c,f;

HuffmanTree p;

char *cd;

if(n<=1)

return;

m=2*n-1;

HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); // 0号单元未用

for(p=HT+1,i=1;i<=n;++i,++p,++w)

{

p->weight=*w;

p->parent=0;

p->lchild=0;

p->rchild=0;

}

for(;i<=m;++i,++p)

p->parent=0;

for(i=n+1;i<=m;++i) // 建哈夫曼树

{

select(HT,i-1,s1,s2);

HT[s1].parent=HT[s2].parent=i;

HT[i].lchild=s1;

HT[i].rchild=s2;

HT[i].weight=HT[s1].weight+HT[s2].weight;