2024年北京邮电大学信通院数据结构实验三哈夫曼树实验报告.doc

级数据结构试验报告
试验名称： 试验三——哈夫曼编/解码器的实现
学生姓名：陈聪捷
日 期： 11月28日
1．试验要求
一、试验目标：
了解哈夫曼树的思想和有关概念；

二、试验内容：
利用二叉树结构实现哈夫曼编/解码器
1.初始化：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立哈夫曼树。
2.建立编码表：利用已经建好的哈夫曼树进行编码，并将每个字符的编码输出。
3.编码：依照编码表对输入的字符串进行编码，并将编码后的字符串输出。
4.译码：利用已经建好的哈夫曼树对编码后的字符串进行译码，并输出译码成果。
5.打印：以直观的方式打印哈夫曼树。
6.计算输入的字符串编码前和编码后的长度，并进行分析，讨论哈夫曼编码的压缩效果。
7.用户界面能够设计成“菜单”方式，能进行交互，依照输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
2. 程序分析
2.1 存储结构
二叉树
template <class T>
class BiTree
{
public:
BiTree(); //结构函数，其前序序列由键盘输入
~BiTree(void); //析构函数
BiNode<T>* Getroot(); //取得指向根结点的指针
protected:
BiNode<T> *root; //指向根结点的头指针
};
//申明类BiTree及定义结构BiNode
Data：
二叉树是由一个根结点和两棵互不相交的左右子树组成
二叉树中的结点具备相同数据类型及层次关系

示意图： root

lchild parent rchild

哈夫曼树类的数据域，继承节点类型为int的二叉树
class HuffmanTree:public BiTree<int>
data:
HCode* HCodeTable;//编码表
int tSize; //编码表中的总字符数

二叉树的节点结构
template <class T>
struct BiNode //二叉树的结点结构
{
T data; //统计数据
T lchild; //左孩子
T rchild; //右孩子
T parent; //双亲
};
示意图：
T parent
T rchild
T lchild
T data

编码表的节点结构
struct HCode
{
char data; //编码表中的字符
char code[100]; //该字符对应的编码
};
示意图：
char code[100]
char data

待编码字符串由键盘输入，输入时用链表存储，链表节点为
struct Node
{
char character; //输入的字符
unsigned int count;//该字符的权值
bool used; //建立树的时候该字符是否使用过
Node* next; //保存下一个节点的地址
};
Node* next
bool used
unsigned int count
char character
示意图：

2.2 核心算法分析
1.初始化函数（void HuffmanTree::Init(string Input)）
算法伪代码：
1.初始化链表的头结点
2.取得输入字符串的第一个字符，并将其插入到链表尾部,n=1(n统计的是链表中字符的个数)
3.从字符串第2个字符开始，逐一取出字符串中的字符
3.1 将目前取出的字符与链表中已经存在的字符逐一比较，假如目前取出的字符与链表中已经存在的某个字符相同，则链表中该字符的权值加1。
3.2 假如目前取出的字符与链表中已经存在的字符都不相同，则将其加入到链表尾部，同时n++
4.tSize=n(tSize统计链表中字符总数，即哈夫曼树中叶子节点总数)
5.创建哈夫曼树
6.销毁链表
源代码：
void HuffmanTree::Init(string Input)
{
Node *front=new Node; //初始化链表的头结点
if(!front)
throw exception("堆空间用尽");
front->next=NULL;
front->character=NULL;
front->count=0;
Node *pfront=front;
char ch=Input[0]; //取得第一个字符
Node* New1=new Node;
if(!New1)
throw exception("堆空间用尽");
New1->character=ch; //将第一个字符插入链表
New1->count=1;
New1->next=pfront->next;
pfront->next=New1;
bool replace=0; //判断在已经写入链表的字符中是否有与目前读出的字符相同的字符
int n=1; //统计链表中字符个数
for(int i=1;i<Input.length();i++)
{
ch=Input[i]; //取得第i个字符
do
{
pfront=pfront->next;
if((int)pfront->character == (int)ch) //假如在链表中有与目前字符相同的字符，该字符权值加1
{
pfront->count++;
replace=1;
break;
}
}while(pfront->next);
if(!replace) //假如在链表中没找到与目前字符相同的字符，则将该字符作为新成
员插入链表
{
Node* New=new Node;
if(!New)
throw exception("堆空间用尽");
New->character=ch;
New->count=1;
New->next=pfront->next;
pfront->next=New;
n++;
}
pfront=front; //重置pfront和replace变量为默认值
replace=0;
}
tSize=n; //tSize统计的是编码表中字符个数
CreateHTree(front,n); //创建哈夫曼树
pfront=front;
while(pfront) //销毁整个链表
{
front=pfront;
pfront=pfront->next;
delete front;
}
时间复杂度：
若输入的字符串长度为n，则时间复杂度为O(n)

2.创建哈夫曼树（void HuffmanTree::CreateCodeTable(Node *p)）
算法伪代码：
1. 创建一个长度为2*tSize-1的三叉链表
2. 将存储字符及其权值的链表中的字符逐一写入三叉链表的前tSize个结点的data域，并将对应结点的孩子域和双亲域赋为空
3. 从三叉链表的第tSize个结点开始，i=tSize
3.1 从存储字符及其权值的链表中取出两个权值最小的结点x,y，统计其下标x,y。
3.2 将下标为x和y的哈夫曼树的结点的双亲设置为第i个结点
3.3 将下标为x的结点设置为i结点的左孩子，将下标为y的结点设置为i结点的右孩子，i结点的权值为x结点的权值加上y结点的权值，i结点的双亲设置为空
4. 依照哈夫曼树创建编码表
源代码：
void HuffmanTree::CreateHTree(Node *p,int n)
{
root= new BiNode<int>[2*n-1]; //初始化哈夫曼树
Node *front=p->next;
if(n==0)
throw exception("没有输入字符");
for(int i=0;i<n;i++) //将n个字符的权值存储在哈夫曼树数组的前n位
{
root[i].data=front->count;
root[i].lchild=-1;
root[i].rchild=-1;
root[i].parent=-1;
front=front->next;
}
front=p;
int New1,New2;
for(i=n;i<2*n-1;i++)
{
SelectMin(New1,New2,0,i); //从0~i中选出两个权值最小的结点
root[New1].parent=root[New2].parent=i; //用两个权值最小的结点生成新结点， 新节点为其双亲
root[i].data=root[New1].data+root[New2].data;//新结点的权值为其孩子的权值的和
root[i].lchild=New1;
root[i].rchild=New2;
root[i].parent=-1;
}
CreateCodeTable(p); //创建编码表
}
时间复杂度：
在选用两个权值最小的结点的函数中要遍历链表，时间复杂度为O(n),故该函数的时间复杂度为O（n^2）

3．创建编码表（void HuffmanTree::CreateCodeTable(Node *p)）
算法伪代码：
1.初始化编码表
2.初始化一个指针，从链表的头结点开始，遍历整个链表
2.1 将链表中指针目前所指的结点包括的字符写入编码表中
2.2 得到该结点对应的哈夫曼树的叶子结点及其双亲
2.3 假如哈夫曼树只有一个叶子结点，将其字符对应编码设置为0
2.4 假如不止一个叶子结点，从目前叶子结点开始判断
2.4.1 假如目前叶子结点是其双亲的左孩子，则其对应的编码为0，否则为1
2.4.2 child指针指向叶子结点的双亲，parent指针指向child指针的双亲，重复2.4.1的操作
2.5 将已完成的编码倒序
2.6 取得链表中的下一个字符
3．输出编码表
源代码：
void HuffmanTree::CreateCodeTable(Node *p)
{
HCodeTable=new HCode[tSize]; //初始化编码表
Node *front=p->next;
for(int i=0;i<tSize;i++)
{
HCodeTable[i].data=front->character; //将第i个字符写入编码表
int child=i; //得到第i个字符对应的叶子节点
int parent=root[i].parent; //得到第i个字符对应的叶子节点的双亲
int k=0;
if(tSize==1) //假如文本中只有一个字符，它的编码为0
{
HCodeTable[i].code[k]='0';
k++;
}
while(parent!=-1) //从第i个字符对应的叶子节点开始，寻找它到根结点的途径
{
if(child==root[parent].lchild) //假如目前结点为双亲的左孩子，则编码为0， 否则编码为1
HCodeTable[i].code[k]='0';
else
HCodeTable[i].code[k]='1';
k++;
child=parent;
parent=root[child].parent;
}
HCodeTable[i].code[k]='\0';
Reverse(HCodeTable[i].code); //将编码逆置
front=front->next; //得到下一个字符
}
cout<<"编码表为："<<endl;
for(i=0;i<tSize;i++) //输出编码表
{
cout<<HCodeTable[i].data<<' '<<HCodeTable[i].code<<endl;
}
}
时间复杂度：
需要遍历哈夫曼树获取编码，时间复杂度为O（n^2）

4. 选择两个最小权值的函数（void HuffmanTree::SelectMin(int &New1,int &New2,int begin,int end)）
算法伪代码：
1. 从下标为begin的结点开始，寻找第一个没用过的结点
2. 遍历哈夫曼树中从下标为begin到下标为end的结点序列，寻找没用过的同时权值又是最小的结点。
3. 暂时变化找到的权值最小结点的双亲域，预防第2次找到相同的结点。
4. 将权值最小结点的下标统计下来。
5. 重复步骤1~4，找到第2个权值最小的结点
源代码：
void HuffmanTree::SelectMin(int &New1,int &New2,int begin,int end)
{
int min;
for(int j=0;j<2;j++) //要选择两个权值最小的结点
{
int sign=begin;
for(int i=begin;i<end;i++) //从下标为begin的结点开始,寻找第1个没用过的结点
{
if(root[i].parent==-1) //没用过的结点其双亲应为空
{
min=root[i].data;
sign=i;
break;
}
}
for(i=begin;i<end;i++) //从begin到end，寻找权值最小的没用过的结点
{
if(root[i].parent==-1)
{
if(min>root[i].data)
{
min=root[i].data;
sign=i;
}
}
}
root[sign].parent=0;//暂时变化所找最小结点的双亲域，预防第2次找到的是同一个结点
if(!j)
New1=sign;
else
New2=sign;
}
}
时间复杂度：
两次遍历链表，时间复杂度为O（n）

5. 将字符串倒序的函数（void HuffmanTree::Reverse(char *pch)）
算法伪代码：
1． 得到字符串的长度
2． 初始化两个统计下标的变量，一个为字符串开头字符所在的下标i，另一个为字符串结尾字符所在的下标j
3． 将下标为i和j的字符互换
4． i++,j - -
时间复杂度：
时间复杂度为O（n）

6.编码函数（void HuffmanTree::Encode(string &s,string &d)）
算法伪代码：
1. 从s开头的字符开始，逐一对s中的字符进行编码
2. 在编码表中查找与目前字符对应的字符
3．假如找到了与目前字符对应的编码表中的字符，将其编码追加到解码串的末尾。
4. 重复以上步骤，直到所有待编码串中的字符都编码完成
5. 输出编码后的字符串
源代码：
void HuffmanTree::Encode(string &s,string &d)
{
for(int j=0;j<s.length();j++) //逐一看待编码字符串中的字符进行编码
{
for(int i=0;i<tSize;i++) //在编码表中查找与目前字符对应的编码
{
if(s[j] == HCodeTable[i].data)
{
d.append(HCodeTable[i].code); //编码
break;
}
}
}
cout<<d<<endl; //输出编码后的字符串
}
时间复杂度：
设待编码字符串长度为n，编码表中字符个数为m，则复杂度为O（n*m）

7.解码函数（void HuffmanTree::Decode(string &s,string &d)）
算法伪代码：
1. 得到指向哈夫曼树的根结点的指针和指向待解码串中的第1个字符的指针
2. 逐一读取待解码串中的字符，若为0，则指向哈夫曼树目前结点的指针指向目前结点的左孩子，若为1，则指向目前结点的右孩子
3. 指向待解码串的指针指向解码串中的下一个字符，直到指向哈夫曼树结点的指针的孩子结点为空
4. 假如哈夫曼树只有一个叶子结点，直接将待解码串中的编码转换为对应的字符
5. 假如指向哈夫曼树结点的指针的孩子结点已经为空，则将叶子结点下标对应的字符追加到解码串中。
6. 输出解码串
源代码：
void HuffmanTree::Decode(string &s,string &d)
{
for(int i=0;i<s.length();)
{
int parent=2*tSize-1-1; //得到哈夫曼树的根结点
while(root[parent].lchild!=-1) //假如结点不为叶子结点
{
if(s[i]=='0') //编码为0则寻找其左孩子
parent=root[parent].lchild;
else //编码为1则寻找右孩子
parent=root[parent].rchild;
i++;
}
if(tSize==1) //假如编码表只有一个字符，则根结点即为叶子结点
i++;
d.append(1,HCodeTable[parent].data);//将叶子节点对应的字符追加到解码串中
}
cout<<d<<endl;
}
时间复杂度：
设待解码串长度为n，则复杂度为O(n)

8. 计算哈夫曼编码的压缩比（void HuffmanTree::Calculate(string s1,string s2)）
算法伪代码：
1. 取得编码前字符串的长度，即其占用的字节数
2. 取得编码后的字符串的长度，将其除以8然后向上取整，得到其占用的字节数
3. 压缩比将两个相除
源代码：
void HuffmanTree::Calculate(string s1,string s2)
{
int cal1=s1.length();
int cal2=s2.length();
cal2=ceill((float)cal2/8); //将编码串的比特数转化为字节数
cout<<"编码前的字符串长度："<<cal1<<endl;
cout<<"编码后的字符串长度："<<cal2<<endl;
cout<<"压缩比为："<<((double)cal2/(double)cal1)*100<<"%"<<endl;
}
时间复杂度：
O(1)

9. 打印哈夫曼树（void HuffmanTree::PrintTree(int TreeNode,int layer) ）
算法伪代码：
1. 假如待打印结点为空，则返回
2. 递归调用函数打印目前结点的右子树
3. 依照目前结点所在的层次确定其前面要输出多少空格，先输出空格，在打印目前结点的权值
4. 递归调用函数打印目前结点的左子树
源代码：
void HuffmanTree::PrintTree(int TreeNode,int layer)
{
if(TreeNode==-1) //假如待打印结点为空，则返回
return;
else
{
PrintTree(root[TreeNode].rchild,layer+1); //先打印该结点的右子树，layer统计的是该结点所在的层次
for(int i=0;i<layer*2;i++) //依照该结点所在的层次，确定在它之前需要打印多少空格
cout<<' ';
cout<<root[TreeNode].data<<endl; //打印该结点的权值
PrintTree(root[TreeNode].lchild,layer+1); //打印该结点的左子树
}
}
时间复杂度：
中序遍历哈夫曼树，复杂度为O(n)

10. 菜单函数（void HuffmanTree::Menu()）
算法伪代码：
1. 逐一读取键盘缓存区中的字符，并将它们逐一追加到统计输入字符串的string变量中，直到读到回车输入符为止
2. 删除string变量末尾的回车输入符
3．利用string变量创建哈夫曼树，初始化编码表。
4. 直观打印哈夫曼树
5. 对输入的字符串进行编码
6. 对编码后的字符串进行解码
7. 计算编码前后的压缩比并输出
源代码：
void HuffmanTree::Menu()
{
cout<<"请输入你要编码的文本,按回车键确定输入"<<endl;
string Input;
char letter;
do //将字符逐一读入Input变量中
{
letter=cin.get();
Input.append(1,letter);
}while(letter!='\n');
Input.erase(Input.length()-1,1); //去掉Input末尾的回车符
Init(Input); //依照输入的字符串创建哈夫曼树及其编码表
cout<<"直观打印哈夫曼树"<<endl;
PrintTree(2*tSize-1-1,1); //打印哈夫曼树
cout<<'\n'<<'\n';
string d1,d2;
cout<<"编码后的字符串为"<<endl;
Encode(Input,d1); //编码并打印编码串
cout<<"解码后的字符串为"<<endl;
Decode(d1,d2); //解码并打印解码串
cout<<"ASCII码编码与HUFFMAN编码的比较"<<endl;
Calculate(Input,d1); //计算编码前后的压缩比
}

2.3 其他
1.因为题目要求能输入任意长的字符串，因此本程序采取了string变量来统计输入的字符串，并采取string类的类组员函数来完成各项任务
2.打印哈夫曼树时采取了递归函数，且采取了凹凸表的形式打印哈夫曼树。
3.为了输入空格，输入时采取逐一字符输入的方式
3. 程序运行成果
主函数流程图：
开始

调用菜单函数

等候用户输入字符串

利用用户输入的字符串创建哈夫曼树和编码表

直观打印哈夫曼树和编码表

对输入的字符串编码

对编码串解码

计算编码前后的压缩比

结束

运行成果：

各函数运行正常，没有出现bug
4. 总结
通过这次试验，我了解了哈夫曼树的创建过程，了解了一个不等长编码的措施，用设断点调试的措施愈加纯熟，同时熟悉了STL中string类型的使用方法，对C++愈加熟悉