数据结构——线索二叉树实验报告
实验报告二叉树
递归遍历右子树输出根结点数data}void postOrder1 (struct btnode *bt){概念栈,结点参数p,prebt入栈While(栈或p是不是为空){提取栈顶元素值if判定p是不是为空或是pre的根结点输出根结点数data栈顶元素出栈栈顶元素p赋给pre记录else if右结点非空将右结点压栈if左结点将左结点压栈}}void main(){struct btnode *root=NULL;root=createbt(root);preOrder(root); midOrder(root); postOrder(root);preOrder1(root); midOrder1(root); postOrder1(root);
数据结构 二叉树 实验报告
1 二叉树的实现与运算
(1)定义结二叉树的结构体 typedef char TELemType; typedef struct BTree {
TELemType data; struct BTree *lChild; struct BTree *rChild; }BinTree; (2)二叉树的创建 BinTree *CreateTree1(BinTree *T) { char temp; //scanf("%c", &temp); temp=getch(); printf("%c",temp); if(temp == '#')
二.概要设计(常金娥)
1.二叉树的实现和运算 BinTree *CreateTree1(BinTree *T) 初始条件:给二叉树 T 的定义。 操作结果:构造二叉树 T。 BinTree *CreateTree1(BinTree *T) 初始条件:二叉树 T 存在。 操作结果:计算叶子结点的数量。 PreOrderTraverse(T,visit()) 初始条件:二叉树 T 存在,visit 是对结点操作的应用函数。 操作结果:先序遍历 T,对每个结点调用函数 visit 一次且仅一次。一旦 visit() 失败,则操作失败。 InOrderTraverse(T,visit()) 初始条件:二叉树 T 存在,visit 是对结点操作的应用函数。 操作结果:中序遍历 T,对每个结点调用函数 visit 一次且仅一次。一旦 visit() 失败,则操作失败。 PostOrderTraverse(T,visit()) 初始条件:二叉树 T 存在,visit 是对结点操作的应用函数。 操作结果:后序遍历 T,对每个结点调用函数 visit 一次且仅一次。一旦 visit() 失败,则操作失败。
数据结构实验报告二二叉树实验
实验报告课程名称:数据结构
第 1 页共4 页
五、实验总结(包括心得体会、问题回答及实验改进意见,可附页)
这次实验主要是建立二叉树,和二叉树的先序、中序、后续遍历算法。
通过这次实验,我巩固了二叉树这部分知识,从中体会理论知识的重要性。
在做实验之前,要充分的理解本次实验的理论依据,这样才能达到事半功倍的效果。
如果在没有真正理解实验原理之盲目的开始实验,只会浪费时间和精力。
例如进行二叉树的遍历的时候,要先理解各种遍历的特点。
先序遍历是先遍历根节点,再依次先序遍历左右子树。
中序遍历是先中序遍历左子树,再访问根节点,最后中序遍历右子树。
而后序遍历则是先依次后续遍历左右子树,再访问根节点。
掌握了这些,在实验中我们就可以融会贯通,举一反三。
其次要根据不光要懂得代码的原理,还要对题目有深刻的了解,要明白二叉树的画法,在纸上先进行自我演练,对照代码验证自己写的正确性。
第 3 页共4 页
第 4 页共4 页。
数据结构课程设计报告之线索二叉树
线索二叉树一目的程序从文件中读取每个结点的信息,然后建立一个二叉树。
通过菜单的形式,选择不同的线索化方式,然后再对线索化的二叉树经行遍历并输出对应的结果。
二需求分析1、文件的读入程序首先要从一个文件中读入结点的信息。
故需建立一个文件,在文件中,给出每个结点的信息。
2、菜单的实现由于需要建立两种不同的线索二叉树,故需要一个菜单,来选择需要进行的操作,并输出操作的结果。
3、树的建立从文件中,读入每个结点的信息。
然后建立起树,然后再对已建立的树进行相应的线索化。
4、树的线索化根据菜单的选择,对已建立的树经行相对应的线索化。
5、输出遍历的结果对每种不同的线索化的的树,给出相对应的算法。
然后,根据算法把每种遍历的结果输出。
三概要设计1、主程序模块(1)主程序模块int main(){welcome(); //通过welcome()模块来让用户控制,做线索化的工作。
return 0;}(2)可线索化单元模块—实现各种线索化的抽象数据类型;通过welcome()模块来调用每个线索化模块。
2、建立二叉树的模块bool CreatBinTree();函数会根据用户输入的文件名,打开一个存储了树中每个结点的文件,且是用广义表的形式给出结点信息的文件。
操作结果:根据文件中广义表的形式,建立相对应的二叉树,该树的根节点为root。
3、线索化的抽象数据类型void CreatInThread();void CreatInThread(Node *current,Node *&front)current是中序遍历下,当前遍历的结点的指针。
front是中序遍历下,current结点的前驱的指针。
操作结果:对建立的二叉树完成中序线索化。
void CreatPostThread();void CreatPostThread(Node *current,Node *&front)current是后续遍历下,当前遍历的结点的指针。
数据结构二叉树的实验报告
数据结构二叉树的实验报告数据结构二叉树的实验报告一、引言数据结构是计算机科学中非常重要的一个领域,它研究如何组织和存储数据以便高效地访问和操作。
二叉树是数据结构中常见且重要的一种,它具有良好的灵活性和高效性,被广泛应用于各种领域。
本实验旨在通过实际操作和观察,深入了解二叉树的特性和应用。
二、实验目的1. 理解二叉树的基本概念和特性;2. 掌握二叉树的创建、遍历和查找等基本操作;3. 通过实验验证二叉树的性能和效果。
三、实验过程1. 二叉树的创建在实验中,我们首先需要创建一个二叉树。
通过输入一系列数据,我们可以按照特定的规则构建一棵二叉树。
例如,可以按照从小到大或从大到小的顺序将数据插入到二叉树中,以保证树的有序性。
2. 二叉树的遍历二叉树的遍历是指按照一定的次序访问二叉树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历是先访问根节点,然后再依次遍历左子树和右子树;中序遍历是先遍历左子树,然后访问根节点,最后再遍历右子树;后序遍历是先遍历左子树,然后遍历右子树,最后访问根节点。
3. 二叉树的查找二叉树的查找是指在二叉树中寻找指定的节点。
常见的查找方式有深度优先搜索和广度优先搜索。
深度优先搜索是从根节点开始,沿着左子树一直向下搜索,直到找到目标节点或者到达叶子节点;广度优先搜索是从根节点开始,逐层遍历二叉树,直到找到目标节点或者遍历完所有节点。
四、实验结果通过实验,我们可以观察到二叉树的特性和性能。
在创建二叉树时,如果按照有序的方式插入数据,可以得到一棵平衡二叉树,其查找效率较高。
而如果按照无序的方式插入数据,可能得到一棵不平衡的二叉树,其查找效率较低。
在遍历二叉树时,不同的遍历方式会得到不同的结果。
前序遍历可以用于复制一棵二叉树,中序遍历可以用于对二叉树进行排序,后序遍历可以用于释放二叉树的内存。
在查找二叉树时,深度优先搜索和广度优先搜索各有优劣。
深度优先搜索在空间复杂度上较低,但可能会陷入死循环;广度优先搜索在时间复杂度上较低,但需要较大的空间开销。
数据结构二叉树的建立实践报告
数据结构二叉树的建立实践报告下载温馨提示:该文档是我店铺精心编制而成,希望大家下载以后,能够帮助大家解决实际的问题。
文档下载后可定制随意修改,请根据实际需要进行相应的调整和使用,谢谢!并且,本店铺为大家提供各种各样类型的实用资料,如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等,如想了解不同资料格式和写法,敬请关注!Download tips: This document is carefully compiled by the editor. I hope that after you download them, they can help yousolve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you!In addition, our shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts,other materials and so on, want to know different data formats and writing methods, please pay attention!数据结构是计算机科学中的重要基础知识之一,而二叉树又是数据结构中的一种重要形式。
数据结构实验报告—二叉树
数据结构实验报告—二叉树数据结构实验报告—二叉树引言二叉树是一种常用的数据结构,它由节点和边构成,每个节点最多有两个子节点。
在本次实验中,我们将对二叉树的基本结构和基本操作进行实现和测试,并深入了解它的特性和应用。
实验目的1. 掌握二叉树的基本概念和特性2. 熟练掌握二叉树的基本操作,包括创建、遍历和查找等3. 了解二叉树在实际应用中的使用场景实验内容1. 二叉树的定义和存储结构:我们将首先学习二叉树的定义,并实现二叉树的存储结构,包括节点的定义和节点指针的表示方法。
2. 二叉树的创建和初始化:我们将实现二叉树的创建和初始化操作,以便后续操作和测试使用。
3. 二叉树的遍历:我们将实现二叉树的前序、中序和后序遍历算法,并测试其正确性和效率。
4. 二叉树的查找:我们将实现二叉树的查找操作,包括查找节点和查找最大值、最小值等。
5. 二叉树的应用:我们将探讨二叉树在实际应用中的使用场景,如哈夫曼编码、二叉搜索树等。
二叉树的定义和存储结构二叉树是一种特殊的树形结构,它的每个节点最多有两个子节点。
节点被表示为一个由数据和指向其左右子节点的指针组成的结构。
二叉树可以分为三类:满二叉树、完全二叉树和非完全二叉树。
二叉树可以用链式存储结构或顺序存储结构表示。
- 链式存储结构:采用节点定义和指针表示法,通过将节点起来形成一个树状结构来表示二叉树。
- 顺序存储结构:采用数组存储节点信息,通过计算节点在数组中的位置来进行访问和操作。
二叉树的创建和初始化二叉树的创建和初始化是二叉树操作中的基础部分。
我们可以通过手动输入或读取外部文件中的数据来创建二叉树。
对于链式存储结构,我们需要自定义节点和指针,并通过节点的方式来构建二叉树。
对于顺序存储结构,我们需要定义数组和索引,通过索引计算来定位节点的位置。
一般来说,初始化一个二叉树可以使用以下步骤:1. 创建树根节点,并赋初值。
2. 创建子节点,并到父节点。
3. 重复步骤2,直到创建完整个二叉树。
二叉树 实验报告
二叉树实验报告二叉树实验报告引言:二叉树是一种常见的数据结构,它由节点和边组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。
在本次实验中,我们将探索二叉树的基本概念、特性以及应用。
一、二叉树的定义与性质1.1 二叉树的定义二叉树是一种递归定义的数据结构,它可以为空,或者由一个根节点和两个二叉树组成,分别称为左子树和右子树。
1.2 二叉树的性质(1)每个节点最多有两个子节点,分别称为左子节点和右子节点。
(2)左子树和右子树也是二叉树。
(3)二叉树的子树之间没有关联性,它们是相互独立的。
二、二叉树的遍历方式2.1 前序遍历前序遍历是指先访问根节点,然后按照先左后右的顺序遍历左子树和右子树。
2.2 中序遍历中序遍历是指先遍历左子树,然后访问根节点,最后遍历右子树。
2.3 后序遍历后序遍历是指先遍历左子树,然后遍历右子树,最后访问根节点。
2.4 层次遍历层次遍历是指按照从上到下、从左到右的顺序遍历二叉树的每个节点。
三、二叉树的应用3.1 二叉搜索树二叉搜索树是一种特殊的二叉树,它的每个节点的值大于其左子树的所有节点的值,小于其右子树的所有节点的值。
这种特性使得二叉搜索树可以高效地进行查找、插入和删除操作。
3.2 哈夫曼树哈夫曼树是一种带权路径长度最短的二叉树,它常用于数据压缩中。
哈夫曼树的构建过程是通过贪心算法,将权值较小的节点放在离根节点较远的位置,从而实现最优编码。
3.3 表达式树表达式树是一种用于表示数学表达式的二叉树,它的叶节点是操作数,而非叶节点是操作符。
通过对表达式树的遍历,可以实现对表达式的求值。
结论:通过本次实验,我们对二叉树的定义、性质、遍历方式以及应用有了更深入的了解。
二叉树作为一种重要的数据结构,在计算机科学和算法设计中发挥着重要的作用。
在今后的学习和工作中,我们应该进一步探索二叉树的高级应用,并灵活运用于实际问题的解决中。
数据结构二叉树综合实验报告
数据结构二叉树综合实验报告数据结构二叉树综合实验报告1.引言在计算机科学中,二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树具有广泛的应用场景,如在搜索算法、图形处理和编译器设计中等。
本报告旨在介绍我们进行的二叉树综合实验,包括实验目的、实验过程中的具体步骤和实验结果分析等。
2.实验目的本实验的主要目的是通过设计和实现二叉树的基本操作,加深对二叉树的理解,并掌握二叉树的基本算法和应用。
具体的实验目标包括:- 熟悉二叉树的基本概念和性质;- 掌握二叉树的创建、插入和删除操作;- 实现二叉树的遍历算法,包括前序、中序和后序遍历;- 实现二叉树的搜索功能;- 进行基于二叉树的排序实验。
3.实验步骤3.1 二叉树的创建首先,我们需要创建一个空的二叉树。
通过定义二叉树的节点结构和指针,可以动态地分配内存空间用于创建节点,并建立节点之间的连接关系。
3.2 节点的插入在已有的二叉树中,我们可以向其中插入新的节点。
插入操作通常涉及到比较节点的键值大小,然后根据比较结果决定插入新节点的位置。
3.3 节点的删除除了插入节点,我们也可能需要从二叉树中删除节点。
删除操作通常需要考虑节点的子节点情况,例如,被删除的节点是否有左子节点、右子节点或者同时存在。
3.4 二叉树的遍历二叉树的遍历操作可以按照不同的顺序进行,包括前序(根-左-右)、中序(左-根-右)和后序(左-右-根)遍历。
在实验中,我们需要实现这三种遍历算法,并观察它们的输出结果。
3.5 二叉树的搜索在已有的二叉树中,我们可根据节点的键值进行搜索操作。
通过比较键值,我们可以判断在左子树或右子树中进行进一步的搜索,直至找到目标节点或确定目标节点不存在于二叉树中。
3.6 基于二叉树的排序二叉树可以作为一种排序算法的基础结构。
在实验中,我们可以通过节点的插入操作构建一个包含数据集的二叉树,并通过中序遍历获取有序的数据。
数据结构——线索二叉树实验报告
线索二叉树应用实验实验报告实验目的(1)掌握线索二叉树的有关知识。
(2)掌握求解线索二叉树中结点前趋和后继的算法以及以相应次序遍历线索二叉树的算法。
(3)掌握二叉树的线索化算法的设计。
实验运行环境Visual C++实验任务线索二叉树是为了快速求解二叉树中结点在指定次序下的前驱和后继,而将二叉链表中空的左右孩子指针分别改为指向其前驱和后继结点而得到的结构,反映了运算对数据结构的设计的影响。
因此,首先要了解线索二叉树的结构特点,其中原本为空的指针被修改为前驱和后继指针,使得对左右子树和线索的判断发生了变化。
利用线索可以实现某些次序下的前驱和后继。
本实验期望能理解线索二叉树的结构特点,实现各前驱和后接算法的求解,并掌握将二叉树转换为线索二叉树的算法,即线索化算法。
为使实验程序简洁直观,下面的部分实验程序中的一些功能实现仍以调用库函数程序"btrechar.h"中的函数的形式给出,并假设该库函数中定义了线索二叉树的相关功能,如显示线索二叉树等。
实验内容第一题:按先序次序遍历先序线索二叉树。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: letter.cbt实验准备:1:将二叉树的根结点的指针传给函数。
2:判断当前结点是否为先序遍历的最后一个结点,若是则访问完该结点后结束,否则进入3。
2:判断当前结点是否有左子树,若有的话访问完该结点后访问它的左子树,否则访问它的右子树,返回2。
第二题:按中序次序遍历中序线索二叉树。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: letter.cbt实验准备:1:将二叉树的根结点的指针传给函数。
2:判断当前结点是否为中序遍历的最后一个结点,若是则访问完该结点后结束,否则进入3。
3:对于当前结点,先访问该结点的前驱结点并进入第二步,其次访问该结点并进入第二步最后访问该结点的后继结点并进入2。
第三题:将值为x的结点作为先序线索二叉树T的左子树的(先序)最后一个结点的右孩子插入进去。
数据结构二叉树实验报告总结
数据结构二叉树实验报告总结一、实验目的本次实验的主要目的是通过对二叉树的学习和实践,掌握二叉树的基本概念、性质和遍历方式,加深对数据结构中树形结构的理解。
二、实验内容1. 二叉树的基本概念和性质在本次实验中,我们首先学习了二叉树的基本概念和性质。
其中,二叉树是由节点组成的有限集合,并且每个节点最多有两个子节点。
同时,我们还学习了二叉树的高度、深度、层数等概念。
2. 二叉树的遍历方式在了解了二叉树的基本概念和性质之后,我们开始学习如何遍历一个二叉树。
在本次实验中,我们主要学习了三种遍历方式:前序遍历、中序遍历和后序遍历。
其中,前序遍历指先访问节点自身再访问左右子节点;中序遍历指先访问左子节点再访问自身和右子节点;后序遍历指先访问左右子节点再访问自身。
3. 二叉搜索树除了以上内容之外,在本次实验中我们还学习了一种特殊的二叉树——二叉搜索树。
二叉搜索树是一种特殊的二叉树,它的每个节点都满足左子节点小于该节点,右子节点大于该节点的性质。
由于这个性质,二叉搜索树可以被用来进行快速查找、排序等操作。
三、实验过程1. 实现二叉树的遍历方式为了更好地理解和掌握二叉树的遍历方式,我们首先在编程环境中实现了前序遍历、中序遍历和后序遍历。
在代码编写过程中,我们需要考虑如何递归地访问每个节点,并且需要注意访问顺序。
2. 实现二叉搜索树为了更好地理解和掌握二叉搜索树的特性和操作,我们在编程环境中实现了一个简单的二叉搜索树。
在代码编写过程中,我们需要考虑如何插入新节点、删除指定节点以及查找目标节点等操作。
3. 实验结果分析通过对代码运行结果进行分析,我们可以清晰地看到每个遍历方式所得到的结果以及对应的顺序。
同时,在对二叉搜索树进行操作时,我们也可以看到不同操作所产生的不同结果。
四、实验总结通过本次实验,我们进一步加深了对二叉树的理解和掌握,学习了二叉树的遍历方式以及二叉搜索树的特性和操作。
同时,在编程实践中,我们也进一步熟悉了代码编写和调试的过程。
数据结构实验报告-树(二叉树)
实验5:树(二叉树)(采用二叉链表存储)一、实验项目名称二叉树及其应用二、实验目的熟悉二叉树的存储结构的特性以及二叉树的基本操作。
三、实验基本原理之前我们都是学习的线性结构,这次我们就开始学习非线性结构——树。
线性结构中结点间具有唯一前驱、唯一后继关系,而非线性结构中结点的前驱、后继的关系并不具有唯一性。
在树结构中,节点间关系是前驱唯一而后继不唯一,即结点之间是一对多的关系。
直观地看,树结构是具有分支关系的结构(其分叉、分层的特征类似于自然界中的树)。
四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和预定义2.创建二叉树3.前序遍历4.中序遍历5.后序遍历6.总结点数7.叶子节点数8.树的深度9.树根到叶子的最长路径10.交换所有节点的左右子女11.顺序存储12.显示顺序存储13.测试函数和主函数对二叉树的每一个操作写测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define MAX_TREE_SIZE 100typedef char ElemType;ElemType SqBiTree[MAX_TREE_SIZE];struct BiTNode{ElemType data;BiTNode *l,*r;}*T;void createBiTree(BiTNode *&T){ElemType e;e = getchar();if(e == '\n')return;else if(e == ' ')T = NULL;else{if(!(T = (BiTNode *)malloc(sizeof (BiTNode)))){cout << "内存分配错误!" << endl;exit(0);}T->data = e;createBiTree(T->l);createBiTree(T->r);}}void createBiTree2(BiTNode *T,int u) {if(T){SqBiTree[u] = T->data;createBiTree2(T->l,2 * u + 1);createBiTree2(T->r,2 * u + 2); }}void outputBiTree2(int n){int cnt = 0;for(int i = 0;cnt <= n;i++){cout << SqBiTree[i];if(SqBiTree[i] != ' ')cnt ++;}cout << endl;}void preOrderTraverse(BiTNode *T) {if(T){cout << T->data;preOrderTraverse(T->l);preOrderTraverse(T->r);}}void inOrderTraverse(BiTNode *T) {if(T){inOrderTraverse(T->l);cout << T->data;inOrderTraverse(T->r);}}void beOrderTraverse(BiTNode *T){if(T){beOrderTraverse(T->l);beOrderTraverse(T->r);cout << T->data;}}int sumOfVer(BiTNode *T){if(!T)return 0;return sumOfVer(T->l) + sumOfVer(T->r) + 1;}int sumOfLeaf(BiTNode *T){if(!T)return 0;if(T->l == NULL && T->r == NULL)return 1;return sumOfLeaf(T->l) + sumOfLeaf(T->r);}int depth(BiTNode *T){if(!T)return 0;return max(depth(T->l),depth(T->r)) + 1;}bool LongestPath(int dist,int dist2,vector<ElemType> &ne,BiTNode *T) {if(!T)return false;if(dist2 == dist)return true;if(LongestPath(dist,dist2 + 1,ne,T->l)){ne.push_back(T->l->data);return true;}else if(LongestPath(dist,dist2 + 1,ne,T->r)){ne.push_back(T->r->data);return true;}return false;}void swapVer(BiTNode *&T){if(T){swapVer(T->l);swapVer(T->r);BiTNode *tmp = T->l;T->l = T->r;T->r = tmp;}}//以下是测试程序void test1(){getchar();cout << "请以先序次序输入二叉树结点的值,空结点用空格表示:" << endl; createBiTree(T);cout << "二叉树创建成功!" << endl;}void test2(){cout << "二叉树的前序遍历为:" << endl;preOrderTraverse(T);cout << endl;}void test3(){cout << "二叉树的中序遍历为:" << endl;inOrderTraverse(T);cout << endl;}void test4(){cout << "二叉树的后序遍历为:" << endl;beOrderTraverse(T);cout << endl;}void test5(){cout << "二叉树的总结点数为:" << sumOfVer(T) << endl;}void test6(){cout << "二叉树的叶子结点数为:" << sumOfLeaf(T) << endl; }void test7(){cout << "二叉树的深度为:" << depth(T) << endl;}void test8(){int dist = depth(T);vector<ElemType> ne;cout << "树根到叶子的最长路径:" << endl;LongestPath(dist,1,ne,T);ne.push_back(T->data);reverse(ne.begin(),ne.end());cout << ne[0];for(int i = 1;i < ne.size();i++)cout << "->" << ne[i];cout << endl;}void test9(){swapVer(T);cout << "操作成功!" << endl;}void test10(){memset(SqBiTree,' ',sizeof SqBiTree);createBiTree2(T,0);cout << "操作成功!" << endl;}void test11(){int n = sumOfVer(T);outputBiTree2(n);}int main(){int op = 0;while(op != 12){cout << "-----------------menu--------------------" << endl;cout << "--------------1:创建二叉树--------------" << endl;cout << "--------------2:前序遍历----------------" << endl;cout << "--------------3:中序遍历----------------" << endl;cout << "--------------4:后序遍历----------------" << endl;cout << "--------------5:总结点数----------------" << endl;cout << "--------------6:叶子节点数--------------" << endl;cout << "--------------7:树的深度----------------" << endl;cout << "--------------8:树根到叶子的最长路径----" << endl;cout << "--------------9:交换所有节点左右子女----" << endl;cout << "--------------10:顺序存储---------------" << endl;cout << "--------------11:显示顺序存储-----------" << endl;cout << "--------------12:退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl;if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1();break;case 2:test2();break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:cout << "测试结束!" << endl;break;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果测试用例:1.创建二叉树(二叉链表形式)2.前序遍历3.中序遍历4.后序遍历5.总结点数6.叶子结点数7.树的深度8.树根到叶子的最长路径9.交换所有左右子女10.顺序存储七、思考讨论题或体会或对改进实验的建议通过这次实验,我掌握了二叉树的顺序存储和链式存储,体会了二叉树的存储结构的特性,掌握了二叉树的树上相关操作。
数据结构之二叉树编程实验报告
实验报告:二叉树题目:建立一棵二叉树,数据以字符串形式从键盘输入,在此二叉树上完成:(1)前序、中序、后序遍历(2)求出叶子数(3)求树高(4)左右子树交换,输出交换后的前序、中序遍历序列分析:建树:输入的字符串序列为带有空节点的前序遍历序列(空节点用*表示)。
①:前序,中序,后序遍历:递归遍历②:求叶子数:当一个节点的左右孩子都是NULL时,此节点即为叶子节点。
③:求树高当前节点的树高等于其左右孩子树高大的加1。
④:左右子树交换:对于每个节点,将其左右孩子交换,再递归对其左右子树交换。
测试结果:附:源码#include <iostream>#include <stdlib.h>using namespace std;struct Bintree{char data;Bintree* lchild;Bintree* rchild;};Bintree *head;int sp;/* 已知一棵二叉树的前序序列,建立这棵树*/ void CreateTree(Bintree *&p,char a[]){Bintree *temp;if(a[sp]!=0){if(a[sp]=='*'){p=NULL;sp++;return ;}p=new Bintree;p->data=a[sp++];CreateTree(p->lchild,a);CreateTree(p->rchild,a);}else p=NULL;}/* 求一棵树的高度*/int Depth(Bintree *&t){int lh , rh ;if( t == NULL ){return 0 ;}else{lh = Depth( t->lchild ) ;rh = Depth( t->rchild ) ;return ( lh > rh ? lh : rh ) + 1 ;}}/* 将二叉树的左右子树互换*/ void Exchange1(Bintree *&t){Bintree *temp;if(t){Exchange1(t->lchild);Exchange1(t->rchild);temp=t->lchild;t->lchild=t->rchild;t->rchild=temp;}}/* 按照前序递归遍历二叉树*/ void Preorder1(Bintree *&t){if(t!=NULL){printf("%c",t->data);Preorder1(t->lchild);Preorder1(t->rchild);}}/* 按照中序递归遍历二叉树*/ void Inorder1(Bintree *&t){if(t!=NULL){Inorder1(t->lchild);printf("%c",t->data);Inorder1(t->rchild);}}/* 按照后序递归遍历二叉树*/void Posorder1(Bintree *&t){if(t!=NULL){Posorder1(t->lchild);Posorder1(t->rchild);printf("%c",t->data);}}/* 递归法求叶子结点个数*/int Leaves_Num1(Bintree *&t){if(t){if(t->lchild==NULL&&t->rchild==NULL){return 1;}return Leaves_Num1(t->lchild)+Leaves_Num1(t->rchild);}return 0;}/*******************************************/int main (){char a[100];memset(a,0,sizeof(a));cout<<"输入带有空节点的前序遍历序列(空节点用*表示)"<<endl;cin>>a;sp=0;CreateTree(head,a);cout<<"前序遍历:"<<endl;Preorder1(head);cout<<endl;cout<<"中序遍历:"<<endl;Inorder1(head);cout<<endl;cout<<"后序遍历:"<<endl;Posorder1(head);cout<<endl;cout<<"叶子数:"<<Leaves_Num1(head)<<endl;cout<<"树高:"<<Depth(head)<<endl;cout<<"左右子树交换后"<<endl;Exchange1(head);cout<<"前序遍历:"<<endl;Preorder1(head);cout<<endl;cout<<"中序遍历:"<<endl;Inorder1(head);cout<<endl;cout<<"后序遍历:"<<endl;Posorder1(head);cout<<endl;return 0;}。
数据结构实验报告-线索二叉树的遍历
线索二叉树的遍历--《数据结构实验报告》1.基本思想对于n个结点的二叉树,在二叉链存储结构中有n+1个空链域,利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针,这些指针称为线索,加上线索的二叉树称为线索二叉树。
线索二叉树的建立就是在二叉树的基础上进行线索化。
本次实验建立了前序线索二叉树,中序线索二叉树,和后序线索二叉树,并分别对前中序线索二叉树进行了前序,中序,后序遍历,对后序线索二叉树进行了后序遍历。
2.用到的数据结构定义节点元素:Left, right为普通二叉树的左右孩子,value为该节点元素的值,Ltag, Rtag为左右线索化指向节点。
在某些遍历中会用到栈结构,用来存储当前可以路过,但是在以后却访问不到的点。
3.基本操作实现1.前,中,后序二叉树的线索化:线索化的实质是将二叉链表中的空指针改为指向前驱或后继的线索,前驱和后继的信息是在遍历过程中才能得到,故线索化的过程即为在遍历过程中修改空指针的过程。
前,中,序线索化的过程相似,只是修改NULL和递归遍历左右孩子的顺序导致产生不同。
2.前序线索二叉树的前序遍历:因为前序线索二叉树建立的过程就是按照前序遍历的思想线索化的,所以按照一直向左走,直到左边的指向为线索时停止,开始向右指(不管是线索还是树枝),依次递归得到答案。
3.前序线索二叉树的中序遍历:根据前序线索化的二叉树在中序遍历时如果按照前序遍历的方式会出现上面的一些点永远无法被访问到,所以,增加一个数据结构—栈。
在一直向左遍历的时候,将这些节点入栈,在回访时,依次取出这些点,在进入到取出点的右孩子,实现中序遍历。
4.前序线索二叉树的后序遍历:思想和中序遍历差不多,但是是将栈中元素的右孩子遍历完成后在输出该元素的值,实现后序遍历。
5.中序线索二叉树的前序遍历:中序的前序遍历比较简单,和前序线索的前序遍历很像,但是在判断左右孩子是否是线索时,需进行循环遍历判断,不是简单的if。
中序线索化二叉树实验报告数据结构
中序线索化二叉树实验报告数据结构实验名称:中序线索化二叉树实验报告一、实验目的:1.掌握二叉树的基本概念和性质;2.熟悉二叉树的线索化实现方法,特别是中序线索化;3.学会使用数据结构实现中序线索化二叉树的算法。
二、实验原理:1.二叉树的线索化是将原本存储指向孩子节点的指针改为指向前驱或后继节点的指针,这样可以加快查找和遍历的速度;2.中序线索化二叉树的线索化过程是对二叉树进行中序遍历,在遍历的过程中修改指针的指向;3.在中序线索化二叉树中,空指针域指向该结点在中序遍历序列中的前驱节点或后继节点。
三、实验内容:1.创建二叉树的节点结构体,并实现二叉树的创建函数;2.实现二叉树的中序遍历函数;3.实现二叉树的线索化函数;4.分别对给定的二叉树进行创建、中序遍历和线索化;5.输出线索化结果,并验证线索化是否正确。
四、实验步骤:1.创建二叉树的节点结构体,定义节点的数据域和左右指针域,以及指针域指向的节点类型(表达孩子关系还是前驱后继关系);2.实现二叉树的创建函数,可以通过输入数据构建一个二叉树;3.实现二叉树的中序遍历函数,函数中应该具有递归的特性;4.实现二叉树的线索化函数,先确定中序遍历的第一个节点,然后根据中序遍历的性质,将节点的左右指针域进行修改;5.进行中序遍历和线索化处理,输出线索化结果;6.验证线索化的正确性,先找到线索化二叉树的最左节点,然后通过右指针找到后继节点,最终输出完整的中序遍历结果。
五、实验结果:成功创建了二叉树并进行了中序遍历和线索化,线索化结果正确。
六、实验总结:通过本次实验,我深入了解了二叉树的基本概念和性质,掌握了二叉树的线索化实现方法,特别是中序线索化的算法。
实验过程中,我仔细研究了中序线索化的原理和实现步骤,结合所学的数据结构知识,成功实现了中序线索化二叉树的算法。
实验结果表明线索化过程正确,验证了算法的正确性。
通过本次实验,我不仅巩固了二叉树的相关知识,还提高了对数据结构实现算法的能力。
二叉树实验报告总结(共10篇)
二叉树实验报告总结(共10篇)二叉树实验报告实验报告课程名称算法与数据结构专业学号姓名实验日期算法与数据结构实验报告一、实验目的1.了解二叉树的结构特点及有关概念,掌握二叉树建立的基本算法2.了解二叉树遍历的概念,掌握遍历二叉的算法3.进一步掌握树的结构及非线性特点,递归特点和动态性。
二、实验内容二叉树的实现和运算三、实验要求1.用C++/C完成算法设计和程序设计并上机调试通过。
2.撰写实验报告,提供实验结果和数据。
3.分析算法,并简要给出算法设计小结和心得。
四、算法步骤用户以三元组形式输入二叉树的结点元素及其位置关系,建立二叉树,并打印输出该二叉树。
用户输入选择结点,程序调用BiTNode* Find Node(char tag, BiTNode* node)函数,返回子树的根结点,然后调用BiTreeDepth(BiTree T)函数,求出子树的深度,并输出该值。
3.用户可以选择是否继续执行程序,若继续,则输入1,否则输入0,结束程序。
五、主程序代码:int main(void){BiTree T;TElemType e1;char node; // node为用户选择输入的结点//int b,choose; // b为以选定结点为子树的深度,choose为实现多次选择输入的标志//BiTNode* a; // a为选定结点为子树的根结点//choose=1; // 多次选择的标志,当choose为1时运行程序,为0时结束程序// InitBiTree(T);printf(构造空二叉树后,树空否?%d(1:是0:否), 树的深度=%d\n,BiTreeEmpty(T),BiTreeDepth(T));e1 = Root(T);if(e1 != Nil)#ifdef CHARprintf(二叉树的根为: %c\n,e1);#endif#ifdef INTprintf(二叉树的根为: %d\n,e1);#endifelseprintf(树空,无根\n); //三元组构建二叉树striile(x!=end){AddNode(T, x[0], x[1], x[2]);GetUserWord(x);} //输出树PrintTreeLevel( T );//以三元组形式输入任意二叉树(以大写字母表示结点),求以任意一选定结点为子树的深度。
数据结构树和二叉树实验报告
《数据结构〉课程实验报告实验名称树与二叉树实验序号5实验日期姓名院系班级学号指导教师成绩专业教师评语一、实验目得与要求(1)掌握树得相关概念,包括树、结点得度、树得度、分支结点、叶子结点、儿子结点、双亲结点、树得深度、森林等定义。
(2)掌握树得表示,包括树形表示法、文氏图表示法、凹入表示法与括号表示法等。
(3)掌握二叉树得概念,包括二叉树、满二叉树与完全二叉树得定义。
(4)掌握二叉树得性质。
(5)重点掌握二叉树得存储结构,包括二叉树顺序存储结构与链式存储结构。
(6)重点掌握二叉树得基本运算与各种遍历算法得实现。
(7)掌握线索二叉树得概念与相关算法得实现。
(8)掌握哈夫曼树得定义、哈夫曼树得构造过程与哈夫曼编码产生方法。
(9)掌握并查集得相关概念与算法。
(1 0)灵活掌握运用二叉树这种数据结构解决一些综合应用问题。
二、实验项目摘要1编写一程序,实现二叉树得各种基本运算,并在此基础上设计一个主程序完成如下功能:(1)输出二叉树b;(2)输出H结点得左、右孩子结点值;(3)输出二叉树b得深度;(4)输出二叉树b得宽度;(5)输出二叉树b得结点个数;(6)输出二叉树b得叶子结点个数。
2编写一程序,实现二叉树得先序遍历、中序遍历与后序遍历得各种递归与非递归算法,以及层次遍历得算法。
三、实验预习内容二叉树存储结构,二叉树基本运算(创建二叉树、寻找结点、找孩子结点、求高度、输出二叉树)三、实验结果与分析7-1#incl u d e < s tdio、h>#incl u d e<m a1 l o c、h># d e f in e M axS i z e 100typedef cha r E l emT y p e;ty p ed e f struct n o d e{o ElemTy p e data;。
str u c t n ode * 1 c h i 1 d ;0struct no d e * r chi l d;0}BT N ode;void Cr e a teBTNod e(BTNod e *&b,c h ar *s t r){o B TNod e* S t[M a x S ize] , *p=NULL;o i n t t o p=-1,k,j = 0:ch a r ch;b=N U L L;oo0ch= s tr廿];wh i l e C ch!='\O')叶s wit c h(ch){o ca s e'(':to p ++; St[t o p]=p;k=l;b rea k;。
数据结构二叉树实验报告(附代码)
一、【实验构思(Conceive)】(10%)(本部分应包括:描述实验实现的基本思路,包括所用到的离散数学、工程数学、程序设计、算法等相关知识)首先构造二叉树的存储结构,用data存储当前节点的值,分别用*lchild,*rchild 表示该节点的左右孩子。
然后应用BiTree Create函数,根据用户的输入构造二叉树,当输入#时表示没有孩子。
采用递归的思想构造Preorder,Inorder,Postorder函数,分别实现二叉树的先序,中序,和后序的遍历。
然后编写了Sumleaf,Depth函数,来求叶子节点的数目和二叉树的深度。
二、【实验设计(Design)】(20%)(本部分应包括:抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明,主程序模块与各子程序模块间的调用关系)二叉树的存储结构:typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;子程序模块:BiTree Create(BiTree T){char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild);}return T;}void Preorder(BiTree T){if(T){printf("%c",T->data);Preorder(T->lchild);Preorder(T->rchild);}}int Sumleaf(BiTree T){int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild)) sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}void Inorder(BiTree T) {if(T){Inorder(T->lchild); printf("%c",T->data); Inorder(T->rchild); }}void Postorder(BiTree T) {if(T){Postorder(T->lchild); Postorder(T->rchild); printf("%c",T->data); }}int Depth(BiTree T){int dep=0,depl,depr;if(!T)dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}主程序模块:int main(){BiTree T = 0;int sum,dep;printf("请输入你需要建立的二叉树\n");printf("例如输入序列ABC##DE#G##F###(其中的#表示空)\n并且输入过程中不要加回车\n输入完之后可以按回车退出\n");T=Create(T);printf("先序遍历的结果是:\n");Preorder(T);printf("\n");printf("中序遍历的结果是:\n");Inorder(T);printf("\n");printf("后序遍历的结果是:\n");Postorder(T);printf("\n");printf("统计的叶子数:\n");sum=Sumleaf(T);printf("%d",sum);printf("\n统计树的深度:\n");dep=Depth(T);printf("\n%d\n",dep);}三、【实现描述(Implement)】(30%)(本部分应包括:抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系,关键的程序流程图等,给出关键算法的时间复杂度分析。
数据结构实验三二叉树实验报告
数据结构实验报告实验名称:实验三——二叉树学生姓名: XX班级:班内序号:学号:日期:1.实验要求1.1实验目的通过选择下面两个题目之一进行实现,掌握如下内容:掌握二叉树基本操作的实现方法了解赫夫曼树的思想和相关概念学习使用二叉树解决实际问题的能力1.2实验内容根据二叉树的抽象数据类型的定义,使用二叉链表实现一个二叉树。
二叉树的基本功能:1、二叉树的建立2、前序遍历二叉树3、中序遍历二叉树4、后序遍历二叉树5、按层序遍历二叉树6、求二叉树的深度7、求指定结点到根的路径8、二叉树的销毁9、其他:自定义操作编写测试main()函数测试线性表的正确性2. 程序分析2.1 存储结构二叉树的结点结构二叉树的二叉链表存储示意图2.2 关键算法分析(1)创建一个二叉树伪代码实现:1.定义根指针,输入节点储存的data,若输入“#”,则该节点为空;2.申请一个新节点,判断它的父结点是否不为空,如果不为空在判断其为左或者右孩子,并把地址付给父结点,把data写入。
代码实现void BiTree::create(BiNode* &R,int data[],int i,int n)//创建二叉树{if(i<=n){R=new BiNode;R->data=data[i-1];create(R->lch,data,2*i,n);create(R->rch,data,2*i+1,n);}else R=NULL;}(2)前序遍历伪代码实现:1.设置递归边界条件:if root==null则停止递归2.打印起始节点的值,并先后在左子数右子数上递归调用打印函数代码实现void BiTree::preorder(BiNode* R)//前序遍历{if(R!=NULL){cout<<R->data;preorder(R->lch);preorder(R->rch);}}时间复杂度:O(n)(3)中序遍历伪代码实现:1.设置递归边界条件:if root==null则停止递归2.递归遍历左子树3.打印根节点数据域内容4.递归遍历右子树代码实现void BiTree::inorder(BiNode* R)//中序遍历{if(R!=NULL){inorder(R->lch);cout<<R->data;inorder(R->rch);}}时间复杂度:O(n)(4)后序遍历伪代码实现:1.设置递归边界条件:if root==null则停止递归2.递归遍历左子树3.递归遍历右子树4.访问根结点数据域代码实现void BiTree::postorder(BiNode* R)//后序遍历{if(R!=NULL){postorder(R->lch);postorder(R->rch);cout<<R->data;}}时间复杂度:O(n)(5)层序遍历伪代码实现1.队列Q及所需指针的定义和初始化2.如果二叉树非空,将根指针入队3.循环直到队列Q为空3.1 q=队列Q的队头元素出队3.2 访问节点q的数据域 cout<<q->data<<" ";3.3 若节点q存在左孩子,则将左孩子指针入队3.4若节点q存在右孩子,则将右孩子指针入队代码实现void BiTree::levelordre(BiNode* R)//层序遍历{BiNode*queue[maxsize];int f=0,r=0;if(R!=NULL)queue[++r]=R;while(f!=r){BiNode*p=queue[++f];cout<<p->data;if(p->lch!=NULL)queue[++r]=p->lch;if(p->rch!=NULL)queue[++r]=p->rch;}}时间复杂度:O(n)(6)计算二叉树深度伪代码实现:1. 定义和初始化计数深度的参数2.如果根节点为空,return03.如果根节点为非空,递归调用自身的到叶子节点到根的路径长度,输出其中较大的作为树的深度代码实现int BiTree::depth(BiNode* root)//求二叉树深度{int ld,rd;if (root!=NULL){ld = 1+depth(root->lch);rd = 1+depth(root->rch);return ld>rd?ld:rd;}else return 0;}时间复杂度:O(n)(7)输出指定结点到根结点的路径伪代码实现:1.建立一个存储路径结点结构,定义和初始化结构体的数组2.当root不为空或top为0时,进入循环3.当此时root所指的节点的数据不为指定数据时,将root指向它的左孩子4.当此时root所指的节点的数据为指定数据时,访问其数据域并输出代码实现bool BiTree::printPath(BiNode* root, int data)//打印指定结点到根节点的路径{if (root == NULL)return false;if (root->data == data || printPath(root->lch,data) ||printPath(root->rch,data)){cout<<root->data;return true;}return false;}3. 程序运行结果3.1测试主函数流程图:3.2测试条件对如下二叉树: 补全后的二叉树:按层序遍历的输入方法为:ABC#EFGH###I###J###@ 3.3程序运行结果为:4. 总结出现的问题及改进:刚开始编译正确但是输出结果异常,纪念馆仔细检查发现二叉树创建有问题,经过仔细修改,发现形参表示错误,*&,指针的引用,作为输入时,既把指针的值传入函数内部,又可以将指针的关系传递到函数内部;作为输出,由于算法中修改了指针的值,可以将新值传入到函数内部。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
线索二叉树应用实验实验报告实验目的(1)掌握线索二叉树的有关知识。
(2)掌握求解线索二叉树中结点前趋和后继的算法以及以相应次序遍历线索二叉树的算法。
(3)掌握二叉树的线索化算法的设计。
实验运行环境Visual C++实验任务线索二叉树是为了快速求解二叉树中结点在指定次序下的前驱和后继,而将二叉链表中空的左右孩子指针分别改为指向其前驱和后继结点而得到的结构,反映了运算对数据结构的设计的影响。
因此,首先要了解线索二叉树的结构特点,其中原本为空的指针被修改为前驱和后继指针,使得对左右子树和线索的判断发生了变化。
利用线索可以实现某些次序下的前驱和后继。
本实验期望能理解线索二叉树的结构特点,实现各前驱和后接算法的求解,并掌握将二叉树转换为线索二叉树的算法,即线索化算法。
为使实验程序简洁直观,下面的部分实验程序中的一些功能实现仍以调用库函数程序"btrechar.h"中的函数的形式给出,并假设该库函数中定义了线索二叉树的相关功能,如显示线索二叉树等。
实验内容第一题:按先序次序遍历先序线索二叉树。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: letter.cbt实验准备:1:将二叉树的根结点的指针传给函数。
2:判断当前结点是否为先序遍历的最后一个结点,若是则访问完该结点后结束,否则进入3。
2:判断当前结点是否有左子树,若有的话访问完该结点后访问它的左子树,否则访问它的右子树,返回2。
第二题:按中序次序遍历中序线索二叉树。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: letter.cbt实验准备:1:将二叉树的根结点的指针传给函数。
2:判断当前结点是否为中序遍历的最后一个结点,若是则访问完该结点后结束,否则进入3。
3:对于当前结点,先访问该结点的前驱结点并进入第二步,其次访问该结点并进入第二步最后访问该结点的后继结点并进入2。
第三题:将值为x的结点作为先序线索二叉树T的左子树的(先序)最后一个结点的右孩子插入进去。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: letter.cbt实验准备:1:将先序线索二叉树的根结点的指针传给函数。
2:判断当前结点是否为要找的结点P,若是则建立一个新的结点,将新结点作为P的右孩子,并根据新建的结点修改前驱后继关系,否则进入3。
3:指针指向该结点先序遍历的后继,返回2。
第四题:按中序次序线索化二叉树。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: letter.cbt实验准备:1:设立两个指针pre与t分别代表前驱结点与当前结点。
2:按照中序访问的顺序,对于访问到的每一个结点进行如下的操作。
3:判断当前结点是否为空,若是则结束,否则进入第四步。
4:对于当前结点如果它的左孩子为空,则将该结点前驱线索化,如果它的前驱指针pre指向的结点的右孩子为空,则将pre指向的结点后继线索化,如果对于当前结点如果它的右孩子为空,则将该结点的rchild置为1,将t 赋值给pre。
5:将t指向它在中序中的后继,返回到3。
第五题:按后序次序线索化二叉树。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: letter.cbt实验准备:1:设立两个指针pre与t分别代表前驱结点与当前结点。
2:按照后序访问的顺序,对于访问到的每一个结点进行如下的操作。
3:判断当前结点是否为空,若是则结束,否则进入4。
4:对于当前结点如果它的左孩子为空,则将该结点前驱线索化,如果它的前驱指针pre指向的结点的右孩子为空,则将pre指向的结点后继线索化,如果对于当前结点如果它的右孩子为空,则将该结点的rchild置为1,将t 赋值给pre。
5:将t指向它在后序中的后继,返回到3。
实验测试数据实验程序#include<iostream>using namespace std;int m;struct tbnode{char data;tbnode *lchild,*rchild;int ltag,rtag;};tbnode *pre=NULL; //初始化前驱指针class tbtree{public:tbtree();int height(tbnode *p);void prepare_tree(tbnode *&p); //初始化二叉树void first_tree(tbnode *p); //先序线索化void second_tree(tbnode *p); //中序线索化void third_tree(tbnode *p); //后序线索化void first_first_tree(tbnode *p); //先序编历先序线索化二叉树void second_second_tree(tbnode *p); //中序编历中序线索化二叉树tbnode *&get_root(){ return root;}tbnode *prepare(tbnode *p){if(p->ltag==0) return p->lchild;else return p->rchild;}tbnode* start(tbnode *p){if(p->rtag==1)return p->rchild;else{tbnode *q=p->rchild;while(q->ltag!=1)q=q->lchild;return q;}}private:tbnode *root;};tbtree::tbtree(){root = new tbnode ;root = NULL;}int tbtree::height(tbnode *p) //求二叉树的高度函数{int ch_1,ch_2;if(p==NULL) return(0);else{ch_1=height(p -> lchild);ch_2=height(p -> rchild);if(ch_1>ch_2) return (ch_1+1);elsereturn ch_2;}}void tbtree::prepare_tree(tbnode *&p) //初始化二叉树{char a;cin>>a;if(a == '.') p = NULL;else{p = new tbnode ;p -> data = a;prepare_tree(p -> lchild );prepare_tree(p -> rchild );}}void tbtree::first_tree(tbnode *p) //先序次序线索化二叉树{if(p != NULL){if(p -> lchild==NULL){p ->ltag = 1;p ->lchild = pre;}else p ->ltag = 0;if(pre != NULL&& pre ->rtag ==1) pre ->rchild =p;if(p ->rchild ==NULL) p -> rtag = 1;else p ->rtag = 0;}cout<<p ->data;pre = p;if(p ->ltag ==0) first_tree(p -> lchild);if(p ->rtag ==0) first_tree(p -> rchild);}void tbtree::second_tree(tbnode *p) //中序次序线索化二叉树{if(p!=NULL){second_tree(p->lchild);if(pre!=NULL&&pre->rtag==1) pre->rchild=p;if(p->lchild==NULL){p->lchild=pre;p->ltag=1;}else p->ltag=0;if(p->rchild==NULL) p->rtag=1;else p->rtag=0;cout<<p->data;pre=p;if(p->rtag==0) second_tree(p->rchild);}}void tbtree::third_tree(tbnode *p){if(p != NULL){third_tree(p -> lchild);third_tree(p -> rchild);if(pre != NULL && pre -> rtag==1) pre -> rchild = p;if(p -> lchild ==NULL){p -> ltag =1;p -> lchild = pre;}if(p -> rchild ==NULL) p -> rtag = 1;else p -> rtag = 0;cout<<p ->data;pre = p;}}void tbtree::first_first_tree(tbnode *p) //先序编历先序线索化二叉树{while(p!=NULL){cout<<p->data;p=prepare(p);}}void tbtree::second_second_tree(tbnode *p) //中序编历中序线索化二叉树{while(p->ltag!=1) p=p->lchild;while(p!=NULL){cout<<p->data;p=start(p);}}int main(){tbtree T;int choice;{cout<<endl;cout<<"数据结构实验四--线索二叉树应用实验"<<endl;cout<<endl;cout<<"第1题: 按先序次序遍历先序线索二叉树"<<endl;cout<<"第2题: 按中序次序遍历中序线索二叉树"<<endl;cout<<"第3题: 将值为x的结点作为先序线索二叉树T的左子树的(先序)"<<endl;cout<<" 最后一个结点的右孩子插入进去"<<endl;cout<<"第4题: 按中序次序线索化二叉树"<<endl;cout<<"第5题: 按后序次序线索化二叉树"<<endl;cout<<"退出程序:0"<<endl;cout<<endl;cout<<"请选择一道题"<<endl;cin>>choice;switch(choice){case 1:{cout<<"此操作是按先序次序遍历先序线索二叉树"<<endl;cout<<endl;cout<<"输入所建立二叉树的元素"<<endl;cout<<endl;tbnode *p;T.prepare_tree(p);T.first_tree(p);cout<<endl;T.first_first_tree(p);break;}case 2:{cout<<"此操作是按中序次序遍历先序线索二叉树"<<endl;cout<<endl;cout<<"输入所建立二叉树的元素"<<endl;cout<<endl;tbnode *p;T.prepare_tree(p);T.second_tree(p);T.second_second_tree(p);break;}case 3:{cout<<"此操作是将值为x的结点作为先序线索二叉树T"<<endl;cout<<"的左子树的(先序)最后一个结点的右孩子插入进去"<<endl;cout<<"输入所建立二叉树的元素"<<endl;cout<<endl;tbnode *p;T.prepare_tree(p);T.first_tree(p);T.first_first_tree(p);cout<<"请输入所要插入的值:"<<endl;cin>>choice;T.first_first_tree(p);break;}case 4:{cout<<"按中序次序线索化二叉树"<<endl;cout<<endl;cout<<"输入所建立二叉树的元素"<<endl;tbnode *p;T.prepare_tree(p);T.second_tree(p);break;}case 5:{cout<<"按后序次序线索化二叉树"<<endl;cout<<endl;cout<<"输入所建立二叉树的元素"<<endl;tbnode *p;T.prepare_tree(p);T.third_tree(p);break;}case 0:{cout<<"EXIT"<<endl;break;}default:{cout<<"输入错误,请重新输入"<<endl; } }}return 0;}。