哈夫曼编码毕业课程设计报告Word文档格式.docx

哈夫曼编码毕业课程设计报告Word文档格式.docx

《哈夫曼编码毕业课程设计报告Word文档格式.docx》由会员分享，可在线阅读，更多相关《哈夫曼编码毕业课程设计报告Word文档格式.docx（39页珍藏版）》请在冰豆网上搜索。

Huffman编码是一种可变长编码方式，是由美国数学家DavidHuffman创立的，是二叉树的一种特殊转化形式。

编码的原理是：

将使用次数多的代码转换成长度较短的代码，而使用次数少的可以使用较长的编码，并且保持编码的唯一可解性。

Huffman算法的最根本的原则是：

累计的（字符的统计数字*字符的编码长度）为最小，也就是权值（字符的统计数字*字符的编码长度）的和最小。

B哈夫曼树构造算法：

Huffman树是二叉树的一种特殊转化形式。

以下是构件Huffman树的例子：

比如有以下数据，ABFACGCAHGBBAACECDFGFAAEABBB先进行统计A（8）B（6）C（4）D

（1）E

（2）F（3）G（3）H

（1）括号里面的是统计次数

生成Huffman树：

每次取最小的那两个节点（node）合并成一个节点（node），并且将累计数值相加作为新的接点的累计数值，最顶层的是根节点（root）注：

列表中最小节点的是指包括合并了的节点在内的所有节点，已经合并的节点不在列表中

运算的过程如下：

1:

D+H

（2）

2:

DE+H（4）

3:

F+G（6）

4:

C+DEH（8）

5:

B+FG（12）

6:

A+CDEH（16）

7:

ACDEH+BFG（28）

那么转化为Huffman树就是

Huffman树层数

Root

┌┴┐

ACDEHBFG1

┌┴┐┌┴┐

CDEHABFG2

┌┴┐┌┴┐

DEHCFG3

DHE4

┌┴┐

DH5

取左面是1右面是0则有。

注：

层数就是位数或者说是代码长度，权值=代码长度*该字的统计次数。

代码位数权值

A=10216

B=01212

C=110312

D=1111155

E=111048

F=00139

G=00026

H=1111055

可以看出Huffman代码是唯一可解的（uniquelydecodable），如果你读到110就一定是C，不会有任何一个编码是以110开始的。

如果不使用Huffman算法，而使用普通的编码，结果是什么呢？

Root

ABCDEFGH1

ABCDEFGH2

┌┴┐┌┴┐┌┴┐┌┴┐

ABCDEFGH3

取左面是1右面是0则有

代码位数权值

A=111324

B=110318

C=101312

D=10033

E=01136

F=01039

G=00139

H=00033

利用Huffman编码得到的权值累计是73，如果利用普通定长编码的话，则要用84字符长度。

从这个比较，可以看出，Huffman是怎么进行压缩的。

C哈夫曼编码结构及算法

编码：

将ABCDEFGH用Huffman树产生的编码对应着写到文件中，并且保留原始的Huffman树，主要是编码段的信息。

一般要编码256个元素的话需要511个单位来储存Huffman树，每个Huffman树都必须有以下的结构：

code,char,left,right,probability（出现次数），通常情况是利用一个数组结构。

因为在解码的时候只需要用到code，所以只需要记录每个元素的编码就可以了。

解码：

利用文件中保存的Huffman编码，一一对应，解读编码，把可变长编码转换为定长编码。

2．解压缩算法部分

A.基于字符匹配的解压算法

读出结点数就能知道哈夫曼树存入部分的总长，方便读出树哈夫曼树（子结点值和权值），就能由次些信息重新构造完整的哈夫曼树，和各结点的哈夫曼编码。

解压时，读取一个字节（8bit）用一个函数转换为8个字符（用一个数组记录，其元素只是一个0或一个1），然后按哈夫曼树从顶向下查找，如果到达叶子结点，就读出该叶子结点的值，放入缓冲区中，如果不是，则继续找，如此重复，直到缓冲区满了，就写入到解压文件中，再循环以上过程，直到处理完所有数据。

B.缓冲输入输出

和压缩时采用1M二级缓冲相同，如果的压缩时也采用此技术，也会有很大的速度优化，当然程序也变得更加复杂。

四用户使用说明

1.运行huffman.exe程序，出现下面的界面

2.选择相应的功能，输入正确文件路径，对文件进行压缩、解压。

五设计心得体会

通过这次课题实验的程序实践，我实在获益匪浅！

数据结构是本学期开展的一门学科，学习好这门学科是非常重要的，在以后的程序设计方面这门学科能给我们很大的帮助。

同时，学习这门学科也是艰辛的，因为它比较难懂，这不仅需要我们要发挥我们的聪明才志，还需要我们在不断的实践中领悟。

六附录

程序清单

在此，给出huffman.exe的程序清单。

#include<

fstream>

iostream>

String>

cmath>

usingnamespacestd;

structHTNode

{

chardata;

//节点数据

intweight;

//权值

intparent;

//父亲

intleftchild;

//左孩子

intrightchild;

//右孩子

};

typedefchar*Code;

HTNode*ht;

Code*hcd;

intmaplist[256];

//建立字符与哈夫曼编码的映射

intnodenum=0;

//哈夫曼树结点数

intrearnum=0;

//哈夫曼编码尾补码

inttextlen=0;

//需压缩的文件长度

intcodelen=0;

//压缩后的文件的哈夫曼编码总长度

intconstbufferlen=1024;

//设置读取缓冲区长度

intclean（）;

//清空节点及编码指针内容

voiddtobin（intnum,intbin[8]）;

//十进制变换成二进制

voidHTCreate（HTNodeht[],intn）;

//建立哈夫曼树

voidHCCreat（HTNodeht[],Codehcd[],intn）;

//提取哈夫曼编码

voidWriteFile（char*tmp）;

//写入文件

unsignedcharConvertBinary（char*tmp）;

//变换二进制文件

voidConvertFile（Codehcd[],stringfileadd,stringfileadd2）;

//压缩并解压文件

boolInitFromFile（stringfileadd）;

//初始化文件

voidDecompressionFile（stringfileadd2,stringfileadd3）;

//解压文件

stringCompression（stringfileadd）;

//压缩文件

stringDecompression（stringfileadd2）;

//解压文件子函数

///////////////十进制转二进制函数/////////////////

intclean（）

delete[]ht;

delete[]hcd;

return1;

}

voiddtobin（intnum,intbin[8]）

inti=0;

for（i=0;

i<

8;

i++）

{

bin[i]=0;

}

i=0;

while（num>

0）

bin[8-1-i]=num%2;

num=num/2;

i++;

//////////////////压缩和写入文件//////////////////

voidConvertFile（Codehcd[],stringfileadd,stringfileadd2）

fstreaminfile（fileadd.c_str（）,ios:

:

in|ios:

binary）;

fstreamoutfile（fileadd2.c_str（）,ios:

out|ios:

if（!

infile）cout<

<

"

openfilefail!

endl;

outfile）cout<

creatfilefail!

//unsigned

charch;

/////////////写入哈夫曼树//////////////

ch=nodenum;

outfile.write（&

ch,1）;

///写入结点数

ch=8;

///写入补位数（预写入）

codelen=0;

outfile.write（（char*）&

codelen,4）;

//写入压缩后的文件的哈夫曼编码总长度（预写入）

inth=0;

for（h=0;

h<

nodenum;

h++）

outfile.write（（char*）&

ht[h].data,sizeof（char））;

ht[h].weight,sizeof（int））;

chartmp[8];

//设置缓冲区

charoutbuffer[bufferlen];

//设置写入缓冲区

char*tmpcd;

inti=0,j,k,last=0;

charinbuffer[bufferlen];

intreadlen=0;

//infile.seekg（i,ios:

beg）;

h=0;

do

infile.read（inbuffer,bufferlen）;

readlen=infile.gcount（）;

tmpcd=hcd[maplist[（unsignedchar）inbuffer[i]]];

readlen;

）

for（j=last;

j<

8&

&

*tmpcd!

='

\0'

;

j++）

tmp[j]=*tmpcd;

tmpcd++;

if（j==8&

*tmpcd=='

last=0;

ch=ConvertBinary（tmp）;

//cout<

'

（unsignedint）ch<

'

outbuffer[h]=ch;

h++;

codelen++;

//压缩文件长度加一

if（h==bufferlen）

outfile.write（outbuffer,bufferlen）;

if（i<

readlen）tmpcd=hcd[maplist[（unsignedchar）inbuffer[i]]];

else

{

i=0;

break;

}

elseif（j<

last=j;

{i=0;

break;

/////继续循换////

elseif（j==8&

//WriteFile（tmp）;

while（readlen==bufferlen）;

readlen<

bufferlen）

outfile.write（outbuffer,h）;

for（k=j;

k<

k++）

tmp[k]='

0'

cout<

ch=8-j;

rearnum=8-j;

outfile.seekp（1,ios:

//写入真正的补位数

outfile.seekp（2,ios:

outfile.write（（char*）&

//写入真正的压缩后的文件的哈夫曼编码总长度长度

outfile.close（）;

infile.close（）;

//////////////构造哈夫曼树////////////

voidHTCreate（HTNodeht[],intn）

inti,k,lnode,rnode;

intmin1,min2;

2*n-1;

ht[i].parent=ht[i].rightchild=ht[i].leftchild=-1;

for（i=n;

min1=min2=;

lnode=rnode=-1;

for（k=0;

=i-1;

if（ht[k].parent==-1）

if（ht[k].weight<

min1）

min2=min1;

min1=ht[k].weight;

rnode=lnode;

lnode=k;

elseif（ht[k].weight<

min2）

min2=ht[k].weight;

rnode=k;

ht[lnode].parent=i;

ht[rnode].parent=i;

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

ht[i].leftchild=lnode;

ht[i].rightchild=rnode;

///////////构造哈夫曼编码/////////////

voidHCCreat（HTNodeht[],Codehcd[],intn）

inti,p,c;

Codehc;

hc=newchar[n];

intstart,tmplen;

n;

tmplen=0;

start=n-1;

hc[start]='

c=i;

p=ht[i].parent;

while（p!

=-1）

if（ht[p].leftchild==c）//是左孩子结点

hc[--start]='

tmplen++;

1'

c=p;

p=ht[p].parent;

hcd[i]=newchar[n-start];

strcpy（hcd[i],&

hc[start]）;

delete[]hc;

voidWriteFile（char*tmp）

inti;

tmp[i];

tmp="

unsignedcharConvertBinary（char*tmp）

charch=0;

ch=（unsignedchar）pow（2.0,8-i-1）*（tmp[i]-48）+ch;

returnch;

//////////////打开文件//////////////

boolInitFromFile（stringfileadd）

binary|ios:

in）;

infile）{cout<

error!

return0;

inttable[256];

inti,j;

intlen=0,num=0;

unsignedcharch;

256;

i++）{table[i]=0;

maplist[i]=-1;

charbuffer[bufferlen];

//设置读取缓冲区,加快读取速度

infile.read（buffer,bufferlen）;

while（i<

readlen）

ch=（unsignedchar）buffer[i];

table[ch]++;

len++;

if（table[i]!

=0）num++;

ht=newHTNode[2*num-1];

hcd=newCode[num];

for（i=0,j=0;

=0）

ht[j].data=i;

ht[j].weight=table[i];

maplist[i]=j;

j++;

nodenum=num;

textlen=len;

infile.clear（）;

/////////////从文件解压////////////////////

voidDecompressionFile（stringfileadd2,stringfileadd3）

............解压并输出新文件过程:

fstreaminfile（fileadd2.c_str（）,ios:

fstreamoutfile（fileadd3.c_str（）,ios:

/////////////////读出哈夫曼树的数据/////////////

//读入文件的缓冲区

//写入文件的缓冲区

infile.read（buffer,1）;

nodenum=（unsignedchar）*buffer;

//哈夫曼树结点数

if（nodenum==0）nodenum=256;

rearnum=（unsignedchar）*buffer;

infile.read（（char*）&

读出哈夫曼树数据...."

ht=newHTNode[2*nodenum-1];

hcd=newCode[nodenum];

//hcdlen=newint[nodenum];

infile.read（&

ht[h].data,1）;

ht[h].weight,4）;

//////构走哈夫曼树///////

HTCreate（ht,nodenum）;

//////构造哈夫曼编码/////

HCCreat（ht,hcd,nodenum）;

///////////////////////解压并输出解压文件////////////////////////

char*buffertmp=newchar;

intbin[8],j=0,i=0;

intcoderead=0;

//记录以度的长度,用于判断何时达到文件最后一字节（用codelen比较）

intchild=0;

intlast=2*