北邮数据结构实验报告Word文档格式.docx

北邮数据结构实验报告Word文档格式.docx

《北邮数据结构实验报告Word文档格式.docx》由会员分享，可在线阅读，更多相关《北邮数据结构实验报告Word文档格式.docx（7页珍藏版）》请在冰豆网上搜索。

　　{

　　public:

　　BiTree（）;

//构造函数，其前序序列由键盘输入

　　~BiTree（void）;

//析构函数

　　BiNode*Getroot（）;

//获得指向根结点的指针

　　protected:

　　BiNode*root;

//指向根结点的头指针

　　};

　　//声明类BiTree及定义结构BiNode

　　Data：

　　二叉树是由一个根结点和两棵互不相交的左右子树构成

　哈夫曼树类的数据域，继承节点类型为int的二叉树classHuffmanTree:

publicBiTree　　　data:

　　HCode*HCodeTable;

//编码表

　　inttSize;

//编码表中的总字符数

　　二叉树的节点结构

　　structBiNode//二叉树的结点结构{

　　Tdata;

//记录数据

　　Tlchild;

//左孩子

　　Trchild;

//右孩子

　　Tparent;

//双亲

　　编码表的节点结构

　　structHCode

　　chardata;

//编码表中的字符

　　charcode;

//该字符对应的编码

　　待编码字符串由键盘输入，输入时用链表存储，链表节点为structNode

　　charcharacter;

//输入的字符

　　unsignedintcount;

//该字符的权值

　　boolused;

//建立树的时候该字符是否使用过

　　Node*next;

//保存下一个节点的地址

　　示意图：

　　　关键算法分析

　　1.初始化函数（voidHuffmanTree:

:

Init（stringInput））

　　算法伪代码：

　　1.初始化链表的头结点

　　2.获得输入字符串的第一个字符，并将其插入到链表尾部,n=1（n记录的是链表

　　中字符的个数）

　　3.从字符串第2个字符开始，逐个取出字符串中的字符

　　将当前取出的字符与链表中已经存在的字符逐个比较，如果当前取出

　　的字符与链表中已经存在的某个字符相同，则链表中该字符的权值加1。

　　如果当前取出的字符与链表中已经存在的字符都不相同，则将其加入

　　到链表尾部，同时n++

　　=n（tSize记录链表中字符总数，即哈夫曼树中叶子节点总数）

　　5.创建哈夫曼树

　　6.销毁链表

　　源代码：

　　voidHuffmanTree:

Init（stringInput）

　　Node*front=newNode;

//初始化链表的头结点

　　if（!

front）

　　throwexception（"

堆空间用尽"

）;

　　front->

next=NULL;

character=NULL;

count=0;

　　Node*pfront=front;

　　charch=Input;

//获得第一个字符

　　Node*New1=newNode;

New1）

　　New1->

character=ch;

//将第一个字符插入链表

count=1;

next=pfront->

next;

　　pfront->

next=New1;

　　boolreplace=0;

//判断在已经写入链表的字符中是否有与当前读出的字符相同的字符intn=1;

//统计链表中字符个数

　　for（inti=1;

i

　　ch=Input;

//获得第i个字符

　　do

　　pfront=pfront->

　　if（（int）pfront->

character==（int）ch）//如果在链表中有与当前字符相同的字符，

　　该字符权值加1

count++;

　　replace=1;

　　break;

　　}

　　}while（pfront->

next）;

replace）//如果在链表中没找到与当前字符相同的字符，则将该字符作为新成员插入链表

　　Node*New=newNode;

New）

　　New->

next=New;

　　n++;

　　pfront=front;

//重置pfront和replace变量为默认值replace=0;

　　tSize=n;

//tSize记录的是编码表中字符个数

　　CreateHTree（front,n）;

//创建哈夫曼树

　　while（pfront）//销毁整个链表

　　front=pfront;

　　front;

　　时间复杂度：

　　若输入的字符串长度为n，则时间复杂度为O（n）

　　2.创建哈夫曼树（voidHuffmanTree:

CreateCodeTable（Node*p））

　　1.创建一个长度为2*tSize-1的三叉链表

　　2.将存储字符及其权值的链表中的字符逐个写入三叉链表的前tSize个结点

　　的data域，并将对应结点的孩子域和双亲域赋为空

　　3.从三叉链表的第tSize个结点开始，i=tSize

　　从存储字符及其权值的链表中取出两个权值最小的结点x,y，记录其

　　下标x,y。

　　将下标为x和y的哈夫曼树的结点的双亲设置为第i个结点

　　将下标为x的结点设置为i结点的左孩子，将下标为y的结点设置为

　　i结点的右孩子，i结点的权值为x结点的权值加上y结点的权值，i

　　结点的双亲设置为空

　　4.根据哈夫曼树创建编码表

CreateHTree（Node*p,intn）

　　root=newBiNode;

//初始化哈夫曼树

　　Node*front=p->

　　if（n==0）

没有输入字符"

　　for（inti=0;

　　root.data=front->

count;

　　root.lchild=-1;

　　root.rchild=-1;

　　root.parent=-1;

　　front=front->

　　front=p;

　　intNew1,New2;

　　for（i=n;

i　　{

　　SelectMin（New1,New2,0,i）;

//从0~i中选出两个权值最小的结点

　　root.parent=root.parent=i;

//用两个权值最小的结点生成新结点，

　　新节点为其双亲

　　root.data=root.data+root.data;

//新结点的权值为其孩子的权值的和root.lchild=New1;

　　root.rchild=New2;

　　CreateCodeTable（p）;

//创建编码表

　　在选取两个权值最小的结点的函数中要遍历链表，时间复杂度为O（n）,故该函数

　　的时间复杂度为O（n^2）

　　3.创建编码表（voidHuffmanTree:

　　1.初始化编码表

　　2.初始化一个指针，从链表的头结点开始，遍历整个链表

　　将链表中指针当前所指的结点包含的字符写入编码表中

　　得到该结点对应的哈夫曼树的叶子结点及其双亲

　　如果哈夫曼树只有一个叶子结点，将其字符对应编码设置为0

　　如果不止一个叶子结点，从当前叶子结点开始判断

　　如果当前叶子结点是其双亲的左孩子，则其对应的编码为0，否

　　则为1

　　child指针指向叶子结点的双亲，parent指针指向child指针的双亲，

　　重复的操作

　　将已完成的编码倒序

　　取得链表中的下一个字符

　　3.输出编码表

CreateCodeTable（Node*p）

　　HCodeTable=newHCode;

//初始化编码表

　　HCodeTable.data=front->

character;

//将第i个字符写入编码表

　　intchild=i;

//得到第i个字符对应的叶子节点

　　intparent=root.parent;

//得到第i个字符对应的叶子节点的双亲

　　intk=0;

　　if（tSize==1）//如果文本中只有一种字符，它的编码为0

　　HCodeTable.code='

0'

;

　　k++;

　　while（parent!

=-1）//从第i个字符对应的叶子节点开始，寻找它到根结点的路径

　　if（child==root.lchild）//如果当前结点为双亲的左孩子，则编码为0，

　　否则编码为1

　　else

1'

　　child=parent;

　　parent=root.parent;

'

　　Reverse（HCodeTable.code）;

//将编码逆置

//得到下一个字符

　　cout　　for（i=0;

　　cout　　parent=root.lchild;

　　else//编码为1则寻找右孩子

　　parent=root.rchild;

　　i++;

　　if（tSize==1）//如果编码表只有一个字符，则根结点即为叶子结点i++;

　　（1,HCodeTable.data）;

//将叶子节点对应的字符追加到解码串中}

　　cout　　}

　　设待解码串长度为n，则复杂度为O（n）

　　8.计算哈夫曼编码的压缩比（voidHuffmanTree:

Calculate（strings1,strings2））算法伪代码：

　　1.获得编码前字符串的长度，即其占用的字节数

　　2.获得编码后的字符串的长度，将其除以8然后向上取整，得到其占用的字

　　节数

　　3.压缩比将两个相除

Calculate（strings1,strings2）

　　intcal1=（）;

　　intcal2=（）;

　　cal2=ceill（（float）cal2/8）;

//将编码串的比特数转化为字节数cout　　cout　　cout　　}

　　O

（1）

　　9.打印哈夫曼树（voidHuffmanTree:

PrintTree（intTreeNode,intlayer））算法伪代码：

　　1.如果待打印结点为空，则返回

　　2.递归调用函数打印当前结点的右子树

　　3.根据当前结点所在的层次确定其前面要输出多少空格，先输出空格，在打

　　印当前结点的权值

　　4.递归调用函数打印当前结点的左子树

PrintTree（intTreeNode,intlayer）

　　if（TreeNode==-1）//如果待打印结点为空，则返回return;

　　PrintTree（root.rchild,layer+1）;

//先打印该结点的右子树，layer记录

　　的是该结点所在的层次

　　空格

　　cout　　cout　　PrintTree（root.lchild,layer+1）;

//打印该结点的左子树

　　中序遍历哈夫曼树，复杂度为O（n）

　　10.菜单函数（voidHuffmanTree:

Menu（））

　　1.逐一读取键盘缓存区中的字符，并将它们逐一追加到记录输入字符串的

　　string变量中，直到读到回车输入符为止

　　2.删除string变量末尾的回车输入符

　　3.利用string变量创建哈夫曼树，初始化编码表。

　　4.直观打印哈夫曼树

　　5.对输入的字符串进行编码

　　6.对编码后的字符串进行解码

　　7.计算编码前后的压缩比并输出

Menu（）

　　cout　　stringInput;

　　charletter;

　　do//将字符逐个读入Input变量中

　　letter=（）;

　　（1,letter）;

　　}while（letter!

='

'

　　（（）-1,1）;

//去掉Input末尾的回车符

　　Init（Input）;

//根据输入的字符串创建哈夫曼树及其编码表cout　　PrintTree（2*tSize-1-1,1）;

//打印哈夫曼树

　　cout　　stringd1,d2;

　　cout　　Encode（Input,d1）;

//编码并打印编码串

　　cout　　Decode（d1,d2）;

//解码并打印解码串

　　cout　　Calculate（Input,d1）;

//计算编码前后的压缩比

　　其他

　　1.由于题目要求能输入任意长的字符串，所以本程序采用了string变量来记录输入

　　的字符串，并采用string类的类成员函数来完成各项任务

　　2.打印哈夫曼树时采用了递归函数，且采用了凹凸表的形式打印哈夫曼树。

　　3.为了输入空格，输入时采取逐个字符输入的方式

　　3.程序运行结果

　　主函数流程图：

　　　运行结果：

　　　　各函数运行正常，没有出现bug

　　4.总结

　　经过这次实验，我了解了哈夫曼树的创建过程，了解了一种不等长编码的方法，用设断点调试的方法更加熟练，同时熟悉了STL中string类型的用法，对C++更加熟悉