c++数据结构实验哈夫曼树

合集下载

c语言哈夫曼树的构造及编码

c语言哈夫曼树的构造及编码

c语言哈夫曼树的构造及编码一、哈夫曼树概述哈夫曼树是一种特殊的二叉树,它的构建基于贪心算法。

它的主要应用是在数据压缩和编码中,可以将频率高的字符用较短的编码表示,从而减小数据存储和传输时所需的空间和时间。

二、哈夫曼树的构造1. 哈夫曼树的定义哈夫曼树是一棵带权路径长度最短的二叉树。

带权路径长度是指所有叶子节点到根节点之间路径长度与其权值乘积之和。

2. 构造步骤(1) 将待编码字符按照出现频率从小到大排序。

(2) 取出两个权值最小的节点作为左右子节点,构建一棵新的二叉树。

(3) 将新构建的二叉树加入到原来排序后队列中。

(4) 重复上述步骤,直到队列只剩下一个节点,该节点即为哈夫曼树的根节点。

3. C语言代码实现以下代码实现了一个简单版哈夫曼树构造函数:```ctypedef struct TreeNode {int weight; // 权重值struct TreeNode *leftChild; // 左子节点指针struct TreeNode *rightChild; // 右子节点指针} TreeNode;// 构造哈夫曼树函数TreeNode* createHuffmanTree(int* weights, int n) {// 根据权值数组构建节点队列,每个节点都是一棵单独的二叉树TreeNode** nodes = (TreeNode**)malloc(sizeof(TreeNode*) * n);for (int i = 0; i < n; i++) {nodes[i] = (TreeNode*)malloc(sizeof(TreeNode));nodes[i]->weight = weights[i];nodes[i]->leftChild = NULL;nodes[i]->rightChild = NULL;}// 构建哈夫曼树while (n > 1) {int minIndex1 = -1, minIndex2 = -1;for (int i = 0; i < n; i++) {if (nodes[i] != NULL) {if (minIndex1 == -1 || nodes[i]->weight < nodes[minIndex1]->weight) {minIndex2 = minIndex1;minIndex1 = i;} else if (minIndex2 == -1 || nodes[i]->weight < nodes[minIndex2]->weight) {minIndex2 = i;}}}TreeNode* newNode =(TreeNode*)malloc(sizeof(TreeNode));newNode->weight = nodes[minIndex1]->weight + nodes[minIndex2]->weight;newNode->leftChild = nodes[minIndex1];newNode->rightChild = nodes[minIndex2];// 将新构建的二叉树加入到原来排序后队列中nodes[minIndex1] = newNode;nodes[minIndex2] = NULL;n--;}return nodes[minIndex1];}```三、哈夫曼编码1. 哈夫曼编码的定义哈夫曼编码是一种前缀编码方式,它将每个字符的编码表示为二进制串。

哈夫曼树_实验报告

哈夫曼树_实验报告

一、实验目的1. 理解哈夫曼树的概念及其在数据结构中的应用。

2. 掌握哈夫曼树的构建方法。

3. 学习哈夫曼编码的原理及其在数据压缩中的应用。

4. 提高编程能力,实现哈夫曼树和哈夫曼编码的相关功能。

二、实验原理哈夫曼树(Huffman Tree)是一种带权路径长度最短的二叉树,又称为最优二叉树。

其构建方法如下:1. 将所有待编码的字符按照其出现的频率排序,频率低的排在前面。

2. 选择两个频率最低的字符,构造一棵新的二叉树,这两个字符分别作为左右子节点。

3. 计算新二叉树的频率,将新二叉树插入到排序后的字符列表中。

4. 重复步骤2和3,直到只剩下一个节点,这个节点即为哈夫曼树的根节点。

哈夫曼编码是一种基于哈夫曼树的编码方法,其原理如下:1. 从哈夫曼树的根节点开始,向左子树走表示0,向右子树走表示1。

2. 每个叶子节点对应一个字符,记录从根节点到叶子节点的路径,即为该字符的哈夫曼编码。

三、实验内容1. 实现哈夫曼树的构建。

2. 实现哈夫曼编码和译码功能。

3. 测试实验结果。

四、实验步骤1. 创建一个字符数组,包含待编码的字符。

2. 创建一个数组,用于存储每个字符的频率。

3. 对字符和频率进行排序。

4. 构建哈夫曼树,根据排序后的字符和频率,按照哈夫曼树的构建方法,将字符和频率插入到哈夫曼树中。

5. 实现哈夫曼编码功能,遍历哈夫曼树,记录从根节点到叶子节点的路径,即为每个字符的哈夫曼编码。

6. 实现哈夫曼译码功能,根据哈夫曼编码,从根节点开始,按照0和1的路径,找到对应的叶子节点,即为解码后的字符。

7. 测试实验结果,验证哈夫曼编码和译码的正确性。

五、实验结果与分析1. 构建哈夫曼树根据实验数据,构建的哈夫曼树如下:```A/ \B C/ \ / \D E F G```其中,A、B、C、D、E、F、G分别代表待编码的字符。

2. 哈夫曼编码根据哈夫曼树,得到以下字符的哈夫曼编码:- A: 00- B: 01- C: 10- D: 11- E: 100- F: 101- G: 1103. 哈夫曼译码根据哈夫曼编码,对以下编码进行译码:- 00101110111译码结果为:BACGACG4. 实验结果分析通过实验,验证了哈夫曼树和哈夫曼编码的正确性。

北邮数据结构实验三题目2哈夫曼树(代码)

北邮数据结构实验三题目2哈夫曼树(代码)
int Getm(){return m;}
~Huffman(){delete []HTree;delete []HcodeTable;}//析构函数
};
//初始化哈夫曼树
void Huffman::Init(char *s)
{
int n=0;
while (*(s+n)!='\0')
k=0;//控制哈夫曼数组下标
ctemp=temp[0];//做标记
for (int i=0;i<n;i++)
{
if(temp[i]==ctemp)
{
l++;//统计不同字符出现的频度
if (i==n-1)
HTree[k].weight=l;
}
{
for (int j=0;HcodeTable[i].code[j]!='\0';j++)
{
*d+=HcodeTable[i].code[j];
sum+=1;
}
s++;
n++;
break;
}
}
}
}
void main()
{
cout<<"请选择输入字符串:"<<endl;
char str[1000]={'\0'};
char *s=&str[0];
char c;
int i=0;
bool flag=0;//判断不同字符个数是否>=2
while (cin.get(c))//接收输入字符串,自动除去空格

《数据结构课程设计》赫夫曼编码实验报告

《数据结构课程设计》赫夫曼编码实验报告

目录一、概述 (1)二、系统分析 (1)三、概要设计 (2)四、详细设计 (4)4.1 赫夫曼树的建立 (4)4.1.1 选择选择parent 为0 且权值最小的两个根结点的算法 (5)4.1.2 统计字符串中字符的种类以及各类字符的个数 (7)4.1.3构造赫夫曼树 (8)4.2赫夫曼编码 (10)4.2.1赫夫曼编码算法 (10)4.2.2建立正文的编码文件 (11)4.3代码文件的译码 (12)五、运行与测试 (14)六、总结与心得 (14)参考文献 (15)附录 (15)一、概述本设计是对输入的一串电文字符实现赫夫曼编码,再对赫夫曼编码生产的代码串进行译码,输出电文字符串。

在当今信息爆炸时代,如何采用有效的数据压缩技术节省数据文件的存储空间和计算机网络的传送时间越来越引起人们的重视,赫夫曼编码正是一种应用广泛且非常有效的数据压缩技术。

二、系统分析赫夫曼编码的应用很广泛,利用赫夫曼树求得的用于通信的二进制编码成为赫夫曼编码。

树中从根到每个叶子都有一条路径,对路径上的各分支约定:指向左子树的分支表示“0”码,指向右子树的分支表示“1”码,取每条路径上的“0”或“1”的序列作为和每个叶子对应的字符的编码,这就是赫夫曼编码。

通常我们把数据压缩的过程称为编码,解压缩的过程称为解码。

电报通信是传递文字的二进制码形式的字符串,但在信息传递时,总希望总长度能尽可能短,即采用最短码。

假设每种字符在电文中出现的次数为W i ,编码长度为L i ,电文中有n 种字符,则电文编码总长为∑W i L i 。

若将此对应到二叉树上,W i 为叶节点的权,L i 为根节点到叶节点的路径长度。

那么,∑W i L i 恰好为二叉树上带权路径长度。

因此,设计电文总长最短的二进制前缀编码,就是以n 种子符出现的频率作权,构造一刻赫夫曼树,此构造过程成为赫夫曼编码。

根据设计要求和分析,要实现设计,必须实现以下方面的功能:(1)赫夫曼树的建立;(2)赫夫曼编码的生成;(3)编码文件的译码;三、概要设计程序由哪些模块组成以及模块之间的层次结构、各模块的调用关系;每个模块的功能。

武汉理工大学数据结构与算法综合实验哈夫曼树

武汉理工大学数据结构与算法综合实验哈夫曼树

..
v
.. .
..
.
typedef char * pBuffer ; //其大小视原文件压缩后的大小
2.核心算法设计
(1)生成 Huffman 树和 Huffman 编码的算法 void Select(HTNode huffTree[],int m) {
int min,min2,i; min=min2=1000; for(i=0;i<m;i++)
b=b<<1; if(pBinStr[i]=='1') {
b=b|0x01; } } return b; } bool InitHead(const char *pFilename,HEAD &sHead) { char ch;
..
v
.. . .. .
..
.
.. .
//初始化文件 strcpy(sHead.type,"HUF"); sHead.length=0; for(int i=0;i<256;i++) {
..
v
.. .
..
.
.. .
二叉树的存储结构。使用结构体存储节点,使用数组存储树的节点,使用静态二叉链表方 式存储二叉树。
Huffman编码存储结构 struct HTNode
{ int weight;//权值 int parent; int lchild; int rchild; char zifu; string bianma;
..
.
.. .
学生学号
Xxx
实验课成绩
学生实验报告书
实验课程名称 开课学院
指导教师姓名 学生姓名

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告

数据结构哈夫曼编码实验报告【正文】1.实验目的本实验旨在研究哈夫曼编码的原理和实现方法,通过实验验证哈夫曼编码在数据压缩中的有效性,并分析其应用场景和优缺点。

2.实验原理2.1 哈夫曼编码哈夫曼编码是一种无损数据压缩算法,通过根据字符出现的频率构建一颗哈夫曼树,将频率较高的字符用较短的编码表示,频率较低的字符用较长的编码表示。

哈夫曼编码的编码表是唯一的,且能够实现前缀编码,即一个编码不是另一个编码的前缀。

2.2 构建哈夫曼树构建哈夫曼树的过程如下:1) 将每个字符及其频率作为一个节点,构建一个节点集合。

2) 每次从节点集合中选择出现频率最低的两个节点,构建一个新节点,并将这两个节点从集合中删除。

3) 将新节点加入节点集合。

4) 重复以上步骤,直到节点集合中只有一个节点,这个节点就是哈夫曼树的根节点。

2.3 编码过程根据哈夫曼树,对每个字符进行编码:1) 从根节点开始,根据左子树为0,右子树为1的规则,将编码依次加入编码表。

2) 对于每个字符,根据编码表获取其编码。

3) 将编码存储起来,得到最终的编码序列。

3.实验步骤3.1 数据读取与统计从输入文件中读取字符序列,并统计各个字符的频率。

3.2 构建哈夫曼树根据字符频率构建哈夫曼树。

3.3 构建编码表根据哈夫曼树,构建每个字符的编码表。

3.4 进行编码根据编码表,对输入的字符序列进行编码。

3.5 进行解码根据哈夫曼树,对编码后的序列进行解码。

4.实验结果与分析4.1 压缩率分析计算原始数据和压缩后数据的比值,分析压缩率。

4.2 编码效率分析测试编码过程所需时间,分析编码效率。

4.3 解码效率分析测试解码过程所需时间,分析解码效率。

4.4 应用场景分析分析哈夫曼编码在实际应用中的优势和适用场景。

5.结论通过本次实验,我们深入了解了哈夫曼编码的原理和实现方法,实践了哈夫曼编码的过程,并对其在数据压缩中的有效性进行了验证。

实验结果表明,哈夫曼编码能够实现较高的压缩率和较高的编解码效率。

哈夫曼树 实验报告

哈夫曼树 实验报告

哈夫曼树实验报告哈夫曼树实验报告引言:哈夫曼树是一种经典的数据结构,广泛应用于数据压缩、编码和解码等领域。

本次实验旨在通过构建哈夫曼树,探索其原理和应用。

一、哈夫曼树的定义和构建方法哈夫曼树是一种特殊的二叉树,其叶子节点对应于待编码的字符,而非叶子节点则是字符的编码。

构建哈夫曼树的方法是通过贪心算法,即每次选择权值最小的两个节点合并,直到构建出完整的哈夫曼树。

二、哈夫曼编码的原理和实现哈夫曼编码是一种可变长度编码,即不同字符的编码长度不同。

其原理是通过构建哈夫曼树来确定字符的编码,使得频率较高的字符编码较短,频率较低的字符编码较长。

这样可以有效地减少编码的长度,从而实现数据的压缩。

三、实验过程和结果在本次实验中,我们选择了一段文本作为输入数据,通过统计每个字符的频率,构建了对应的哈夫曼树。

然后,根据哈夫曼树生成了字符的编码表,并将原始数据进行了编码。

最后,我们通过对编码后的数据进行解码,验证了哈夫曼编码的正确性。

实验结果显示,通过哈夫曼编码后,原始数据的长度明显减少,达到了较好的压缩效果。

同时,解码后的数据与原始数据完全一致,证明了哈夫曼编码的可靠性和正确性。

四、哈夫曼树的应用哈夫曼树在实际应用中有着广泛的用途。

其中,最典型的应用之一是数据压缩。

通过使用哈夫曼编码,可以将大量的数据压缩为较小的存储空间,从而节省了存储资源。

此外,哈夫曼树还被广泛应用于网络传输、图像处理等领域,提高了数据传输的效率和图像的质量。

五、对哈夫曼树的思考哈夫曼树作为一种经典的数据结构,其优势在于有效地减少了数据的冗余和存储空间的占用。

然而,随着技术的不断发展,现代的数据压缩算法已经不再局限于哈夫曼编码,而是采用了更为复杂和高效的算法。

因此,我们需要在实际应用中综合考虑各种因素,选择合适的压缩算法。

六、总结通过本次实验,我们深入了解了哈夫曼树的原理和应用。

哈夫曼编码作为一种重要的数据压缩算法,具有广泛的应用前景。

在实际应用中,我们需要根据具体情况选择合适的压缩算法,以达到最佳的压缩效果和性能。

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
2.上机输入、调试实验程序;
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法,1为插入,2为删除,3为查询!4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);

哈夫曼编码-数据结构-C++程序

哈夫曼编码-数据结构-C++程序

数据结构课程设计一、目的《数据结构》是一门实践性较强的软件基础课程,为了学好这门课程,必须在掌握理论知识的同时,加强上机实践。

本课程设计的目的就是要达到理论与实际应用相结合,使同学们能够根据数据对象的特性,学会数据组织的方法,能把现实世界中的实际问题在计算机内部表示出来,并培养基本的、良好的程序设计技能。

二、要求通过这次设计,要求在数据结构析逻辑特性和物理表示,数据结构的选择的应用、算法的设计及其实现等方面中深对课程基本内容的理解。

同时,在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。

三、内容2.哈夫曼编码/译码器【问题描述】设计一个利用哈夫曼算法的编码和译码系统,重复地显示并处理以下项目,直到选择退出为止。

【基本要求】(1)初始化:键盘输入字符集大小n、n个字符和n个权值,建立哈夫曼树;(2)编码:利用建好的哈夫曼树生成哈夫曼编码;(3)输出编码;(4)设字符集及频度如下表:字符空格A B C D E F G H I J K L M频度186 64 13 22 32 103 21 15 47 57 1 5 32 20字符N O P Q R S T U V W X Y Z频度57 63 15 1 48 51 80 23 8 18 1 16 1【选做内容】(1)译码功能;(2)显示哈夫曼树;(3)界面设计的优化。

哈夫曼编写编译码一、问题描述利用哈夫曼编码进行通信可以大大提高信道利用率,这要求在发送端通过一个编码系统对待传输预先编码,在接收端将传来的数据进行译码。

对于双工通道,每端都需要一个完整的编/译码系统。

试为这样的信息收发站写一个哈夫曼码的编/译码系统。

二、概要设计1.哈夫曼树的定义:在一棵二叉树中,若带权路径长度达到最小,称这样的二叉树为最优二叉树,也称为哈夫曼树。

2.哈夫曼树的构造:假设有N个权值,则构造出的哈夫曼树有N个叶子结点。

N个权值分别设为W1,W2,……….Wn,则哈夫曼树的构造规则为:(1)将W1,W2,……….Wn看成有N棵树的森林;(2)在森林中选出两个根结点的权值最小的树合并,作为一棵新树的左,右子树,且新树的根结点为其左,右子树结点权值之和;(3)从森林中删除选取取的两面三刀棵树,并将新树加入森林;(4)重复(2)(3)步,直到森林中只剩一棵树为止,该树即为我们所求得的哈夫曼树。

哈夫曼树实验报告

哈夫曼树实验报告

哈夫曼树实验报告一、实验目的1.理解哈夫曼树的概念和实现原理;2.掌握使用哈夫曼树进行编码和解码的方法;3.熟悉哈夫曼树在数据压缩中的应用。

二、实验原理哈夫曼树是一种用于数据压缩的树形结构,通过将出现频率较高的数据项用较短的编码表示,从而达到压缩数据的目的。

哈夫曼树的构建过程如下:1.统计字符出现的频率,并按照频率从小到大排序;2.将频率最低的两个字符合并为一个节点,节点的频率为两个字符的频率之和;3.将新节点插入频率表,并将频率表重新排序;4.重复步骤2和3,直到频率表中只剩下一个节点,该节点即为哈夫曼树的根节点。

三、实验步骤1.统计输入的字符序列中每个字符出现的频率;2.根据频率构建哈夫曼树;3.根据哈夫曼树生成字符的编码表;4.将输入的字符序列编码为哈夫曼编码;5.根据哈夫曼树和编码表,解码得到原始字符序列。

四、实验结果以字符序列"abacabad"为例进行实验:1.统计字符频率的结果为:a-4次,b-2次,c-1次,d-1次;```a-4/\b-2c-1/\d-1空节点```3.根据哈夫曼树生成的编码表为:a-0,b-10,c-110,d-111;5. 根据哈夫曼树和编码表进行解码得到原始字符序列:"abacabad"。

五、实验总结通过本次实验,我深入了解了哈夫曼树的原理和实现方法,掌握了使用哈夫曼树进行字符编码和解码的过程。

哈夫曼树在数据压缩中的应用非常广泛,能够有效地减小数据的存储空间,提高数据传输效率。

在实际应用中,我们可以根据不同字符出现的频率构建不同的哈夫曼树,从而实现更高效的数据压缩和解压缩算法。

数据结构课程设计实验报告哈夫曼

数据结构课程设计实验报告哈夫曼

数据结构课程设计实验报告哈夫曼树的应用计算机学院信管专业数据结构课程设计题目:哈夫曼树的应用班级:姓名:学号:同组人姓名:起迄日期:课程设计地点:指导教师:完成日期:2012年12月目录一、需求分析 (3)二、概要设计 (4)三、详细设计 (6)四、调试分析和测试结果 (7)五、心得体会和总结 (10)六、参考文献 (10)七、附录 (11)一、需求分析(一)实验要求要求用到数据结构课上学到的线性表的知识,所以就要充分而清晰的理解关于线性表的知识。

要求实现的基本功能很简单,只有删除和插入,增加功能也不过是加上修改。

这些在数据结构课上已经讲过,只要能够理解关于线性表的几个相关的基本算法就可以了。

问题是将输入的信息保存入文件和从文件输出。

这里基本是自学的内容,而且要考虑到是否要自行选择保存的磁盘。

综上,做这个课题,要具备的知识就是线性表的基本算法,文件的保存和读取算法,必要的C或者C++知识(本次我将使用C++实现),以及丰富的程序调适经验。

(二)实验任务一个完整的系统应具有以下功能:功能1.从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树并将它存于文件hfmTree中.将已在内存中的哈夫曼树以直观的方式(比如树)显示在终端上;功能2.利用已经建好的哈夫曼树(如不在内存,则从文件htmTree中读入),对文件ToBeTran中的正文进行编码,然后将结果存入文件CodeFile中,并输出结果,将文件CodeFile以紧凑格式先是在终端上,每行50个代码。

同时将此字符形式的编码文件写入文件CodePrint中。

功能3.利用已建好的哈夫曼树将文件CodeFile中的代码进行译码,结果存入文件TextFile中,并输出结果。

(三)实验步骤分步实施:1)初步完成总体设计,搭好框架,确定人机对话的界面,确定函数个数;2)完成最低要求:完成功能1;3)进一步要求:完成功能2和3。

有兴趣的同学可以自己扩充系统功能。

哈夫曼树实验报告(上传)

哈夫曼树实验报告(上传)

201*级数据结构实验报告哈夫曼树的建立姓名:***学号:***********班级:指导老师:***日期:201*.12.25一、实验题目及要求:实验题目:哈夫曼编码器设计实验要求:哈夫曼(Huffman)树与哈夫曼码1.输入一个文本,统计各字符出现的频度,输出结果;2.使用二叉链表或三叉链表作存储结构,构造哈夫曼(Huffman)树; 3.确定和输出各字符的哈夫曼码;4.输入一个由0和1组成的代码序列,翻译并输出与之对应的文本;操作提示:一个完整的系统应具有以下功能:(1)初始化: 从终端读入一段英文字符,统计每个字符出现的频率,建立赫夫曼树,并将该树存入某文件;(2)编码: 利用建好的赫夫曼树对各字符进行编码,用列表的形式显示在屏幕上,并将编码结果存入另一文件中;(3)解码: 利用保存的赫夫曼编码,对任意输入的0,1序列能正确解码。

二、实验分析及内容1、 存储结构a. 哈夫曼树的存储结构该程序使用一个静态三叉链表来存储哈夫曼树:weight LChild RChild Parent 2 -1 -1 4 3 -1 -1 4 6 -1 -1 5 9 -1 -1 6 5 1 1 5 11 2 2 6 2055-1b. 哈夫曼编码表的存储结构把每个字符data 及对应的编码code 用一个结点存储,将所有的结点存储在数组中:data Code Z 100 C 101 B 11 Ac. 录入字符串以及存储字符的数组a[]、b[]的获取:先将录入的字符串存在一个字符数组S[]中,然后遍历数组S[],先建立一个空的循环链表,然后再遍历数组S 的同时往链表里插入新的结点或者修改相应结点中的域值:0 1 2 3 4 5 60 1 2 3Data Weight Nextrrear2. 关键算法分析a.初始化哈夫曼树:用数组a[]初始化哈夫曼树:从0到n-1循环,分别对树中结点赋值:HTree[i].weight=a[i];HTree[i].lchild=-1;HTree[i].rchild=-1;HTree[i].parent=-1;b.创建哈夫曼树:(1)、从1——i中选择两个最小的结点:SelectMin(x,y,0,i);(2)、将选中的两个结点插入到树中:HTree[x].parent=HTree[y].parent=ii;HTree[ii].weight=HTree[x].weight+HTree[y].weight;HTree[ii].lchild=x;HTree[ii].rchild=y;HTree[ii].parent=-1;d.创建编码表:(1)、自下而上从叶子节点找到根节点,左孩子标识为‘0’,右孩子标识为‘1’,将‘0’、‘1’储存在编码表的code[]中;(2)、将code[]中的‘0’、‘1’进行倒序;e.编码:根据编码表,进行编码:for(int i=0;i<n;i++){ if(*s==HCodeTable[i].data){cout<<HCodeTable[i].code;s++;}}f.译码:输入一串‘0’、‘1’代码,根据编码表进行译码:(1)、如果是‘0’,则转到当前结点的左孩子:if(*s=='0') parent=HTree[parent].lchild;(2)、如果是‘1’,则转到当前结点的右孩子:else parent=HTree[parent].rchild;5、源程序:#include "stdio.h"typedef struct{float weight;int parent,lchild,rchild;}huftree;typedef struct{int bit[100];int length;}hufcode;huftree tree[100];//哈夫曼树hufcode code[100];//编码int num,m;//个数,编码最大长度void HufBuild(){int i,j,p1,p2;float s1,s2;printf("How: ");scanf("%d",&num);m=2*num-1;printf("请输入各个编码频率: ");for(i=0;i<num;i++){scanf("%f",&tree[i].weight);tree[i+num].parent=tree[i].parent=0;tree[i+num].lchild=tree[i].lchild=0;tree[i+num].rchild=tree[i].rchild=0;}for(i=num;i<m;i++){s1=s2=1; p1=p2=0;for(j=0;j<i;j++)if(tree[j].parent==0)if(tree[j].weight<s1){s2=s1; s1=tree[j].weight;p2=p1; p1=j;}else if(tree[j].weight<s2){s2=tree[j].weight;p2=j;}tree[p1].parent=tree[p2].parent=i;tree[i].weight=tree[p1].weight+tree[p2].weight;tree[i].lchild=p1; tree[i].rchild=p2;}}void CodePrint(){int i,j,p,k;printf("各个编码如下: \n");for(i=0;i<num;i++){printf("%6.2f",tree[i].weight);p=tree[i].parent;j=i;code[i].length=num-1;while(p!=0){if(tree[p].lchild==j) code[i].bit[code[i].length]=1;else code[i].bit[code[i].length]=0;code[i].length--;j=p;p=tree[p].parent;}printf(" ");for(k=code[i].length+1;k<num;k++)printf("%d",code[i].bit[k]);printf("\n");}}void main(){printf("输入一个要进行哈夫曼编码的字符串:"); gets();printf("如下是编码表:");HufBuild();pringtf("请输入一串0和1的代码");CodePrint();}3、运行结果三、实验小结1、虽然最终顺利的编完了程序,但是总的来说哈夫曼树还是很不容易的。

哈夫曼实验报告(附代码)

哈夫曼实验报告(附代码)

哈夫曼实验报告(附代码)以下是为大家整理的哈夫曼实验报告(附代码)的相关范文,本文关键词为哈夫曼,实验,报告,代码,,您可以从右上方搜索框检索更多相关文章,如果您觉得有用,请继续关注我们并推荐给您的好友,您可以在综合文库中查看更多范文。

哈弗曼编码/译码器一、程序的功能分析1.构造哈夫曼树及哈夫曼编码:从终端读入字符集大小n、n 个字符以及n个对应的权值,建立哈夫曼树;利用已经建好的哈夫曼树求每个叶结点的哈夫曼编码,并保存。

2.编码:利用已构造的哈夫曼编码对“明文”文件中的正文进行编码,然后将结果存入“密文”文件中。

3.译码:将“密文”文件中的0、1代码序列进行译码。

(读文件) 4.打印“密文”文件:将文件以紧凑格式显示在终端上,每行30个代码;同时,将此字符形式的编码文件保存。

5.打印哈夫曼树及哈夫曼编码:将已在内存中的哈夫曼树以凹入表形式显示在终端上,同时将每个字符的哈夫曼编码显示出来;并保存到文件。

二、基本要求分析1、输入输出的要求按提示内容从键盘输入命令,系统根据用户输入的需求在保证界面友好的前提下输出用户所需信息,并按要求保存文件,以便保存备份信息。

2、测试数据(1).令叶子结点个数n为4,权值集合为{1,3,5,7},字符集合为{A,b,c,D},且字符集与权值集合一一对应。

(2).令叶子结点个数n为7,权值集合为{12,6,8,18,3,20,2},字符集合为{A,b,c,D,e,F,g},且字符集与权值集合一一对应。

(3).请自行选定一段英文文本,统计给出的字符集,实际统计字符的频度,建立哈夫曼树,构造哈夫曼编码,并实现其编码和译码。

三、概要设计1.主模块的流程及各子模块的主要功能主函数负责提供选项功能,循环调控整个系统。

创建模块实现接收字符、权值、构建哈夫曼树,并保存文件,此功能是后续功能的基础。

编码模块实现利用已编好的哈夫曼树对每个字符进行哈夫曼编码,即对每个字符译出其密文代码,并保存文件。

数据结构——哈夫曼(Huffman)树+哈夫曼编码

数据结构——哈夫曼(Huffman)树+哈夫曼编码

数据结构——哈夫曼(Huffman)树+哈夫曼编码前天acm实验课,⽼师教了⼏种排序,抓的⼀套题上有⼀个哈夫曼树的题,正好之前离散数学也讲过哈夫曼树,这⾥我就结合课本,整理⼀篇关于哈夫曼树的博客。

哈夫曼树的介绍Huffman Tree,中⽂名是哈夫曼树或霍夫曼树,它是最优⼆叉树。

定义:给定n个权值作为n个叶⼦结点,构造⼀棵⼆叉树,若树的带权路径长度达到最⼩,则这棵树被称为哈夫曼树。

这个定义⾥⾯涉及到了⼏个陌⽣的概念,下⾯就是⼀颗哈夫曼树,我们来看图解答。

(01) 路径和路径长度定义:在⼀棵树中,从⼀个结点往下可以达到的孩⼦或孙⼦结点之间的通路,称为路径。

通路中分⽀的数⽬称为路径长度。

若规定根结点的层数为1,则从根结点到第L层结点的路径长度为L-1。

例⼦:100和80的路径长度是1,50和30的路径长度是2,20和10的路径长度是3。

(02) 结点的权及带权路径长度定义:若将树中结点赋给⼀个有着某种含义的数值,则这个数值称为该结点的权。

结点的带权路径长度为:从根结点到该结点之间的路径长度与该结点的权的乘积。

例⼦:节点20的路径长度是3,它的带权路径长度= 路径长度 * 权 = 3 * 20 = 60。

(03) 树的带权路径长度定义:树的带权路径长度规定为所有叶⼦结点的带权路径长度之和,记为WPL。

例⼦:⽰例中,树的WPL= 1*100 + 2*50 +3*20 + 3*10 = 100 + 100 + 60 + 30 = 290。

⽐较下⾯两棵树上⾯的两棵树都是以{10, 20, 50, 100}为叶⼦节点的树。

左边的树WPL=2*10 + 2*20 + 2*50 + 2*100 = 360 右边的树WPL=350左边的树WPL > 右边的树的WPL。

你也可以计算除上⾯两种⽰例之外的情况,但实际上右边的树就是{10,20,50,100}对应的哈夫曼树。

⾄此,应该堆哈夫曼树的概念有了⼀定的了解了,下⾯看看如何去构造⼀棵哈夫曼树。

c语言实现构造哈夫曼树代码

c语言实现构造哈夫曼树代码

c语言实现构造哈夫曼树代码一、哈夫曼树简介哈夫曼树是一种特殊的二叉树,其每个叶子节点都对应一个权值,而非叶子节点则没有权值。

哈夫曼树的构造过程中,将权值较小的节点放在左子树,权值较大的节点放在右子树,这使得哈夫曼树的带权路径最短。

哈夫曼编码就是利用这种特性实现对数据进行压缩。

二、C语言实现构造哈夫曼树1. 定义结构体首先需要定义一个结构体来表示哈夫曼树中的节点。

结构体中包含了该节点的权值以及指向左右子节点的指针。

```typedef struct TreeNode {int weight;struct TreeNode *left;struct TreeNode *right;} TreeNode;2. 构造哈夫曼树接下来需要实现构造哈夫曼树的函数。

该函数接收一个数组作为输入,数组中存储了每个叶子节点的权值。

首先需要将数组中所有元素转化为TreeNode类型,并将它们存储在一个链表中。

```TreeNode *createTreeNodes(int weights[], int size) {TreeNode *nodes[size];for (int i = 0; i < size; i++) {nodes[i] = (TreeNode *)malloc(sizeof(TreeNode));nodes[i]->weight = weights[i];nodes[i]->left = NULL;nodes[i]->right = NULL;}return nodes;}```接下来,需要实现一个函数来找到权值最小的两个节点。

该函数接收一个链表作为输入,并返回该链表中权值最小的两个节点。

```void findMinNodes(TreeNode **nodes, int size, TreeNode**minNode1, TreeNode **minNode2) {*minNode1 = *minNode2 = NULL;for (int i = 0; i < size; i++) {if (*minNode1 == NULL || (*nodes)[i].weight <(*minNode1)->weight) {*minNode2 = *minNode1;*minNode1 = &(*nodes)[i];} else if (*minNode2 == NULL || (*nodes)[i].weight < (*minNode2)->weight) {*minNode2 = &(*nodes)[i];}}}```接下来,需要实现一个函数来构造哈夫曼树。

数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告

2009级数据结构实验报告实验名称:实验3——哈夫曼树学生姓名:陈家斌班级:2009211121班内序号:16学号:09210619日期:2010年12月3日1.实验要求【实验目的】通过选择下面两个题目之一进行实现,掌握如下内容:➢掌握二叉树基本操作的实现方法➢了解赫夫曼树的思想和相关概念➢学习使用二叉树解决实际问题的能力【题目】利用二叉树结构实现赫夫曼编/解码器。

【基本要求】1、初始化(Init):能够对输入的任意长度的字符串s进行统计,统计每个字符的频度,并建立赫夫曼树2、建立编码表(CreateTable):利用已经建好的赫夫曼树进行编码,并将每个字符的编码输出。

3、编码(Encoding):根据编码表对输入的字符串进行编码,并将编码后的字符串输出。

4、译码(Decoding):利用已经建好的赫夫曼树对编码后的字符串进行译码,并输出译码结果。

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

【测试数据】I love data Structure, I love Computer。

I will try my best to study data Structure.提示:1、用户界面可以设计为“菜单”方式:能够进行交互。

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

【代码要求】1、必须要有异常处理,比如删除空链表时需要抛出异常;2、保持良好的编程的风格:➢代码段与段之间要有空行和缩近➢标识符名称应该与其代表的意义一致➢函数名之前应该添加注释说明该函数的功能➢关键代码应说明其功能3、递归程序注意调用的过程,防止栈溢出2. 程序分析【算法实现】程序第一遍统计原数据中各字符出现的频率,利用得到的频率值创建哈夫曼树,并把树的信息保存起来,以便解压时创建同样的哈夫曼树进行解压;第二遍,根据第一遍扫描得到的哈夫曼树进行编码,并把编码后的码字存储。

数据结构实验哈夫曼树及哈夫曼编码c语言

数据结构实验哈夫曼树及哈夫曼编码c语言

数据结构实验报告:哈夫曼树及哈夫曼编码一、实验目的1. 理解哈夫曼树及哈夫曼编码的概念和原理;2. 掌握C语言中哈夫曼树及哈夫曼编码的实现方法;3. 分析和讨论哈夫曼编码在实际应用中的优势和不足。

二、实验内容和步骤1. 哈夫曼树的构建1.1 通过C语言实现哈夫曼树的构建算法;1.2 输入一组权值,按哈夫曼树构建规则生成哈夫曼树;1.3 输出生成的哈夫曼树结构,并进行可视化展示。

2. 哈夫曼编码的实现2.1 设计哈夫曼编码的实现算法;2.2 对指定字符集进行编码,生成哈夫曼编码表;2.3 对给定字符串进行哈夫曼编码,并输出编码结果。

三、实验过程及结果1. 哈夫曼树的构建在C语言中,通过定义结构体和递归算法实现了哈夫曼树的构建。

根据输入的权值,依次选择权值最小的两个节点构建新的父节点,直至构建完成整棵哈夫曼树。

通过调试和可视化展示,确认了程序正确实现了哈夫曼树的构建。

2. 哈夫曼编码的实现经过分析和设计,利用哈夫曼树的特点实现了哈夫曼编码的算法。

根据生成的哈夫曼树,递归地生成字符对应的哈夫曼编码,并输出编码结果。

对指定的字符串进行了编码测试,验证了哈夫曼编码的正确性和有效性。

四、实验结果分析1. 哈夫曼编码在数据传输和存储中具有较高的压缩效率和可靠性,能够有效减少数据传输量和存储空间;2. 哈夫曼树及哈夫曼编码在通信领域、数据压缩和加密等方面有着广泛的应用和重要意义;3. 在实际应用中,哈夫曼编码的构建和解码算法需要较大的时间和空间复杂度,对于大规模数据的处理存在一定的局限性。

五、实验总结通过本次实验,深入理解了哈夫曼树及哈夫曼编码的理论知识,并掌握了C语言中实现哈夫曼树及哈夫曼编码的方法。

对哈夫曼编码在实际应用中的优势和局限性有了更深入的认识,这对今后的学习和工作有着积极的意义。

六、参考文献1. 《数据结构(C语言版)》,严蔚敏赵现军著,清华大学出版社,2012年;2. 《算法导论》,Thomas H. Cormen 等著,机械工业出版社,2006年。

数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告

数据结构哈夫曼树实验报告一、实验目的本次实验的主要目的是深入理解和掌握哈夫曼树的数据结构及其相关算法,并通过实际编程实现来提高对数据结构的应用能力和编程技能。

二、实验环境本次实验使用的编程环境为具体编程语言名称,操作系统为具体操作系统名称。

三、实验原理哈夫曼树,又称最优二叉树,是一种带权路径长度最短的二叉树。

其基本原理是通过构建一棵二叉树,使得权值较大的节点距离根节点较近,权值较小的节点距离根节点较远,从而达到带权路径长度最小的目的。

在构建哈夫曼树的过程中,首先需要将所有的节点按照权值从小到大进行排序。

然后,选取权值最小的两个节点作为左右子树,构建一个新的父节点,该父节点的权值为左右子节点权值之和。

重复这个过程,直到所有的节点都被构建到哈夫曼树中。

哈夫曼编码是基于哈夫曼树的一种编码方式。

对于每个叶子节点,从根节点到该叶子节点的路径上,向左的分支编码为 0,向右的分支编码为 1,这样就可以得到每个叶子节点的哈夫曼编码。

四、实验步骤1、定义节点结构体```ctypedef struct HuffmanNode {char data;int weight;struct HuffmanNode left;struct HuffmanNode right;} HuffmanNode;```2、实现节点排序函数```cvoid sortNodes(HuffmanNode nodes, int n) {for (int i = 0; i < n 1; i++){for (int j = 0; j < n i 1; j++){if (nodesj>weight > nodesj + 1>weight) {HuffmanNode temp = nodesj;nodesj = nodesj + 1;nodesj + 1 = temp;}}}}```3、构建哈夫曼树```cHuffmanNode buildHuffmanTree(HuffmanNode nodes, int n) {while (n > 1) {sortNodes(nodes, n);HuffmanNode left = nodes0;HuffmanNode right = nodes1;HuffmanNode parent =(HuffmanNode )malloc(sizeof(HuffmanNode));parent>data ='\0';parent>weight = left>weight + right>weight;parent>left = left;parent>right = right;nodes0 = parent;nodes1 = nodesn 1;n;}return nodes0;}```4、生成哈夫曼编码```cvoid generateHuffmanCodes(HuffmanNode root, int codes, int index) {if (root>left) {codesindex = 0;generateHuffmanCodes(root>left, codes, index + 1);}if (root>right) {codesindex = 1;generateHuffmanCodes(root>right, codes, index + 1);}if (!root>left &&!root>right) {printf("%c: ", root>data);for (int i = 0; i < index; i++){printf("%d", codesi);}printf("\n");}}```5、主函数```cint main(){HuffmanNode nodes5 ={(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode)),(HuffmanNode )malloc(sizeof(HuffmanNode))};nodes0>data ='A';nodes0>weight = 5;nodes1>data ='B';nodes1>weight = 9;nodes2>data ='C';nodes2>weight = 12;nodes3>data ='D';nodes3>weight = 13;nodes4>data ='E';nodes4>weight = 16;HuffmanNode root = buildHuffmanTree(nodes, 5);int codes100;generateHuffmanCodes(root, codes, 0);return 0;}```五、实验结果与分析通过运行上述程序,得到了每个字符的哈夫曼编码:A: 00B: 01C: 10D: 110E: 111分析实验结果可以发现,权值较小的字符A 和B 对应的编码较短,而权值较大的字符D 和E 对应的编码较长。

哈夫曼树实验报告

哈夫曼树实验报告

一、实验目的1. 理解哈夫曼树的基本概念和构造方法。

2. 掌握哈夫曼编码的原理和实现过程。

3. 通过实验加深对数据结构中树型结构应用的理解。

二、实验原理哈夫曼树(Huffman Tree)是一种带权重的二叉树,用于实现哈夫曼编码。

其基本思想是:将字符按照在数据集中出现的频率进行排序,然后选取两个最小频率的字符合并成一个新节点,其频率为两个字符频率之和,重复此过程,直到只剩下一个节点,即为哈夫曼树的根节点。

哈夫曼编码是一种基于哈夫曼树的编码方法,其原理是将每个字符映射到一个唯一的二进制序列,序列的长度与字符在数据集中出现的频率成反比。

频率越高,编码的长度越短,从而提高信息传输的效率。

三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验步骤1. 初始化(1)从数据文件中读取字符及其频率。

(2)构建一个优先队列(最小堆),将字符和频率存储在队列中。

2. 构建哈夫曼树(1)从优先队列中取出两个频率最小的节点,合并成一个新节点,其频率为两个节点频率之和。

(2)将新节点插入优先队列中。

(3)重复步骤(1)和(2),直到优先队列中只剩下一个节点,即为哈夫曼树的根节点。

3. 哈夫曼编码(1)遍历哈夫曼树,从根节点到叶子节点的路径上,左子树表示0,右子树表示1。

(2)将每个叶子节点的字符和对应的编码存储在哈夫曼编码表中。

4. 编码(1)读取待编码的文本。

(2)根据哈夫曼编码表,将文本中的每个字符映射到对应的编码。

(3)将编码序列写入文件。

5. 译码(1)读取编码文件。

(2)从哈夫曼树的根节点开始,根据编码序列的每一位,判断是左子树还是右子树。

(3)当到达叶子节点时,输出对应的字符。

(4)重复步骤(2)和(3),直到编码序列结束。

五、实验结果与分析1. 实验结果(1)成功构建了哈夫曼树,并生成了哈夫曼编码表。

(2)对给定的文本进行了编码和译码,验证了编码的正确性。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

c++数据结构实验哈夫曼树数据结构实验报告1.实验要求i.实验目的:(1)掌握二叉树基本操作的实现方法(2)掌握二叉树基本操作的实现方法(3)了解哈夫曼树的思想和相关概念(4)学习使用二叉树解决实际问题的能力(5)熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法,熟练改错方法。

(6)熟悉设计算法的过程(7)进一步掌握指针、异常处理的使用ii.实验内容:利用二叉树结构实现赫夫曼编/解码器。

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

3、编码(Encoding):根据编码表对输入的字符串进行编码,并将编码后的字符串输出。

4、译码(Decoding):利用已经建好的赫夫曼树对编码后的字符串进行译码,并输出译码结果。

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

测试数据:I love data Structure, I love Computer.I will try my best to study data structure.提示:1、用户界面可以设计为“菜单”方式:能够进行交互。

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

iii.代码要求:1、必须要有异常处理,比如删除空链表时需要抛出异常;2、保持良好的编程的风格:代码段与段之间要有空行和缩近标识符名称应该与其代表的意义一致函数名之前应该添加注释说明该函数的功能关键代码应说明其功能3、递归程序注意调用的过程,防止栈溢出2. 程序分析树形结构是一种非线性结构可以用结点之间的分支来表示层次关系,二叉树是每个结点最多两个子树的有序树,十分适合计算机处理问题,而哈夫曼树是一种特殊的二叉树,它将权值大的数据放在了离根较近的结点处,这样使得带权路径长度最短,是非常好的存储方式。

2.1 存储结构1.结点结构的存储方式:右孩子……struct hnode //哈夫曼树结点的结构体{int weight;int parent;int lchild;int rchild;char data;};结点存储示意图:2.编码表的实现中使用了以下结构体:Struct hcode //编码表结构体{char data; //字符char code[100]; //编码内容};示意图为:3.在select函数中使用的结构体:struct node{int num;char data;};2.2关键算法分析:A)Init初始化:统计需要编码的字符串中每个字符的频度并建立哈夫曼树实现:在函数中设置了一个数组type用来统计字符串中字符的类型,no数组则用于统计每种字符串的个数,count用于存储每类字符的相应的个数。

void Huffman::Init() //将输入的数据保存至类中{cout << "请输入需要编译压缩的内容" << endl;cin.getline(in, 500, '\n');n = 0;no = 0;count = new node[127];//typefor (int j = 0; j < 127; j++) //对每一种字符的个数进行初始化{count[j].num = 0;}while (in[no] != '\0') //结束之前,每输入一个字符,则对应的数目增1{++count[in[no]].num;count[in[no]].data = in[no];++no;}for (int k = 0; k<127; k++) {if (count[k].num>0){n++;cout << count[k].data << count[k].num << endl;}}}将初始化的数据用于建立哈夫曼树:void Huffman::createht(){no = 0;htree = new hnode[2 * n - 1];//含有n种字符的哈夫曼树需要2*n-1个结点for (int i = 0; i<n; i++){while (count[no].num == 0) //该字符没有出现,跳过,继续找出现过的字符{no++;}htree[i].weight = count[no].num;//将count里统计的次数传入哈夫曼树的节点中,作为字符权重htree[i].lchild = -1;htree[i].rchild = -1;htree[i].parent = -1;//将左右孩子结点和父节点都置空htree[i].data = count[no].data;//将字符传入哈夫曼树的结点no++;}int x = -1, y = -1;for (int i = n; i < 2 * n - 1; i++){SelectMin(x, y, i);//挑选三者中的权重较小的两个htree[x].parent = htree[y].parent = i; //令较小的x、y为孩子节点,该两个结点的父节点是ihtree[i].weight = htree[x].weight +htree[y].weight;//i结点字符的权重赋为是左右孩子字符权重之和htree[i].lchild = x; //左孩子为xhtree[i].rchild = y; //右孩子为yhtree[i].parent = -1; //父节点置空x = -1;y = -1;}}注意select函数的编写十分重要,必须成功选出每次权值最小的两个数据才能正确的建立哈夫曼树void Huffman::SelectMin(int&x, int&y, intk) //选出权值较小的两个字符结点{int i = 0;while (i < k){while (i < k&&htree[i].parent == -1) //当前结点不具有父结点且满足i<k则进行循环{if (x == -1) //左孩子x = i;else if (y == -1)y = i;elseif (htree[x].weight <=htree[y].weight){if (htree[y].weight <=htree[i].weight){y = y; x = x;}elsey = i;}elseif (htree[x].weight > htree[y].weight){if (htree[i].weight >= htree[x].weight){x = x; y = y;}elsex = i;}i++;}i++;}}B)create table建立编码表:利用初始化得到的结果将哈夫曼树进行编码并输出每个字符的编码。

1.在程序中设置了一个数组save来存储每个字符的编码。

void Huffman::createhc() //建立哈夫曼编码表{hcodetable = new hcode[n]; //生成编码表for (int i = 0; i<n; i++){hcodetable[i].data = htree[i].data;int child = i;int parent = htree[i].parent;int k = 0;while (parent != -1){if (child == htree[parent].lchild) //该节点是父节点的左孩子则编码为0,右孩子则编码为1hcodetable[i].code[k] = '0';elsehcodetable[i].code[k] = '1';k++;child = parent; //将该节点的父节点进行编码输出parent = htree[child].parent;}hcodetable[i].code[k] = '\0'; //code 数组以\0结尾Reverse(hcodetable[i].code); //逆置输出字符的编码值}cout << "每个字符的编码为:" << endl;for (int i = 0; i<n; i++){cout << hcodetable[i].data << ":" << hcodetable[i].code << endl;//逐个输出对应的字符和其编码}}2.输出编码的结果与创建顺序相反故需要建立一个数组将编码数组的顺序调整。

void Reverse(char use[]) //逆置函数{char t[500];int i = 0, j = 0;while (use[i] != '\0'){t[i] = use[i];i++;}t[i] = '\0';i--;while (i >= 0) //通过t数组将use数组内的数据逆序排序{use[j] = t[i];i--;j++;}use[j] = '\0';}C).Encoding根据编码表对输入的字符串进行编码,并将编码后的字符串进行输出。

void Huffman::Encoding() //编译输入内容为代码内容用0和1表示{cout << "编码结果为:";int k = 0;for (int i = 0; in[i] != '\0'; i++){int j = 0;while (hcodetable[j].data != in[i]) //编码表的字符等于输入内容的字符时进行下一个while循环{j++;}int m = 0;while (hcodetable[j].code[m] != '\0')//输出该字符的编码{save[k] = hcodetable[j].code[m];//save数组记录编码数据cout << save[k] << endl;k++;m++;}}save[k] = '\0';cout << endl;}D).Decoding译码:利用建好的哈夫曼树对编码后的字符串进行译码,并输出译码的结果。

相关文档
最新文档