树和哈夫曼树实验报告

合集下载

哈夫曼实验报告实验目的(3篇)

哈夫曼实验报告实验目的(3篇)
5. 使用哈夫曼编码对实验数据进行压缩。
6. 对压缩数据进行解压缩,验证哈夫曼编码的正确性。
7. 分析实验结果,对比压缩前后数据的差异。
五、实验总结
通过本次实验,我们掌握了哈夫曼编码的原理和构造方法,学会了如何使用哈夫曼编码进行数据压缩和解压缩。实验结果表明,哈夫曼编码能够有效降低数据的冗余,提高数据压缩效果。同时,本次实验也加深了我们对数据结构中树形结构及其应用的理解,提高了算法设计和实现能力。在今后的学习和工作中,我们将继续探索哈夫曼编码及其应用,为相关领域的研究和发展贡献自己的力量。
二、实验内容
1. 理解哈夫曼编码的原理,掌握哈夫曼树的构造方法。
2. 编写程序实现哈夫曼树的构建、编码和解码过程。
3. 对给定的字符集进行哈夫曼编码,并分析编码后的结果。
4. 对编码后的数据进行解码,验证解码结果的正确性。
5. 比较哈夫曼编码与其他编码方法在数据压缩方面的性能。
三、实验原理
哈夫曼编码是一种基于字符频率的变长编码方法。在哈夫曼编码中,每个字符都被赋予一个唯一的编码,编码的长度与其在原始数据中的频率成反比。频率高的字符编码较短,频率低的字符编码较长。这样,哈夫曼编码在保证数据完整性的同时,实现了数据压缩的目的。
2. 能够编写程序实现哈夫曼编码和解码,提高编程能力。
3. 分析哈夫曼编码在不同场景下的压缩效果,为实际应用提供参考。
4. 了解哈夫曼编码在实际应用中的优势和局限性,为解决实际问题提供思路。
5. 培养实验操作能力,提高解决实际问题的能力。
通过本次实验,我们希望学员能够全面掌握哈夫曼编码的原理、构造方法及其在实际应用中的价值,为今后的学习和工作打下坚实的基础。
第2篇
一、实验目的
1. 理解哈夫曼编码的原理及其在数据压缩中的应用。

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

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

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

二、实验环境本次实验使用的编程语言为 Python,开发工具为 PyCharm。

操作系统为 Windows 10。

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

其基本思想是通过构建一棵二叉树,使得权值较大的节点离根节点较近,权值较小的节点离根节点较远,从而实现带权路径长度的最小化。

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

对于给定的字符集及其出现的频率,通过构建哈夫曼树,可以为每个字符生成唯一的编码,使得编码后的字符串总长度最短。

在构建哈夫曼树的过程中,首先将每个字符及其出现的频率作为一个独立的节点,然后按照频率从小到大的顺序进行合并,每次合并两个频率最小的节点,生成一个新的节点,其频率为两个子节点频率之和。

重复这个过程,直到所有节点合并为一个根节点,最终得到的二叉树即为哈夫曼树。

四、实验步骤1、定义节点类```pythonclass Node:def __init__(self, char, freq, left=None, right=None):selfchar = charselffreq = freqselfleft = leftselfright = rightdef __lt__(self, other):return selffreq < otherfreq```这个节点类包含了字符、频率以及左右子节点的信息,并实现了小于比较方法,以便在构建哈夫曼树时进行节点的排序。

2、构建哈夫曼树```pythondef build_huffman_tree(freq_dict):nodes = Node(char, freq) for char, freq in freq_dictitems()while len(nodes) > 1:nodessort()left = nodespop(0)right = nodespop(0)merged_freq = leftfreq + rightfreqnew_node = Node(None, merged_freq, left, right)nodesappend(new_node)return nodes0```该函数根据字符频率字典创建节点列表,然后不断合并频率最小的两个节点,直到只剩下一个节点,即哈夫曼树的根节点。

树和哈夫曼树实验报告

树和哈夫曼树实验报告

树和哈夫曼树实验报告一.实验目的练习树和哈夫曼树的有关操作,和各个算法程序,理解哈夫曼树的编码和译码二.实验环境Microsoft visual c++三.实验问题描述1. 问题描述:建立一棵用二叉链表方式存储的二叉树,并对其进行遍历(先序、中序和后序),打印输出遍历结果。

基本要求:从键盘接受输入先序序列,以二叉链表作为存储结构,建立二叉树(以先序来建立),并将此二叉树按照“树状形式”打印输出,然后对其进行遍历(先序、中序和后序),最后将遍历结果打印输出。

在遍历算法中要求至少有一种遍历采用非递归方法。

测试数据:ABCØØDEØGØØFØØØ(其中Ø表示空格字符)输出结果为:先序:ABCDEGF先序:CBEGDFA先序:CGEFDBA2. 问题描述:利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。

但是,这要求在发送端通过一个编码系统对待传数据预先编码,在接受端将传来的数据进行译码(复原)。

对于双工信道(即可以双向传输信息的信道),每端都需要一个完整的编/译码系统。

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

基本要求:(至少完成功能1-2)一个完整的系统应具有以下功能:I:初始化(Initialization)。

从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树,并将它存于文件hfmTree中。

基本要求:E:编码(Encoding)。

利用已建好的哈夫曼树(如不在内存,则从文件hfmTree中读入),对文件ToBeTran中的正文进行编码,然后将结果存入文件CodeFile中。

D:译码(Decoding )。

利用已建好的哈夫曼树将文件CodeFile中的代码进行译码,结果存入文件TextFile中。

P:印代码文件(Print)。

将文件CodeFile以紧凑格式显示在终端上,每行50个代码。

哈夫曼树_实验报告

哈夫曼树_实验报告

一、实验目的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. 实验结果分析通过实验,验证了哈夫曼树和哈夫曼编码的正确性。

赫夫曼树实验报告

赫夫曼树实验报告

赫夫曼树实验报告赫夫曼树实验报告引言:赫夫曼树是一种用于数据压缩的重要算法,它通过构建一棵二叉树来实现对数据的编码和解码。

本次实验旨在通过实际操作,深入了解赫夫曼树的原理和应用,并验证其在数据压缩中的有效性。

一、实验背景数据压缩在现代信息技术中起着至关重要的作用。

随着数据量的不断增加,如何有效地压缩数据成为了一个迫切的问题。

赫夫曼树作为一种经典的数据压缩算法,具有较高的压缩比和较快的解压速度,因此备受关注。

二、实验目的1. 了解赫夫曼树的原理和构建方法;2. 掌握赫夫曼编码的过程和步骤;3. 验证赫夫曼树在数据压缩中的有效性。

三、实验过程1. 构建赫夫曼树首先,我们需要统计待压缩数据中各个字符的出现频率。

然后,按照频率从小到大的顺序,将字符构建成一棵二叉树。

具体构建方法为:每次选取频率最低的两个字符,将它们作为左右子节点,生成一个新的节点,该节点的频率为左右子节点频率之和。

重复此过程,直到所有字符都被构建成树的节点。

2. 进行赫夫曼编码在赫夫曼树构建完成后,我们需要对每个字符进行编码。

编码的规则是:向左走为0,向右走为1。

从根节点开始,对每个字符进行路径搜索,直到找到对应的叶子节点,记录下路径上的0和1,即为该字符的编码。

3. 数据压缩与解压缩利用赫夫曼编码,我们可以对待压缩数据进行压缩。

将每个字符替换为对应的编码后,将所有编码拼接起来,即可得到压缩后的数据。

解压缩则是将编码根据赫夫曼树进行反向解码,得到原始数据。

四、实验结果通过实验,我们将不同类型的数据进行了压缩和解压缩,并与原始数据进行了对比。

结果表明,赫夫曼树在数据压缩中表现出色,能够显著减小数据的大小,同时保持数据的完整性。

五、实验总结赫夫曼树作为一种高效的数据压缩算法,具有广泛的应用前景。

通过本次实验,我们深入了解了赫夫曼树的原理和构建方法,并验证了其在数据压缩中的有效性。

赫夫曼树的应用不仅可以提高数据传输的效率,还可以节省存储空间,对于大数据时代的到来具有重要意义。

哈夫曼树 实验报告

哈夫曼树 实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

哈夫曼树实验报告

哈夫曼树实验报告

哈夫曼树实验报告一、需求分析(1)输入输出形式输入数组的组数n: 整形变量组数(回车)请依次输入n组权值与字符, 中间用空格隔开。

如“2 a”:按右提示格式输入(回车)请输入待编译文本: 随机输入字符(回车)输出: 编译出的代码请输入待编译代码: 随机输入一串代码(回车)(2)输出: 编译出的代码(3)程序功能1. 用C语言实现二叉树的说明2. 输入n个权值, 并生成n个二叉树3. 对n个二叉树逐步生成Huffman树4. 对Huffman树的每个叶子结点生成编码5.用哈夫曼树编码。

6.解码哈夫曼编码。

(4)测试用例设计Example1: 输入325 a15 b60 cabbacc010*******输出010*******abbaccExample2: 输入510 a20 b30 c20 d10 eababcde10000100001101101输出10000100001101101ababcde二、概要设计1.根据给定的n个权值(w1, w2, …, wn)构成n棵二叉树的集合F={T1, T2, …, Tn}, 其中每棵二叉树Ti中只有一个带树为Ti的根结点在F中选取两棵根结点的权值最小的树作为左右子树构造一棵新的二叉树, 且置其根结点的权值为其左右子树权值之和3.在F中删除这两棵树, 同时将新得到的二叉树加入F中4.重复2, 3, 直到F只含一棵树为止三、 5.将给定的字符串通过程序编码成哈夫曼编码, 并打印结果在屏幕上。

四、 6.翻译给定的哈夫曼编码变成可读字符串, 并将结果打印在屏幕上。

五、详细设计四、调试分析(1)编译代码、运行代码所遇到的问题及其解决办法问题1: 编译代码过程中有遇到循环体的循环次数不对, 导致二叉树生成得不对解决办法:通过小数字的演算, 检验循环, 再进行更改(2)算法的时空分析(3)心得体会五、用户使用说明如上图所示, 依次输入组数、权值及全值所对应字符。

再根据用户自身需求输入需编译的文本及代码。

哈夫曼树实验报告 (2)

哈夫曼树实验报告 (2)

三、实验要求
设计思路: 数据结构: #define n 100‫ﻩﻩ‬//叶子结点数 #define m 2*n-1// Huffman 树中结点总数 typedef struct {
‫ ﻩ‬int weight; //权值 ‫ ﻩ‬int lchild , rchild , parent; //左右孩子及双亲指针
scanf ("%d",w+i);
HuffmanCoding(HT,HC,w,n);
for(i=1;i<=n;i++){
printf("对应得编码为:");
puts(HC[i]);}
}
}
//****从叶子到根逆向求每个字符得赫夫曼编码****
HC=(HuffmanCode)malloc((n+1)*sizeof(char*));//分配n个字符编码得头指针向量
cd=(char*)malloc(n*sizeof(char));
//分配求编码得工作区间
cd[n-1]='\0';
//编码结束符
else cd[--start]='1';
HC[i]=(char *)malloc((n-start)*sizeof(char)); //为第i个字符编码分配空间
strcpy(HC[i],&cd[start]);
//从 cd 复制编码(串)到 HC

free(cd);
//释放空间

void main()
for(i=1;i<=n;++i)
//逐个字符求赫夫曼树编码
{ int start;
start=n-1;
//编码结束符位置

哈夫曼树实验报告

哈夫曼树实验报告

哈夫曼树实验报告一、实验目的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"。

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

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

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

哈夫曼树实验实验报告(3篇)

哈夫曼树实验实验报告(3篇)

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

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

3. 熟练运用哈夫曼树解决实际问题,提高数据压缩效率。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 构造哈夫曼树2. 哈夫曼编码3. 哈夫曼译码四、实验步骤1. 数据准备(1)创建一个包含字符及其权值的数组,例如:`{'a', 5, 'b', 9, 'c', 12, 'd', 13, 'e', 16, 'f', 45}`。

(2)根据数组内容,使用C++编写程序,实现以下功能:- 将数组元素插入到最小堆中。

- 构建哈夫曼树。

2. 哈夫曼编码(1)遍历哈夫曼树,记录每个字符的编码。

(2)根据编码规则,将字符和编码存储在映射表中。

(3)将映射表输出到文件中。

3. 哈夫曼译码(1)从文件中读取编码序列。

(2)根据哈夫曼树,逐个解码字符。

(3)将解码后的字符输出到文件中。

五、实验结果1. 哈夫曼树```45/ \16 29/ \ / \13 3 12 4/ \ / / \d c b a f```2. 哈夫曼编码```a: 0b: 100c: 101d: 110e: 111f: 1```3. 编码前后的数据```原始数据:abcdef编码后数据:0100110110111011```六、实验分析1. 哈夫曼树通过构建哈夫曼树,可以将权值较小的字符分配较短的编码,权值较大的字符分配较长的编码,从而提高数据压缩效率。

2. 哈夫曼编码哈夫曼编码是一种前缀编码,可以保证解码过程不会产生歧义。

3. 哈夫曼译码通过哈夫曼树,可以快速地将编码序列解码为原始数据。

七、实验总结1. 通过本次实验,掌握了哈夫曼树的基本概念、构造方法、编码和译码原理。

哈夫曼实验报告

哈夫曼实验报告

一、实验目的1. 理解哈夫曼编码的基本原理和重要性。

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

3. 熟悉哈夫曼编码和译码的实现过程。

4. 分析哈夫曼编码在数据压缩中的应用效果。

二、实验原理哈夫曼编码是一种基于字符频率的编码方法,它利用字符出现的频率来构造一棵最优二叉树(哈夫曼树),并根据该树生成字符的编码。

在哈夫曼树中,频率越高的字符对应的编码越短,频率越低的字符对应的编码越长。

这样,对于出现频率较高的字符,编码后的数据长度更短,从而实现数据压缩。

三、实验内容1. 构建哈夫曼树:- 统计待编码数据中每个字符出现的频率。

- 根据字符频率构建哈夫曼树,其中频率高的字符作为叶子节点,频率低的字符作为内部节点。

- 重复上述步骤,直到树中只剩下一个节点,即为哈夫曼树的根节点。

2. 生成哈夫曼编码:- 从哈夫曼树的根节点开始,对每个节点进行遍历,根据遍历方向(左子树为0,右子树为1)为字符分配编码。

- 将生成的编码存储在编码表中。

3. 编码和译码:- 使用生成的编码表对原始数据进行编码,将编码后的数据存储在文件中。

- 从文件中读取编码后的数据,根据编码表进行译码,恢复原始数据。

四、实验步骤1. 编写代码实现哈夫曼树的构建:- 定义节点结构体,包含字符、频率、左子树、右子树等属性。

- 实现构建哈夫曼树的核心算法,包括节点合并、插入等操作。

2. 实现编码和译码功能:- 根据哈夫曼树生成编码表。

- 编写编码函数,根据编码表对数据进行编码。

- 编写译码函数,根据编码表对数据进行译码。

3. 测试实验效果:- 选择一段文本数据,使用实验代码进行编码和译码。

- 比较编码前后数据的长度,分析哈夫曼编码的压缩效果。

五、实验结果与分析1. 哈夫曼树构建:- 成功构建了哈夫曼树,树中节点按照字符频率从高到低排列。

2. 哈夫曼编码:- 成功生成编码表,字符与编码的对应关系符合哈夫曼编码原理。

3. 编码与译码:- 成功实现编码和译码功能,编码后的数据长度明显缩短,译码结果与原始数据完全一致。

哈弗曼树实验报告(3篇)

哈弗曼树实验报告(3篇)

一、实验目的1. 理解并掌握哈弗曼树的构建原理。

2. 学会使用哈弗曼树进行数据编码和解码。

3. 了解哈弗曼编码在数据压缩中的应用。

二、实验原理哈弗曼树(Huffman Tree)是一种带权路径长度最短的二叉树,用于数据压缩。

其基本原理是:将待编码的字符集合按照出现频率从高到低排序,构造一棵二叉树,使得叶子节点代表字符,内部节点代表编码,权值代表字符出现的频率。

通过这棵树,可以生成每个字符的编码,使得编码的平均长度最小。

三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019四、实验步骤1. 构建哈弗曼树(1)创建一个结构体`HuffmanNode`,包含字符、权值、左子树和右子树指针。

```cppstruct HuffmanNode {char data;int weight;HuffmanNode left;HuffmanNode right;};(2)定义一个函数`HuffmanTree()`,用于创建哈弗曼树。

```cppHuffmanNode HuffmanTree(std::vector<char>& chars, std::vector<int>& weights) {// 创建初始二叉树std::vector<HuffmanNode> trees;for (int i = 0; i < chars.size(); ++i) {trees.push_back(new HuffmanNode{chars[i], weights[i], nullptr, nullptr});}// 构建哈弗曼树while (trees.size() > 1) {// 选择两个权值最小的节点auto it1 = std::min_element(trees.begin(), trees.end(),[](HuffmanNode a, HuffmanNode b) {return a->weight < b->weight;});auto it2 = std::next(it1);HuffmanNode parent = new HuffmanNode{0, it1->weight + it2->weight, it1, it2};// 删除两个子节点trees.erase(it1);trees.erase(it2);// 将父节点添加到二叉树集合中trees.push_back(parent);}// 返回哈弗曼树根节点return trees[0];}```2. 生成哈弗曼编码(1)定义一个函数`GenerateCodes()`,用于生成哈弗曼编码。

赫夫曼树的实验报告

赫夫曼树的实验报告

一、实验目的1. 理解赫夫曼树的概念和原理;2. 掌握赫夫曼树的构建方法;3. 学会使用赫夫曼树进行数据压缩和解压缩;4. 了解赫夫曼树在实际应用中的优势。

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

在构建赫夫曼树的过程中,每次选择两个权值最小的节点作为左右子节点,然后合并成一个新的节点,权值为两个子节点权值之和。

重复此过程,直到只剩下一个节点,即为赫夫曼树的根节点。

赫夫曼树在数据压缩中的应用主要体现在编码和解码过程中。

通过对字符进行赫夫曼编码,可以将字符序列转换成二进制序列,从而减少数据存储空间。

在解码过程中,根据赫夫曼树的结构,可以将二进制序列还原成原始字符序列。

三、实验内容1. 构建赫夫曼树(1)输入字符及其权值,例如:A=5, B=9, C=12, D=13, E=16, F=45。

(2)将输入的字符和权值放入最小堆中,每次取出两个最小权值的节点,合并成一个新的节点,权值为两个子节点权值之和。

(3)重复步骤(2),直到只剩下一个节点,即为赫夫曼树的根节点。

2. 使用赫夫曼树进行数据压缩和解压缩(1)根据赫夫曼树生成字符的编码,例如:A=01, B=100, C=101, D=110, E=1110, F=1111。

(2)对输入的字符序列进行编码,例如:输入字符串"ABCDEF",编码后为"01010010101111111111"。

(3)将编码后的二进制序列存储或传输。

(4)接收方根据赫夫曼树的结构,对二进制序列进行解码,还原成原始字符序列。

四、实验结果与分析1. 实验结果(1)构建赫夫曼树```F/ \B D/ \ / \A C E G```(2)字符编码```A=01, B=100, C=101, D=110, E=1110, F=1111```(3)输入字符串"ABCDEF"的编码结果为"01010010101111111111"。

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

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

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、虽然最终顺利的编完了程序,但是总的来说哈夫曼树还是很不容易的。

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

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

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

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

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

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

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

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

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

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

对于每个叶子节点,从根节点到该叶子节点的路径上,向左的分支编码为 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 对应的编码较长。

树和哈夫曼树实验报告

树和哈夫曼树实验报告

哈夫曼树实验报告2011.4.22实验题目: Huffman编码和译码。

实验目的:1、练习树和哈夫曼树的有关操作, 和各个算法程序。

2.理解哈夫曼树的编码和译码实验内容:抽象数据类型:ADT Huffmantree{数据对象: D={带有各自实数W(D)的数据元素}数据关系: (1) D=NULL 则huffman tree 不存在//判断huffman树是否存在(2) D≠NULL R={H}.H为如下二元关系://如果存在, 假设R为其元素名称, H为里边所有元素①D中存在唯一根数据元素root,这个元素无前驱。

//如果只有一个元素, 则为根元素②D-{root} ≠NULL.则存在D-{root} ={D1, Dr}.且D1∧Dr=NULL//如果除了根元素还有别的元素, 那么会有D1和Dr两部分, 并且两者的交集为空, 也就是两者是独立的。

③若D1 ≠NULL , 则D1 中存在唯一元素xr,<root, xr>∈H//如果D1部位空集, 则会有一个元素xr, 且存在Dr上关系Hr ∈H,H= {<root ,x1>,< root, xr>,H1,Hr};④符合①②③的R的组合中, 存在一个组合R’使D中所有结点到root长与其权值W(Di)相乘的和最小, 此时的<D/R>集合称为huffman tree.基本操作:void select(HTNode HT[],int m,int *s1,int *s2)//比较得到权最小的两棵树。

用指针指向所在位置。

*void print1(char *HC[])//将哈弗曼编码逐个打印出来void print2(HTNode HT[])//将哈夫曼树前后的结构打印出来void CreatHuffmanTree(HTNode HT[],lettervalue w[])//建立哈夫曼树void HuffmanTreeCoding(HTNode HT[],char *HC[])//从树根出发, 对哈夫曼树做一次先序遍历, 在遍历过程中利用一个字符//的顺序栈S记下遍历路程, 向左转时0入栈, 向右转时1入栈。

哈夫曼实验报告总结

哈夫曼实验报告总结

哈夫曼实验报告总结哈夫曼编码是一种用于数据压缩的有效算法,它能够将出现频率较高的字符用较短的编码表示,而将出现频率较低的字符用较长的编码表示,从而实现数据的压缩。

本次实验的目的是通过实现哈夫曼编码算法,深入理解哈夫曼编码的原理和应用,并通过实验证明其压缩效果。

在实验中,我们首先需要计算每个字符在给定文本中的出现频率。

通过统计文本中的字符频率,我们可以构建出一个字符频率表,其中每个字符和其对应的频率成对出现。

接下来,根据字符频率表,我们需要构建哈夫曼树。

哈夫曼树是一种特殊的二叉树,它的叶子节点对应于字符,而非叶子节点对应于字符的编码。

构建哈夫曼树的过程是通过将频率较小的字符不断相加作为新的频率节点,直到最终构建出完整的哈夫曼树。

构建哈夫曼树的过程是一个递归的过程,可以通过优先队列或最小堆来实现。

构建完哈夫曼树后,我们可以根据哈夫曼树为每个字符生成对应的编码。

在哈夫曼树中,从根节点到叶子节点的路径表示字符的编码,路径上的左-右方向分别表示0和1。

生成编码的过程是通过遍历哈夫曼树的路径,并记录经过的方向来实现的。

为了更高效地生成编码,可以使用哈希表或者数组来存储每个字符对应的编码。

实验中,我们将生成的哈夫曼编码应用于数据的压缩。

通过将文本中的每个字符替换为其对应的哈夫曼编码,并将生成的编码串连接起来,可以实现对数据的压缩。

压缩效果取决于字符的频率分布情况,频率更高的字符会得到较短的编码,而频率较低的字符会得到较长的编码。

在本次实验中,我们通过分别计算原始文本和压缩后文本的字节数,计算了压缩率。

压缩率的计算公式为:压缩率 = (1 - 压缩后字节数 / 原始字节数) * 100%。

通过实验数据的对比,我们可以发现,哈夫曼编码能够有效地减小数据的存储空间,实现较高的压缩率。

通过本次实验,我深入学习了哈夫曼编码的原理和实现方法。

哈夫曼编码是一种非常有效的数据压缩算法,广泛应用于各类数据压缩工具和通信传输中。

哈夫曼树实验报告

哈夫曼树实验报告

一、实验目的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)。

树和哈夫曼树实验报告一.实验目的练习树和哈夫曼树的有关操作,和各个算法程序,理解哈夫曼树的编码和译码二.实验环境Microsoft visual c++三.实验问题描述1. 问题描述:建立一棵用二叉链表方式存储的二叉树,并对其进行遍历(先序、中序和后序),打印输出遍历结果。

基本要求:从键盘接受输入先序序列,以二叉链表作为存储结构,建立二叉树(以先序来建立),并将此二叉树按照“树状形式”打印输出,然后对其进行遍历(先序、中序和后序),最后将遍历结果打印输出。

在遍历算法中要求至少有一种遍历采用非递归方法。

测试数据:ABCØØDEØGØØFØØØ(其中Ø表示空格字符)输出结果为:先序:ABCDEGF先序:CBEGDFA先序:CGEFDBA2. 问题描述:利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。

但是,这要求在发送端通过一个编码系统对待传数据预先编码,在接受端将传来的数据进行译码(复原)。

对于双工信道(即可以双向传输信息的信道),每端都需要一个完整的编/译码系统。

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

基本要求:(至少完成功能1-2)一个完整的系统应具有以下功能:I:初始化(Initialization)。

从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树,并将它存于文件hfmTree中。

基本要求:E:编码(Encoding)。

利用已建好的哈夫曼树(如不在内存,则从文件hfmTree中读入),对文件ToBeTran中的正文进行编码,然后将结果存入文件CodeFile中。

D:译码(Decoding )。

利用已建好的哈夫曼树将文件CodeFile中的代码进行译码,结果存入文件TextFile中。

P:印代码文件(Print)。

将文件CodeFile以紧凑格式显示在终端上,每行50个代码。

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

T:印哈夫曼树(TreePrinting)。

将已在内存中的哈夫曼树以直观的方式(树或凹入表形式)显示在终端上,同时将此字符形式的哈夫曼树写入文件TreePrint中。

测试数据:设权值w=(5,29,7,8,14,23,3,11),n=8。

按照字符‘0’或‘1’确定找左孩子或右孩子,则权值对应的编码为:5:0001,29:11,7:1110,8:111114:110,23:01,3:0000,11:001用下表给出的字符集和频度的实际统计数据建立哈夫曼树,并实现以下报文的编码和译码:“THIS PROGRAM IS MY FAVORITE”。

四.实验主要程序流实验题目一主要程序:1.void CreatBiTree(BitTree *bt)//用扩展先序遍历序列创建二叉树,如果是#当前树根置为空,否则申请一个新节点//{char ch;ch=getchar();if(ch=='.')*bt=NULL;else{*bt=(BitTree)malloc(sizeof(BitNode));(*bt)->data=ch;CreatBiTree(&((*bt)->LChild));CreatBiTree(&((*bt)->RChild));}}2.void Visit(char ch)//访问根节点{printf("%c ",ch);}3.void PreOrder(BitTree root){if (root!=NULL){Visit(root ->data);PreOrder(root ->LChild);PreOrder(root ->RChild);}}4.void InOrder(BitTree root){if (root!=NULL){InOrder(root ->LChild);Visit(root ->data);InOrder(root ->RChild);}5.int PostTreeDepth(BitTree bt) //后序遍历求二叉树的高度递归算法//{int hl,hr,max;if(bt!=NULL){hl=PostTreeDepth(bt->LChild); //求左子树的深度hr=PostTreeDepth(bt->RChild); //求右子树的深度max=hl>hr?hl:hr; //得到左、右子树深度较大者return(max+1); //返回树的深度}else return(0); //如果是空树,则返回0}6.void PrintTree(BitTree Boot,int nLayer) //按竖向树状打印的二叉树//{int i;if(Boot==NULL) return;PrintTree(Boot->RChild,nLayer+1);for(i=0;i<nLayer;i++)printf(" ");printf("%c\n",Boot->data);PrintTree(Boot->LChild,nLayer+1);}7.void main(){BitTree T;int h;int layer;int treeleaf;layer=0;printf("请输入二叉树中的元素(以扩展先序遍历序列输入,其中.代表空子树):\n");CreatBiTree(&T);printf("先序遍历序列为:");PreOrder(T);printf("\n中序遍历序列为:");InOrder(T);printf("\n后序遍历序列为:");PostOrder(T);h=PostTreeDepth(T);printf("\此二叉树的深度为:%d\n",h);printf("此二叉树的横向显示为:\n");PrintTree(T,layer);}实验二主要程序流:1.int main(){HuffmanTree huftree;char Choose;while(1){cout<<"\n**********************欢迎使用哈夫曼编码/译码系统**********************\n";cout<<"*您可以进行以下操作: *\n";cout<<"*1.建立哈夫曼树*\n";cout<<"*2.编码(源文已在文件ToBeTra中,或键盘输入) *\n";cout<<"* 3.译码(码文已在文件CodeFile中) *\n";cout<<"* 4.显示码文*\n";cout<<"* 5.显示哈夫曼树*\n";cout<<"* 6.退出 *\n"; cout<<"************************************ ***********************************\n";cout<<"请选择一个操作:";cin>>Choose;switch(Choose){case '1':huftree.CreateHuffmanTree();break;case '2':huftree.Encoder();break;case '3':huftree.Decoder();break;case '4':huftree.PrintCodeFile();break;case '5':huftree.PrintHuffmanTree();break;case '6':cout<<"\n**********************感谢使用本系统!*******************\n\n";system("pause");return 0;}//switch}//while}//main2.// 建立哈夫曼树函数// 函数功能:建立哈夫曼树(调用键盘建立哈夫曼树或调用从文件建立哈夫曼树的函数)void HuffmanTree::CreateHuffmanTree(){char Choose;cout<<"你要从文件中读入哈夫曼树(按1),还是从键盘输入哈夫曼树(按2)?";cin>>Choose;if(Choose=='2') { //键盘输入建立哈夫曼树CreateHuffmanTreeFromKeyboard();}//choose=='2'else { //从哈夫曼树文件hfmTree.dat中读入信息并建立哈夫曼树CreateHuffmanTreeFromFile();}}3. // 从键盘建立哈夫曼树函数// 函数功能:从键盘建立哈夫曼树//函数参数:无//参数返回值:无void HuffmanTree::CreateHuffmanTreeFromKeyboard(){int Num;cout<<"\n请输入源码字符集个数:";cin>>Num;if (Num<=1) {cout<<"无法建立少于2个叶子结点的哈夫曼树。

\n\n";return;}LeafNum=Num;Node=new HuffmanNode[2*Num-1];for(int i=0;i<Num;i++) {//读入哈夫曼树的叶子结点信息cout<<"请输入第"<<i+1<<"个字符值";getchar();Node[i].sourcecode=getchar(); //源文的字符存入字符数组Info[]getchar();cout<<"请输入该字符的权值或频度";cin>>Node[i].weight; //源文的字符权重存入Node[].weightNode[i].parent=-1;Node[i].lchild=-1;Node[i].rchild=-1;Node[i].code="\0";}for(int j=Num;j<2*Num-1;j++) {//循环建立哈夫曼树内部结点int pos1,pos2;int max1,max2;pos2=pos1=j;max2=max1=numeric_limits<int>::max( );//在所有子树的根结点中,选权重最小的两个根结点,pos1最后应指向权重最小的根结点的下标//pos2最后应指向权重第二小的根结点的下标//max1存放当前找到的权重最小的根结点的权重//max2存放当前找到的权重第二小的根结点的权重for(int k=j-1;k>=0;k--) {if (Node[k].parent==-1){//如果是某棵子树的根结点if (Node[k].weight<max1){ //发现比当前最大值还大的权重max2=max1;max1=Node[k].weight;pos2=pos1;pos1=k;}elseif(Node[k].weight<max2){ //发现比当前次大值还大的次大权重max2=Node[k].weight;pos2=k;}}//if (Node[j].parent==-1)} //for//在下标i处新构造一个哈夫曼树的内部结点,其左、右孩子就是以上pos1、pos2所指向的结点Node[pos1].parent=j;Node[pos2].parent=j;Node[j].lchild=pos1;Node[j].rchild=pos2;Node[j].parent=-1;Node[j].weight=Node[pos1].weight+Node[pos2].weight;} //for//产生所有叶子结点中字符的编码for (int m=0;m<Num;m++) {//产生Node[i].sourcecode的编码,存入Node[i].code中int j=m;int j1;while(Node[j].parent!=-1) { //从叶结点开始往根结点走,每往上走一层,就产生一位编码存入code[]j1=Node[j].parent;if(Node[j1].lchild==j)Node[m].code.insert(0,"0");elseNode[m].code.insert(0,"1");j=j1; }}cout<<"哈夫曼树已成功构造完成。

相关文档
最新文档