北邮信通院数据结构实验报告三哈夫曼编码器

数据结构实验报告
实验名称:实验三树——哈夫曼编／解码器
学生姓名:
班级:
班内序号：
学号:
日期:２014年12月11日
1.实验要求
利用二叉树结构实现赫夫曼编/解码器。

基本要求：
1、初始化(Iｎiｔ):能够对输入得任意长度得字符串s进行统计,统计每个
字符得频度,并建立赫夫曼树
2、建立编码表(CreaｔeTabｌｅ)：利用已经建好得赫夫曼树进行编码,并
将每个字符得编码输出。

3、编码(Encｏｄing）:根据编码表对输入得字符串进行编码,并将编码后
得字符串输出。

4、译码(Ｄecｏding）：利用已经建好得赫夫曼树对编码后得字符串进行译
码，并输出译码结果。

5、打印(Ｐrint)：以直观得方式打印赫夫曼树(选作）
6、计算输入得字符串编码前与编码后得长度,并进行分析,讨论赫夫曼编
码得压缩效果。

测试数据:
I lｏvｅdata Sｔｒｕcture, I lovｅputｅr。

I wiｌｌtrｙmy best ｔｏsｔudy ｄata Structure、
提示：
１、用户界面可以设计为“菜单”方式:能够进行交互。

2、根据输入得字符串中每个字符出现得次数统计频度,对没有出现得ﻩ字符一律不用编码。

2、程序分析
2、1存储结构
Ｈuffmａn树
给定一组具有确定权值得叶子结点,可以构造出不同得二叉树,其中带权路径长度最小得二叉树称为Hｕffｍan树,也叫做最优二叉树。

wｅighｔlchilｄｒcｈｉld paｒｅnt
２－1－1-1
5－1-1-1
6-1－1-1
7-１－1-1
９-１-1-1
wｅigｈt lchild rchilｄparent 2-1-15
5-1－15
6-１－16
7-１－１6
9-１-17
7017
１3２38
16548
2967-1
2、2 关键算法分析
(1)计算出现字符得权值
利用AＳCII码统计出现字符得次数,再将未出现得字符进行筛选,将出现得字符及頻数存储在数组ａ[]中。

void Huffmａn::Iｎｉt()
{
ﻩｉｎｔｎNｕm［256]＝ {0}；／/记录每一个字符出现得次数ｉnｔ ch = cin、get();
ｉnt i=0;
ﻩwｈｉle(（ｃｈ!='\r') ＆& （ch!='\n'）)
ﻩ｛
ﻩﻩｎＮｕm[cｈ]＋＋; ／/统计字符出现得次数
ﻩstr[i＋+] ＝ cｈ; //记录原始字符串ﻩcｈ = cin、geｔ（）; //读取下一个字符
ﻩ}
str[ｉ]='\0';
n = 0;
for ( ｉ=０;ｉ＜256;i＋+)
ﻩ｛
ﻩﻩｉｆ(nNｕm[i]>０) /／若nＮum[i］==0,字符未出现
ﻩ{
l[ｎ] = (cｈａｒ)i;
ﻩa［ｎ] = nNum[ｉ]；
n++;
ﻩ}
}
}
时间复杂度为O(１);
（2）创建哈夫曼树:
算法过程:
Huffman树采用顺序存储---数组;
数组得前ｎ个结点存储叶子结点,然后就是分支结点,最后就是根结点；
首先初始化叶子结点元素—循环实现；
以循环结构，实现分支结点得合成，合成规则按照hｕfｆmaｎ树构成规则进行。

关键点:选择最小与次小结点合成。

vｏid Hｕffmａn::CｒeateHTｒee（)
{
ﻩHTree = nｅｗＨNoｄe [2*n-１]；/／根据权重数组a[0、、n-1] 初始化Huffmａn树foｒ (int j = 0；j ＜ n；ｊ++)
{
ﻩHTrｅe[j]、weｉght ＝ａ[j];
ﻩﻩＨＴreｅ[ｊ]、LChｉld = ＨTree[j]、RChｉｌｄ = HTreｅ[j]、pａrent ＝ -1;
ﻩ}
inｔｘ,y；
fｏr （int i = n; i < 2*ｎ－1; i+＋）／/开始建Ｈufｆman树{
SelｅctＭin（HTree, i, x, y)；ﻩ／/从1~i中选出两个权值最小得结点
ＨTｒee[x]、parｅnt = HTｒee[ｙ]、parｅｎt = ｉ;
ﻩHＴreｅ[i]、wｅiｇht = HTreｅ[x］、wｅｉｇhｔ+ HTree［ｙ]、weight;
HＴｒeｅ［ｉ]、ＬＣhｉld = ｘ;
HＴree[i]、RChild = y；
ﻩﻩHTrｅe［i]、paｒent = -１;
ﻩ｝
}
时间复杂度为O(ｎ２）
void Huffmａn::SeleｃtMiｎ( HNode ＊hTree,inｔ n, ｉnt &i1，ｉnｔ &i２ ) {
ｉnt i;
//找一个比较值得起始值
ｆｏr(i=0; i<n; ｉ＋+) //找i1
{ if(hTree[i]、parent=＝-1 ）
｛i1=i；ｂｒｅak； }
}
ｉ++;
for( ; i＜ｎ; i++) //找i2
{ if(hTree[i]、parent==-1 )
{ i２＝i；breaｋ； }
}
iｆ(hＴree[ｉ１]、ｗeiｇｈt>hTｒeｅ[i2]、ｗeight) //i1指向最小得
｛ｉnt j=i２; i2=i1; i１＝ j; ｝/／开始找最小得两个
i＋＋;
fｏｒ( ; i＜n; i+＋)
{ iｆ（ｈTree［i］、pａreｎt==-1
&& hTreｅ［i]、weiｇht < hＴrｅｅ[i1]、wｅｉght )
{ i2＝ｉ1; ｉ１= ｉ；｝
else if( hＴｒeｅ[ｉ］、parent==－1
&& hTreｅ[i]、weiｇｈt ＜ hTreｅ［i２]、weigｈt)
{ i２=i; }
｝
｝
时间复杂度为O(n)
(３)创建编码表
算法过程:从叶子到根---自底向上
首先定义码表存储空间；
循环对n个叶子结点自底向上回溯到根，记下途径得左右关系,形成编码得逆序串;
将各个叶子结点对应得逆序串反序即可。

voｉd Huｆfｍan::CreａｔeCodｅTaｂｌe(）
{
ﻩHCodｅTable ＝ nｅw ＨCｏｄｅ[n]; //生成编码表
ﻩｆor （int i=0；i<n；i++)ﻩ
{
ﻩHCodeＴable[i]、data = l[i]；
ﻩｉｎt chilｄ= ｉ；ﻩ/／孩子结点编号
ﻩiｎｔ parenｔ= HTreｅ[ｉ]、parent; //当前结点得父结点编号int k=0;
ﻩｗhilｅ（parent!＝-1)
ﻩﻩ{
ﻩif (cｈild==HＴｒeｅ［ｐareｎt]、LCｈild) ﻩ／/左孩子标‘０’ﻩﻩＨCodeTａble[i]、ｃodｅ［k］= '０';
ﻩｅlse
ﻩＨＣodｅTａbｌe[ｉ]、codｅ[k］ = '1＇ ; ／/右孩子标‘1’ﻩﻩk++;
ﻩcｈild = pareｎt;ﻩ//迭代
ﻩﻩparenｔ = HTree[ｃhild］、paｒeｎt；
ﻩﻩ}
ﻩﻩＨＣoｄeTablｅ[i]、cｏｄe［k] = '\0';
Reverse（HCodeTable[i]、codｅ）; ／／将编码字符逆置
ﻩ}
}
时间复杂度为Ｏ（ｎ)
(4)生成编码串
将输入得字符串得每一个字符与编码表比较
void Huffman:：Encode(ｃｈar *d)//编码,ｄ为编码后得字符串{
ﻩﻩchar *s = stｒ;
ｗhｉｌe（*ｓ！=＇＼0＇)
{
ﻩﻩﻩfoｒ(ｉｎt i=0;i<n；ｉ++)
ﻩﻩﻩﻩif (*s == HCodeTabｌe[i]、daｔa ）
ﻩﻩ{
ﻩﻩﻩｓｔrｃａｔ(d, ＨCodeＴaｂle[i]、codｅ);
ﻩﻩﻩbｒeak;
ﻩﻩﻩ}
ﻩﻩs++;
ﻩ}
}
时间复杂度为O(ｎ)
(5)解码:
算法过程: 从根到叶子---自顶向下
基于huｆfman树存储数组，从根结点开始,依据输入待解码串s中码字0或１,分别向左或右跟踪至叶子结点，叶子结点对应得字符(见码表），即为解码得到得字符;
只要s串为结束，重复上述过程
void Hｕffman：:Ｄｅcoｄe(chaｒ* s, ｃｈaｒ *d)ﻩ／／解码,s为编码串,d为解码后得字符串
{
whｉｌe(*s!='\0＇)
{
ﻩint pａreｎｔ = 2*ｎ-2；ﻩﻩﻩ//根结点在HTrｅe中得下标
ﻩwｈile (ＨTreｅ[paｒeｎt]、LChild!=－１) ／/如果不就是叶子结点ﻩ｛
ﻩif (*s=='0'）
pａrｅnt = HＴree［pａrent]、ＬChilｄ;
else
ﻩﻩparent ＝ HTree［ｐａrｅnt］、RCｈiｌｄ;
ﻩs＋+;
ﻩﻩ}ﻩ
ﻩ*d ＝HCodｅＴable[pａrｅnt］、daｔa;
ﻩd＋+;
ﻩ｝
}
时间复杂度为O(n）
2、3 其她
（1）哈夫曼树得输出就是以凹入表示法来实现得,具体算法如下:
void Hｕffmaｎ::Ｐrinｔ(ｉnt i，iｎt m）
{
ﻩiｆ(HＴｒeｅ[i]、LＣhｉld == -1)
ﻩcout<<sｅｔfiｌl(' ')<＜sｅｔw（ｍ+1)＜<l[i]<<seｔfiｌl('－')<<ｓetw（1０－ｍ）<＜'\n';
ｅｌｓｅ
{
ﻩcoｕt<<setfｉｌl(' ')<<seｔw(ｍ+1)<＜HTｒｅe[ｉ］、weight＜<sｅtfill('-')<<seｔｗ(1０-m）＜<'＼n';
ﻩPrint(HTrｅe［i]、LＣhiｌd,m＋１);
ﻩﻩＰｒiｎt(HＴree[ｉ]、RＣhｉld,m＋１)；
}
}
(2）统计字符頻数时,利用字符得ASCIＩ码进行计数统计,调用了cｉｎ、ｇet()函数
3、程序运行
程序框图:
程序源代码:
#incluｄ
＃include <iomanip>
uｓing nａmespaｃe std；
ｓtruct HＮｏde
{
ﻩｉｎt weighｔ; //结点权值
iｎt paｒent;ﻩ/／双亲指针ﻩintＬChilｄ；ﻩ//左孩子指针
ﻩint RＣｈiｌd; ﻩ／／右孩子指针
struct HCoｄｅ
｛
ｃhａr dａta;
chaｒcodｅ［100］;
｝；
class Huffｍan
{
prｉvate：
HNodｅ＊HTree; /／Hufｆmａn树
HCode* HCｏdｅTａｂlｅ；/／Hufｆman编码表
chａｒｓtｒ[１024]; //输入得原始字符串ﻩchar l［256］; //叶子节点对应得字符
ｉnt a[2５6];//记录每个出现得字符得个数
public:
int n; //叶子节点数
ﻩｖoiｄInｉt()；/／初始化
vｏid ＣreａteHTrｅe(）; ﻩ //创建huffｍaｎ树
ｖoid ＣreateCodｅTａble(); ／／创建编码表
ﻩvoｉd PrinｔTaｂle()；
vｏid Encode(chaｒ＊d);//编码
voｉd Decode(chａr *s, ｃｈaｒ*d); //解码
voidＰrｉnt(int i,int m); ／/打印Huffmaｎ树
voｉｄSeｌectMin(HNode *hTreｅ,ｉnt ｎ, int &i１, iｎｔ&i2);//找出最小得两个权值
void Reveｒse(cｈａr＊ｓ）; ／／逆序
ﻩvoｉd pare（chaｒ＊d)；/／比较压缩大小
～Ｈuffman(); ／／析构
};
voｉｄHufｆmａn：:Iｎit()
{
int ｎNｕｍ[２56]＝{０}; ／/记录每一个字符出现得次数
ﻩint ch =ｃin、get();
int i=0;
ﻩwhｉle((cｈ！＝'＼ｒ＇) && (cｈ!='＼n'))
ﻩ{
ﻩﻩnNum[ch]＋+; /／统计字符出现得次数sｔr[i++] = ch；/／记录原始字符串
ch = cin、get();／/读取下一个字符 }
str［i]='\0';
foｒ（i=0;i<２5６;i++)
ﻩ｛
iｆ(ｎＮum[i]>0）//若nNum[i]==０,字符未出现ﻩﻩ{
ﻩﻩl[ｎ]= (chａr)i；
ﻩﻩﻩa[n］= nNｕm［i];
ﻩﻩn++;
}
}
}
void Huffman：:CreａteHTrｅｅ()
{
ﻩHTｒeｅ＝ｎeｗHNode [2＊n-1]; ／/根据权重数组a[0、、ｎ-1] 初始化Huffｍan树
for (ｉｎｔj = 0;j < n；ｊ＋+）
ﻩ｛
ﻩＨTree[ｊ］、ｗeighｔ=a[j];
ﻩHTree[j]、LChiｌd ＝HTree[j]、RＣhiｌd =ＨTｒee[ｊ]、parent =-1；ﻩ}
ﻩiｎｔx,y;
ﻩfｏr (iｎt ｉ= ｎ；i ＜2＊n-1；i++)ﻩ//开始建Ｈuffman树
{
ＳelｅcｔＭin( ＨＴrｅe, ｉ,x, ｙ); ﻩ /／从１～ｉ中选出两个权值最小得结点
ﻩHTrｅe[ｘ］、pａrｅnt = HTree［y]、paｒenｔ= i;
ﻩﻩHTree［i]、wｅigｈt ＝HＴｒee[x]、ｗｅight+ HTreｅ[ｙ]、weiｇｈｔ；ﻩHTrｅe[i]、LＣhild ＝ｘ;
ﻩHTreｅ[i]、RChild =ｙ；
ﻩHTreｅ[i]、pareｎｔ=-1;
}
｝
void Hｕffｍａn::ＳｅlecｔＭin( HＮode*ｈＴree,inｔn，int ＆i1, int &i2 ）
{
iｎｔi;
//找一个比较值得起始值
fｏr(i=０; i<n；i++) //找ｉ1
{ ｉｆ（ｈTree［i]、parent==-1 )
｛ｉ1=i; breａk; ｝}
i+＋;
fｏr( ；i<n; i＋+）／／找i2
{iｆ(hＴree［i]、parent==-１）
{ ｉ２=ｉ；ｂrｅak；} }
iｆ(hＴｒee［i１]、weiｇht>ｈTreｅ［i2]、ｗｅiｇht）//i1指向最小得
｛int ｊ=i2; ｉ２＝i1;ｉ1 =ｊ; ｝
//开始找最小得两个
i++;
for（; i<n; ｉ+＋）
{if(ｈTree[ｉ]、parent=＝-1
&＆hTｒee[i]、wｅigｈt < ｈTｒee[i1]、wｅｉght ) { i２=i1; i1 ＝i; }
ｅlse iｆ（hTrｅe[i]、parｅnｔ＝=-1
＆& hTree[ｉ］、wｅigｈt < hTｒｅe[ｉ2］、wｅight）{ ｉ2=i; }
}
}
voｉｄＨuffmａｎ：：Ｐrint(int i, iｎｔm)
{
ﻩｉf （HTｒｅe［i］、LChild ==-１)
ﻩｃouｔ<<setfill(' ')<<setw(m+１）<<l[i]<＜setfiｌl('－')<<setw(10-ｍ)＜<＇\n';
ﻩelse
{
ﻩcoｕt＜<ｓetfill（''）＜<ｓetｗ(m+１)＜＜ＨＴreｅ[i]、weｉgｈt<<ｓetfill('－')<＜setw(10-m）＜＜＇＼n';
Pｒint(HTree[i］、LChｉld,m+1);
ﻩPrinｔ（HTree[i]、RＣhiｌｄ,ｍ+1);
ﻩ}
}
voｉd Hufｆman::CreａtｅCｏｄｅTaｂle(）
{
ﻩHCｏｄｅTaｂle =ｎew HCode[n]; ／/生成编码表
ﻩｆoｒ(ｉnt ｉ=0;i＜n；i＋＋)ﻩ
{
ﻩﻩHCodeＴａbｌe［i]、ｄａta ＝l［i];
ﻩiｎt chiｌd= i; ﻩﻩﻩ/／孩子结点编号
int pａrenｔ= ＨTree[i］、paｒｅnt;//当前结点得父结点编号
ﻩinｔｋ=0;
ﻩwｈiｌe(parｅnｔ!＝-1)
ﻩ｛
ﻩiｆ(child＝=HTreｅ[ｐareｎt]、LCｈild）ﻩﻩ／/左孩子标‘0’
ﻩﻩﻩHCodeTａble[ｉ］、ｃoｄe[ｋ] =＇０＇;
ｅlｓｅ
ﻩﻩ HCodeTable［i]、code[k]＝'１' ;ﻩ//右孩子标‘1’ﻩk++；
ｃhiｌd = ｐarent;ﻩﻩﻩ//迭代
ﻩpａreｎt = HＴrｅe［child]、ｐarent;
ﻩﻩ}
ﻩHＣodeＴable[i]、codｅ[k]= ＇\0'；
Revｅrｓe(ＨCoｄeTabｌe[ｉ］、ｃodｅ);//将编码字符逆置ﻩ}
}
voiｄＨｕfｆman:：PrinｔＴable(）
{
ﻩfｏｒ(int i=0；i<n;i++)
ﻩcoｕt<＜HCodeＴabｌｅ[i]、daｔa<<＇\t'<＜HCｏdeTable[i]、cｏdｅ<＜e ｎdl;
}
void Ｈuffmａn::Ｅｎcode(chａr *d)//编码，ｄ为编码后得字符串
{
ﻩchａr*s＝sｔｒ;
ﻩﻩwhｉle(＊s!＝'＼０')
{
ﻩfoｒ(inｔi＝0;i<ｎ;i＋＋)
ﻩﻩif (＊ｓ=＝HＣｏdeTable[i]、data )
ﻩﻩﻩ{
ﻩﻩﻩstrcaｔ(ｄ,ＨCodeＴaｂｌe[i]、code);
ﻩﻩﻩﻩﻩbreak;
ﻩﻩ}
ﻩﻩﻩs+＋；
ﻩ｝
}
void Hｕffｍan:：Ｄｅcodｅ(cｈaｒ* ｓ,char *ｄ)ﻩ/／解码，s为编码串,d为解码后得字符串
｛
ﻩwｈiｌe(*s!＝'\0＇)
ﻩ{
ﻩint paｒent = 2*ｎ-２;ﻩﻩﻩﻩ／/根结点在HTree中得下标
whｉｌe (HＴｒee［parent]、ＬChild！＝-1)／/如果不就是叶子结点
{
ﻩif (*s=='0'）
ﻩｐarｅｎｔ=HTrｅe[parent］、ＬChild;
elsｅ
ﻩparent ＝HTrｅe[ｐareｎt］、ＲＣhｉld;
ﻩﻩﻩs++;
ﻩ}ﻩ
*ｄ＝HCodeTａbｌe[parｅnｔ]、daｔa;
ｄ++;
}
｝
voｉｄHuffman:：Rｅverse(ｃhar*ｓ)／／换序
{
char ch;
ｉnt len ＝strleｎ（s);
foｒ(int i=0；i＜ｌｅn／2;i＋+)
ﻩ{
ﻩﻩch ＝s［i];
ﻩﻩs［ｉ] ＝s［lｅn-i－1];
ﻩﻩｓ[len-i-1]=ｃh;
ﻩ}
}
voｉｄHuffmaｎ::parｅ(ｃhａr*d)//比较压缩大小
｛
cｏut<<"编码前："<＜strleｎ(str)*8<＜"bit"<＜enｄl;
ｃoｕt<<"编码后："<<strleｎ(d)<＜＂biｔ"<<eｎｄl;
｝
Huｆfman:：~ Hufｆmaｎ()//析构函数
{
delete []HTrｅe;
ﻩdelete［］ＨＣoｄeTａｂlｅ;
}
void maiｎ（）
{
ＨｕffmanＨFＣode;
ﻩchａr d［１０２４]={0}；
ﻩchaｒｓ[10２4］=｛0};
couｔ<<"请输入要编码得字符串：";
HＦCoｄｅ、Iniｔ（);
HFCode、CreatｅHTree();
HFCode、CｒeaｔeＣoｄeＴablｅ()；
ﻩHＦCoｄe、Encode(d);
ＨFCodｅ、Decode(ｄ,s);
int m；
ﻩcoｕｔ<<＂欢迎使用\ｎ"<<"１、打印哈夫曼树\n"<＜"2、打印哈夫曼编码表\n"<<＂3、打印编码＼n"<<"4、打印解码\n"＜<＂5、压缩比"<<endl；
while（1)
{cin>>m；
ﻩswitcｈ(m)
｛
ﻩcａse １：
ﻩ{
ﻩﻩＨFCodｅ、Prｉｎt(2*HFCode、n-2,1)；
ﻩbreak;
ﻩ}
ﻩcase 2:
ﻩﻩ{
ＨFＣoｄｅ、PrintTaｂlｅ( ）;
breaｋ;
ﻩﻩ}
cａse 3:
{
coｕｔ<<"编码结果:"<<d＜＜endl;
ﻩﻩbreａk;
}
ﻩcase 4:
ﻩﻩ{
ﻩﻩcout<<"解码结果:＂<<s<＜eｎdl;
ﻩbreａk;
ﻩ｝
ﻩｃaｓe 5：
ﻩﻩ｛
ﻩＨＦCode、pare(d);
ﻩﻩ｝
｝
｝
｝
运行结果:
4、总结
在编程时,最开始在字符统计时出现了空格无法统计得问题，后来用cin、gｅｔ()函数进行统计。

最后由于有一些字符没有出现过,所以还需要进行筛选。

在输出哈夫曼树时,采用了凹入函数法进行输出，更加直观。

创建编码表时，开始就是自下到上得进行遍历，所以最后还需要进行逆序，形成最终得编码表。

创建编码树得时候,没有正确运用指针得传递，结果出现了很多问题，各种内存访问错误，最后经过细细地
从头到尾检查,发现了就是在形式参数得地方出现了错误,在获取两个最小权值得结点得时候应该用引用,改过来之后错误没有了。

打印赫夫曼树就是最难得部分，一开始没有找到合适得办法,出现了很多问题,最后采用凹入表示打印得方法,从最右边得结点开始一行一行得打印,最后问题也能解决了。

调试时,出现得问题就是在进行编码时循环出现了错误,导致运行后编码变少,通过修改问题得以解决。

通过哈夫曼编码得程序设计,更加深入得学习了哈夫曼树编码得思想,了解了不等长编码得思想，同时也通过实践明白了编码器得原理,在编码过程中,面对出现得问题，也学习了字符串得相关函数得运用，更加了解树得存储结构，受益匪浅。