二叉树及其应用(实验五)
二叉排序树的实验报告
二叉排序树的实验报告二叉排序树的实验报告引言:二叉排序树(Binary Search Tree,简称BST)是一种常用的数据结构,它将数据按照一定的规则组织起来,便于快速的查找、插入和删除操作。
本次实验旨在深入了解二叉排序树的原理和实现,并通过实验验证其性能和效果。
一、实验背景二叉排序树是一种二叉树,其中每个节点的值大于其左子树的所有节点的值,小于其右子树的所有节点的值。
这种特性使得在二叉排序树中进行查找操作时,可以通过比较节点的值来确定查找的方向,从而提高查找效率。
二、实验目的1. 理解二叉排序树的基本原理和性质;2. 掌握二叉排序树的构建、插入和删除操作;3. 验证二叉排序树在查找、插入和删除等操作中的性能和效果。
三、实验过程1. 构建二叉排序树首先,我们需要构建一个空的二叉排序树。
在构建过程中,我们可以选择一个节点作为根节点,并将其他节点插入到树中。
插入节点时,根据节点的值与当前节点的值进行比较,如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。
重复这个过程,直到所有节点都被插入到树中。
2. 插入节点在已有的二叉排序树中插入新的节点时,我们需要遵循一定的规则。
首先,从根节点开始,将新节点的值与当前节点的值进行比较。
如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。
如果新节点的值与当前节点的值相等,则不进行插入操作。
3. 删除节点在二叉排序树中删除节点时,我们需要考虑不同的情况。
如果要删除的节点是叶子节点,即没有左右子树,我们可以直接删除该节点。
如果要删除的节点只有一个子树,我们可以将子树连接到要删除节点的父节点上。
如果要删除的节点有两个子树,我们可以选择将其右子树中的最小节点或左子树中的最大节点替代该节点,并删除相应的替代节点。
四、实验结果通过对二叉排序树的构建、插入和删除操作的实验,我们得到了以下结果:1. 二叉排序树可以高效地进行查找操作。
二叉树的操作实验报告
二叉树的操作实验报告二叉树的操作实验报告引言二叉树是计算机科学中常用的数据结构,它具有良好的搜索性能和灵活的插入和删除操作。
本实验旨在通过实际操作,深入理解二叉树的基本操作和特性。
1. 二叉树的定义和基本概念二叉树是一种特殊的树状结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树的节点由数据和指向左右子节点的指针组成。
根据节点的位置,可以将二叉树分为左子树、右子树和根节点。
2. 二叉树的遍历二叉树的遍历是指按照一定的顺序访问二叉树中的所有节点。
常用的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点,然后按照左子树、右子树的顺序遍历;中序遍历先访问左子树,然后根节点,最后右子树;后序遍历先访问左子树,然后右子树,最后根节点。
3. 二叉树的插入操作插入操作是将一个新节点插入到二叉树中的特定位置。
插入操作需要考虑节点的大小关系,小于当前节点则插入到左子树,大于当前节点则插入到右子树。
插入操作可以保持二叉树的有序性。
4. 二叉树的删除操作删除操作是将指定节点从二叉树中删除。
删除操作需要考虑被删除节点的子节点情况,如果被删除节点没有子节点,则直接删除;如果有一个子节点,则将子节点替代被删除节点的位置;如果有两个子节点,则选择被删除节点的后继节点或前驱节点替代被删除节点。
5. 二叉树的查找操作查找操作是在二叉树中搜索指定的节点。
二叉树的查找操作可以使用递归或迭代的方式实现。
递归方式会自动遍历整个二叉树,直到找到目标节点或遍历完整个树。
迭代方式则需要手动比较节点的值,并根据大小关系选择左子树或右子树进行进一步查找。
6. 二叉树的平衡性二叉树的平衡性是指左子树和右子树的高度差不超过1。
平衡二叉树可以提高搜索效率,避免出现极端情况下的性能下降。
常见的平衡二叉树有AVL树和红黑树。
7. 二叉树应用场景二叉树在计算机科学中有广泛的应用场景。
例如,文件系统的目录结构可以使用二叉树来表示;数据库中的索引结构也可以使用二叉树来实现。
[精品]【数据结构】二叉树实验报告
[精品]【数据结构】二叉树实验报告二叉树实验报告一、实验目的:1.掌握二叉树的基本操作;2.理解二叉树的性质;3.熟悉二叉树的广度优先遍历和深度优先遍历算法。
二、实验原理:1.二叉树是一种树形结构,由n(n>=0)个节点组成;2.每个节点最多有两个子节点,称为左子节点和右子节点;3.二叉树的遍历分为四种方式:前序遍历、中序遍历、后序遍历和层次遍历。
三、实验环境:1.编程语言:C++;2.编译器:Dev-C++。
四、实验内容:1.定义二叉树节点结构体:struct BinaryTreeNode{int data; // 节点数据BinaryTreeNode *leftChild; // 左子节点指针BinaryTreeNode *rightChild; // 右子节点指针};2.初始化二叉树:queue<BinaryTreeNode *> q; // 使用队列存储节点q.push(root);int i = 1; // 创建子节点while (!q.empty() && i < length){BinaryTreeNode *node = q.front();q.pop();if (data[i] != -1) // 创建左子节点 {BinaryTreeNode *leftChild = new BinaryTreeNode;leftChild->data = data[i];leftChild->leftChild = nullptr;leftChild->rightChild = nullptr;node->leftChild = leftChild;q.push(leftChild);}i++;if (data[i] != -1) // 创建右子节点 {BinaryTreeNode *rightChild = new BinaryTreeNode;rightChild->data = data[i];rightChild->leftChild = nullptr;rightChild->rightChild = nullptr;node->rightChild = rightChild;q.push(rightChild);}i++;}return root;}3.前序遍历二叉树:五、实验结果:输入:int data[] = {1, 2, 3, 4, -1, -1, 5, 6, -1, -1, 7, 8};输出:前序遍历结果:1 2 4 5 3 6 7 8中序遍历结果:4 2 5 1 6 3 7 8后序遍历结果:4 5 2 6 8 7 3 1层次遍历结果:1 2 3 4 5 6 7 8通过本次实验,我深入理解了二叉树的性质和遍历方式,并掌握了二叉树的基本操作。
数据结构二叉树的实验报告
数据结构二叉树的实验报告数据结构二叉树的实验报告一、引言数据结构是计算机科学中非常重要的一个领域,它研究如何组织和存储数据以便高效地访问和操作。
二叉树是数据结构中常见且重要的一种,它具有良好的灵活性和高效性,被广泛应用于各种领域。
本实验旨在通过实际操作和观察,深入了解二叉树的特性和应用。
二、实验目的1. 理解二叉树的基本概念和特性;2. 掌握二叉树的创建、遍历和查找等基本操作;3. 通过实验验证二叉树的性能和效果。
三、实验过程1. 二叉树的创建在实验中,我们首先需要创建一个二叉树。
通过输入一系列数据,我们可以按照特定的规则构建一棵二叉树。
例如,可以按照从小到大或从大到小的顺序将数据插入到二叉树中,以保证树的有序性。
2. 二叉树的遍历二叉树的遍历是指按照一定的次序访问二叉树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历是先访问根节点,然后再依次遍历左子树和右子树;中序遍历是先遍历左子树,然后访问根节点,最后再遍历右子树;后序遍历是先遍历左子树,然后遍历右子树,最后访问根节点。
3. 二叉树的查找二叉树的查找是指在二叉树中寻找指定的节点。
常见的查找方式有深度优先搜索和广度优先搜索。
深度优先搜索是从根节点开始,沿着左子树一直向下搜索,直到找到目标节点或者到达叶子节点;广度优先搜索是从根节点开始,逐层遍历二叉树,直到找到目标节点或者遍历完所有节点。
四、实验结果通过实验,我们可以观察到二叉树的特性和性能。
在创建二叉树时,如果按照有序的方式插入数据,可以得到一棵平衡二叉树,其查找效率较高。
而如果按照无序的方式插入数据,可能得到一棵不平衡的二叉树,其查找效率较低。
在遍历二叉树时,不同的遍历方式会得到不同的结果。
前序遍历可以用于复制一棵二叉树,中序遍历可以用于对二叉树进行排序,后序遍历可以用于释放二叉树的内存。
在查找二叉树时,深度优先搜索和广度优先搜索各有优劣。
深度优先搜索在空间复杂度上较低,但可能会陷入死循环;广度优先搜索在时间复杂度上较低,但需要较大的空间开销。
实验五 数据结构 二叉树基本操作实验报告(汽院)
班级:
教师批阅处:
一、实验名称
二叉树基本操作的编程实现
二、实验目的
二叉树基本操作的编程实现,掌握二叉树的建立、遍历、插入、删除等基本操作的编程实现,存储结构主要采用链接结构。
三、实验内容
本次实验的内容有三种模式,我选择了第三种模式:用c进行程序的改进和提高,把下面的程序源码进行输入和改写,调试,直到成功。
1、补充三种递归遍历的方法
先根遍历:若二叉树不为空,先访问根节点,然后访问根节点的左子树,最后访问根节点的右子树。
中根遍历:若二叉树不为空,先访问根节点的左子树,然后访问根节点,最后访问根节点的右子树。
后跟遍历:若二叉树不为空,先访问根节点的左子树,然后访问根节点的右子树,最后访问根节点。
三种遍历的效果截图如下:
{
if(pnow!=NULL)
{
if (top<Maxsize-1)
{
top++;
stack[top].link=pnow;
stack[top].flag=1;
pnow=pnow->lchild;
}
else
{ return overflow; }
}
else
{
pnow=stack[top].link;
cout<<",";
else
cout<<")";
pnow=NULL;
}
}
}
cout<<endl;
return success;
}
3、补充层次遍历的方法
若二叉树不为空,从根节点开始从上至下逐层访问,同一层中从左到右逐个结点访问。效果截图如下:
二叉树实验报告
二叉树实验报告二叉树是数据结构中最常见且重要的一种类型。
它由节点组成,每个节点最多有两个子节点,分别称为左节点和右节点。
通过连接这些节点,可以构建一个有序且具有层次结构的树形结构。
本实验报告将介绍二叉树的概念、特点以及常见的操作,同时介绍二叉树在实际应用中的一些典型案例。
一、二叉树的定义和特点二叉树是一种树形结构,它的每个节点至多只有两个子节点。
它的定义可以使用递归的方式进行描述:二叉树要么是一棵空树,要么由根节点和两棵分别称为左子树和右子树的二叉树组成。
二叉树的特点是每个节点最多只有两个子节点。
二、二叉树的创建和操作1.创建二叉树:二叉树可以通过两种方式来创建,一种是使用树的节点类来手动构建二叉树;另一种是通过给定的节点值列表,使用递归的方式构建二叉树。
2.遍历二叉树:二叉树的遍历有三种方式,分别是前序遍历、中序遍历和后序遍历。
a.前序遍历:先遍历根节点,再遍历左子树,最后遍历右子树。
b.中序遍历:先遍历左子树,再遍历根节点,最后遍历右子树。
c.后序遍历:先遍历左子树,再遍历右子树,最后遍历根节点。
3.查找节点:可以根据节点的值或者位置来查找二叉树中的节点。
4.插入节点:可以通过递归的方式在指定位置上插入一个新节点。
5.删除节点:可以通过递归的方式删除二叉树中的指定节点。
三、二叉树的应用案例二叉树在实际应用中有很多重要的用途,下面介绍几个典型的案例。
1.表示文件系统结构:文件系统可以使用二叉树来进行表示,每个文件或文件夹都可以看作是树中一个节点,节点之间的父子关系可以通过左右子树建立连接。
2.实现二叉树:二叉树是一种特殊的二叉树,它要求左子树上的节点值小于根节点的值,右子树上的节点值大于根节点的值。
这种树结构可以快速实现元素的插入、删除和查找等操作。
3.表达式求值:二叉树可以用来表示数学表达式,并且可以通过遍历来对表达式进行求值。
四、实验总结通过本次实验,我们深入了解了二叉树的定义和特点,学会了二叉树的创建和操作方法,以及了解了二叉树在实际应用中的一些典型案例。
树和二叉树的实验报告
树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构,它们在各种算法和应用中都有广泛的应用。
本实验旨在通过实际操作和观察,深入了解树和二叉树的特性和操作。
二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构,由节点和边组成。
每个节点可以有零个或多个子节点,其中一个节点没有父节点的称为根节点。
树的特点包括层次结构、唯一根节点和无环等。
2. 树的构建在本实验中,我们使用Python语言构建了一棵树。
通过定义节点类和树类,我们可以方便地创建树的实例,并添加节点和连接节点之间的边。
3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
我们在实验中实现了这三种遍历方式,并观察了它们的输出结果。
三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树,每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。
2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。
通过定义节点类和二叉树类,我们可以创建二叉树的实例,并实现插入节点、删除节点和查找节点等操作。
3. 二叉树的应用二叉树在实际应用中有很多用途。
例如,二叉搜索树可以用于实现快速查找和排序算法。
AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。
我们在实验中实现了这些应用,并通过实际操作验证了它们的效果。
四、实验结果与讨论通过实验,我们成功构建了树和二叉树的数据结构,并实现了它们的基本操作。
通过观察和分析实验结果,我们发现树和二叉树在各种算法和应用中的重要性和灵活性。
树和二叉树的特性使得它们适用于解决各种问题,例如搜索、排序、图算法等。
同时,我们也发现了一些问题和挑战,例如树的平衡性和节点的插入和删除操作等。
这些问题需要进一步的研究和优化。
五、总结本实验通过实际操作和观察,深入了解了树和二叉树的特性和操作。
数据结构实验报告—二叉树
数据结构实验报告—二叉树数据结构实验报告—二叉树引言二叉树是一种常用的数据结构,它由节点和边构成,每个节点最多有两个子节点。
在本次实验中,我们将对二叉树的基本结构和基本操作进行实现和测试,并深入了解它的特性和应用。
实验目的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. 引言二叉树是一种常见的数据结构,由节点(Node)和链接(Link)构成。
每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树在计算机科学中被广泛应用,例如在搜索算法中,二叉树可以用来快速查找和插入数据。
本实验旨在通过编写二叉树的基本操作来深入理解二叉树的特性和实现方式。
2. 实验内容2.1 二叉树的定义二叉树可以用以下方式定义:class TreeNode:def__init__(self, val):self.val = valself.left =Noneself.right =None每个节点包含一个值和两个指针,分别指向左子节点和右子节点。
根据需求,可以为节点添加其他属性。
2.2 二叉树的基本操作本实验主要涉及以下二叉树的基本操作:•创建二叉树:根据给定的节点值构建二叉树。
•遍历二叉树:将二叉树的节点按照特定顺序访问。
•查找节点:在二叉树中查找特定值的节点。
•插入节点:向二叉树中插入新节点。
•删除节点:从二叉树中删除特定值的节点。
以上操作将在下面章节详细讨论。
3. 实验步骤3.1 创建二叉树二叉树可以通过递归的方式构建。
以创建一个简单的二叉树为例:def create_binary_tree():root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left.left = TreeNode(4)root.left.right = TreeNode(5)return root以上代码创建了一个二叉树,根节点的值为1,左子节点值为2,右子节点值为3,左子节点的左子节点值为4,左子节点的右子节点值为5。
3.2 遍历二叉树二叉树的遍历方式有多种,包括前序遍历、中序遍历和后序遍历。
以下是三种遍历方式的代码实现:•前序遍历:def preorder_traversal(root):if root:print(root.val)preorder_traversal(root.left)preorder_traversal(root.right)•中序遍历:def inorder_traversal(root):if root:inorder_traversal(root.left)print(root.val)inorder_traversal(root.right)•后序遍历:def postorder_traversal(root):if root:postorder_traversal(root.left)postorder_traversal(root.right)print(root.val)3.3 查找节点在二叉树中查找特定值的节点可以使用递归的方式实现。
二叉树的基本操作与实现实验报告
二叉树的基本操作与实现实验报告二叉树是一种重要的数据结构,在计算机科学领域中被广泛应用。
本实验将介绍二叉树的基本操作与实现,并给出相应的实验报告。
一、引言二叉树是一种特殊的树状结构,每个节点至多有两个子节点。
二叉树有许多重要的特性,如平衡二叉树、二叉树等,应用广泛。
在本实验中,我们将介绍二叉树的基本操作和实现。
二、实验目的1.掌握二叉树的基本概念和特性;2.熟悉二叉树的基本操作,包括创建、插入、删除、遍历等;3.学会使用编程语言实现二叉树的基本操作。
三、实验内容本实验主要包括以下内容:1.二叉树的定义和基本概念;2.二叉树的基本操作,包括创建、插入、删除、遍历等;3.使用编程语言实现二叉树的基本操作;4.测试和验证二叉树的基本操作的正确性。
四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构,每个节点至多有两个子节点。
二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。
二叉树的特性有很多,如完全二叉树、平衡二叉树、二叉树等。
2.二叉树的基本操作(1)创建二叉树:可以通过手动输入节点数据来创建二叉树,也可以通过读取文件中的数据来创建二叉树。
(2)插入节点:在指定位置插入一个新节点。
(3)删除节点:删除指定位置的节点。
(4)遍历二叉树:有前序遍历、中序遍历和后序遍历三种遍历方式。
3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。
我们可以定义一个二叉树的结构体,包含节点数据和指向左右子树的指针。
然后根据具体的需求,实现相应的操作函数。
4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后,我们可以编写测试代码来验证操作的正确性。
通过创建二叉树,并进行插入、删除和遍历操作,观察输出结果是否符合预期。
五、实验结果与分析在完成二叉树的基本操作后,我们可以进行测试和验证。
通过输出二叉树的遍历结果,比对预期结果来判断操作是否正确。
同时,我们还可以观察二叉树的结构和特性,如是否满足平衡二叉树或二叉树的条件。
数据结构实验报告-树(二叉树)
实验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.熟练掌握二叉树的查找节点操作;5.掌握二叉树的遍历方法,能够实现对二叉树的前序、中序、后序、层次遍历。
三、实验原理1.二叉树的创建方法:通过递归的方式,先创建根节点,再依次创建左子树和右子树;2.二叉树的插入节点操作:从根节点开始,根据节点值的大小关系,将待插入节点放到适当的位置;3.二叉树的删除节点操作:首先查找待删除的节点,然后根据其子节点的情况,进行相应的删除处理;4.二叉树的查找节点操作:从根节点开始遍历,根据节点值的大小关系,在左子树或右子树中继续查找,直到找到目标节点或遍历到叶子节点;5.二叉树的遍历方法:前序遍历先访问根节点,再遍历左子树和右子树;中序遍历先遍历左子树,再访问根节点和右子树;后序遍历先遍历左子树和右子树,再访问根节点;层次遍历按层次逐个访问节点。
四、实验过程1.创建二叉树:首先,定义二叉树的节点类,包含节点值和左右子节点;然后,通过递归的方式创建根节点、左子树和右子树。
2.插入节点:要插入一个节点,首先需要找到插入位置。
如果待插入节点大于当前节点的值,则插入到右子树中,否则插入到左子树中。
如果节点为空,则表示找到了插入位置。
3.删除节点:删除节点有以下几种情况:(1) 待删除节点为叶子节点:直接删除即可;(2) 待删除节点只有一个子节点:用子节点替换待删除节点的位置;(3) 待删除节点有两个子节点:找到待删除节点的后继节点(右子树的最左下角节点),用后继节点替换待删除节点的位置。
二叉树实现及应用实验报告
二叉树实现及应用实验报告实验名称:二叉树实现及应用实验目的:1. 实现二叉树的创建、插入和删除操作。
2. 学习二叉树的遍历方法,并能够应用于实际问题。
3. 掌握二叉树在数据结构和算法中的一些常用应用。
实验内容:1. 实现二叉树的创建、插入和删除操作,包括二叉树的构造函数、插入函数和删除函数。
2. 学习二叉树的三种遍历方法:前序遍历、中序遍历和后序遍历,并应用于实际问题。
3. 掌握二叉树的一些常用应用,如二叉搜索树、平衡二叉树和哈夫曼树等。
实验步骤:1. 创建二叉树的结构体,包括树节点和树的根节点。
2. 实现二叉树的构造函数,用于创建二叉树的根节点。
3. 实现二叉树的插入函数,用于将元素插入到二叉树中的合适位置。
4. 实现二叉树的删除函数,用于删除二叉树中的指定元素。
5. 学习并实现二叉树的前序遍历、中序遍历和后序遍历函数。
6. 运用二叉树的遍历方法解决实际问题,如查找二叉树中的最大值和最小值。
7. 学习并应用二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构。
实验结果:1. 成功创建、插入和删除二叉树中的元素,实现了二叉树的基本操作。
2. 正确实现了二叉树的前序遍历、中序遍历和后序遍历,并能够正确输出遍历结果。
3. 通过二叉树的遍历方法成功解决了实际问题,如查找二叉树中的最大值和最小值。
4. 学习并熟练应用了二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构,丰富了对二叉树的理解。
实验分析:1. 二叉树是一种重要的数据结构,具有较好的数据存储和查找性能,广泛应用于计算机科学和算法领域。
2. 通过实验,我们深入了解了二叉树的创建、插入和删除操作,以及前序遍历、中序遍历和后序遍历的原理和应用。
3. 实际问题往往可以转化为二叉树的遍历问题进行求解,通过实验,我们成功应用了二叉树的遍历方法解决了实际问题。
4. 熟练掌握二叉搜索树、平衡二叉树和哈夫曼树的原理和应用,对于提高我们在数据结构和算法方面的设计能力具有重要意义。
实验五二叉树的常见操作
实验五二叉树的常见操作【背景知识】二叉树的存储、建立、遍历及其应用。
【目的要求】1.掌握二叉树的存储实现。
2.掌握二叉树的遍历思想。
3.掌握二叉树的常见算法的程序实现。
【实验内容】1.输入字符序列,建立二叉链表。
2.中序遍历二叉树:递归算法。
算法如下:#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int status;typedef struct BiNode{char Data;struct BiNode* lChild;struct BiNode* rChild;}BiNode,*pBiNode;status CreateTree(BiNode** pTree);status InOrderTraval(BiNode* pTree);status Visit(char Data);status CreateTree(BiNode** pTree){char ch;scanf("%c",&ch);if(ch=='#'){(*pTree)=NULL;}else{if(!((*pTree)=(BiNode*)malloc(sizeof(BiNode)))){exit(OVERFLOW);}(*pTree)->Data=ch;CreateTree(&((*pTree)->lChild));CreateTree(&((*pTree)->rChild));}return OK;}status InOrderTraval(BiNode* pTree){if(pTree){if(InOrderTraval(pTree->lChild)){if(Visit(pTree->Data)){if(InOrderTraval(pTree->rChild)) {return OK;}}return ERROR;}return ERROR;}else{return OK;}}。
实验5-二叉树的应用
实验5 二叉树的应用一、实验目的●了解并掌握二叉树的概念与定义●了解并掌握二叉树的先序、中序与后序遍历方法●了解唯一先序遍历,以及依据唯一先序遍历创建树的方法●掌握二叉树的节点查找方法●掌握二叉树的节点插入方法二、实验环境●个人计算机一台,CPU主频1GHz以上,1GB以上内存,2GB以上硬盘剩余空间。
●Windows2000、Windows XP或Win 7操作系统●Code::Blocks(版本12.11或近似版本,英文版),或VC++ 6.0三、实验内容1.二叉树的创建与遍历由唯一先序遍历序列,创建二叉树,以二叉链表链表的形式存储;同时,对该二叉树进行先序、中序和后序遍历,并输出遍历序列。
例如,有以下这棵二叉树:其唯一先序遍历序列为:ABD00E0G00CF0H000其先序遍历序列为:ABDEGCFH其中序遍历序列为:DBEGAFHC其后序遍历序列为:DGEBHFCA源代码:ds13.c 2.节点的查找由二叉树的唯一先序遍历序列创建二叉树,并由用户输入一个字符,查找该字符是否在二叉树中。
例如,二叉树的其唯一先序遍历序列为:ABD00E0G00CF0H000,根据该序列创建二叉树。
若用户输入字符F,输出“Yes”;若用户输入“X”,输出“No”。
注:二叉树的创建可用第1题的程序。
源代码:ds14.c 3.节点的插入由二叉树的唯一先序遍历序列创建二叉树,并由用户输入两个字符ch1和ch2,以及插入标识flag(L或R)。
完成以下操作:(1)查找字符ch1是否为二叉树中某个节点的值,若不是,则输出“No found\n”;若是,转入(2)。
(2)若字符ch1是二叉树中节点p的值,则根据插入标识flag的值,进行操作:若flag的值为“L”,则以ch2为值创建一个新节点q,并将作为p的左子节点,原来的左子节点作为q的左子节点;若flag的值为“R”,,则以ch2为值创建一个新节点q,并将作为p的右子节点,原来的右子节点作为q的右子节点。
实验3 二叉树的应用
实验五:二叉树的应用一、实验预备知识1 树是一种非线性的结构,它具有递归特点。
2 二叉树有四种遍历方法,分别为:先根,后根、中根和层次。
掌握四种遍历的规则。
(每个结点都访问,并且只访问一次)二、实验目的1 掌握二叉树的逻辑结构特性,以及各种存储结构的特点及适用范围。
2 掌握用指针类型描述、访问和处理二叉树的各种运算的实现算法。
三、实验内容1 编写采用二叉链表形式存储的二叉树的创建算法。
2 编写二叉树的先序、中序、后序遍历的递归算法、先序和中序的非递归算法和按层遍历的算法。
2 编写将一棵二叉树的所有左右子树进行交换的算法。
3 编写统计二叉树中叶子结点的算法。
4编写一个主函数,将上面函数连在一起,构成一个完整的程序。
5将实验源程序调试并运行。
四、实验要求建立的二叉树为:AB CD E FG H#include<iostream>using namespace std;typedef char datatype;typedef struct node{datatype data;struct node *lchild,*rchild;}bintnode;typedef bintnode *bintree;typedef struct stack{bintree data[100];int tag[100];int top;}seqstack;创建二叉树算法:void CreateBinTree(bintree *t){char ch;if((ch=getchar())=='0')(*t)=NULL;else{*t=new bintnode ;(*t)->data=ch;CreateBinTree(&(*t)->lchild);CreateBinTree(&(*t)->rchild);}}前序遍历递归算法:void Preorder(bintree t){if(t){cout<<t->data<<" ";Preorder(t->lchild);Preorder(t->rchild);}}中序遍历递归算法:void Inorder(bintree t){if(t){Inorder(t->lchild);cout<<t->data<<" ";Inorder(t->rchild);}}后序遍历递归算法:void Postorder(bintree t){if(t){Postorder(t->lchild);Postorder(t->rchild);cout<<t->data<<" ";}}void Push(seqstack *s,bintree t) {s->data[++s->top]=t;}bintree Pop(seqstack *s){if(s->top!=-1){s->top--;return (s->data[s->top+1]);}elsereturn NULL;}前序遍历非递归算法:void Preorder1(bintree t){seqstack s;s.top=-1;while((t)||(s.top!=-1)){while(t){cout<<t->data<<" ";s.top++;s.data[s.top]=t;t=t->lchild;}if(s.top>-1){t=Pop(&s);t=t->rchild;}}}中序遍历非递归算法:void Inorder1(bintree t){seqstack s;s.top=-1;while((t!=NULL)||(s.top!=-1)){while(t){Push(&s,t);t=t->lchild;}if(s.top!=-1){t=Pop(&s);cout<<t->data<<" ";t->rchild;}}}层次遍历算法:void Levelorder(bintree t){bintree queue[100];int front,rear;if(t==NULL)return;front=-1;rear=0;queue[rear]=t;while(front!=rear){front++;cout<<queue[front]->data<<" ";if(queue[front]->lchild!=NULL){rear++;queue[rear]=queue[front]->lchild;}if(queue[front]->rchild!=NULL){rear++;queue[rear]=queue[front]->rchild;}}}遍历叶子节点算法:void CountLeaf(bintree t){if(!t)return;if(!(t->lchild||t->rchild))cout<<t->data<<" ";CountLeaf(t->lchild);CountLeaf(t->rchild);}交换左右子树算法:void SwapBinTree(bintree t){bintree s;if(t){SwapBinTree(t->lchild);SwapBinTree(t->rchild);s=t->lchild;t->lchild=t->rchild;t->rchild=s;}}主函数实现:void main(){bintree root;cout<<"***********************************************************"<<en dl;cout<<"请按前序遍历次序顺序读入所要生成的二叉树:";CreateBinTree(&root);cout<<"***********************************************************"<<en dl;cout<<"*******************************************"<<endl;cout<<"递归实现前序遍历结果:";Preorder(root);cout<<endl;cout<<"\n递归实现中序遍历结果:";Inorder(root);cout<<endl;cout<<"\n递归实现后序遍历结果:";Postorder(root);cout<<endl;cout<<"*******************************************"<<endl;cout<<"*******************************************"<<endl;cout<<"非递归实现前序遍历结果:";Preorder1(root);cout<<endl;cout<<"\n非递归实现中序遍历结果:";Inorder(root);cout<<endl;cout<<"\n层次遍历结果:";Levelorder(root);cout<<endl;cout<<"\n叶子结点为:";CountLeaf(root);cout<<endl;cout<<"*******************************************"<<endl;cout<<"*******************************************"<<endl;printf("交换左右子树后遍历如下:");cout<<endl;SwapBinTree(root);cout<<"\n递归实现前序遍历结果:";Preorder(root);cout<<endl;cout<<"\n递归实现中序遍历结果:";Inorder(root);cout<<endl;cout<<"\n递归实现后序遍历结果:";Postorder(root);cout<<endl;cout<<"*******************************************"<<endl; }五、实验结果:。
二叉树及其应用实验报告
实验地点:一号教学楼微机室
实验名称:二叉树及其应用
实验目的:熟悉各种存储结构及应用二叉树解决具体问题
实验环境:微机室、DEV-C++
实验步骤:1、确定基本思路和设计思想
2、确定程序主题
3、进行编程设计
4、调试程序
5、分析程序错误,编译调试
6、总结经验
实验体会:二叉树的存储、遍历等非常多,但只要实际掌握了二叉树的原理,在课堂上认真听老师讲课,在编程时其实可以减少好多工作量。只要认真思考,参考一些案例,也可以调试好自己的程序。
void preorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null)
{
printf("%3c",p->data);
preorder_btree(p->left);
preorder_btree(p->right);
}
}
/*中序遍历打印二叉排序树*/
void inorder_btree(b_tree root)
b_trБайду номын сангаасe p=root;
if(p!=null)
{
postorder_btree(p->left );
postorder_btree(p->right );
printf("%3c",p->data );
}
}
在调试程序的过程中,这几段关于二叉树遍历的原理其实老师都讲过,在调试程序的过程中,加深了对二叉树的遍历的理解,有助于更好地学习二叉树、应用二叉树。
{
b_tree p=root;
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验五二叉树及其应用1.目的要求:(1)通过实验掌握二叉树的两种基本的存储结构,及二叉树的建立、遍历,并加以应用。
(2)Huffman树建立、编码。
2.实验内容:(1)按先序次序输入二叉树中结点的值,建立一棵以二叉链表作存储结构的二叉树,然后按先序、中序、后序顺序分别遍历这棵二叉树,并完成二叉树的相应信息的统计(如各种结点数目、二叉树的高度等);(2)建立一棵二叉排序树,并对其进行先序、中序、后序遍历。
(3)应用队列结构实现二叉树的层次遍历。
(4)设计一个完整的编码系统:针对一篇文档,统计各个字符的出现次数,并为其设计Huffman编码。
注:(1)~(2)必做,(3)~(4)选做。
三.实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写,请另加附页)(1)按先序次序输入二叉树中结点的值,建立一棵以二叉链表作存储结构的二叉树,然后按先序、中序、后序顺序分别遍历这棵二叉树,并完成二叉树的相应信息的统计(如各种结点数目、二叉树的高度等);程序代码:头文件:#ifndef _H_#define _H_#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef char TElemType;typedef struct BiTNode{TElemType e;struct BiTNode *LChild,*RChild;}BiTNode,*BiTree;Status Create(BiTree &T);Status PrintElemType(TElemType e);Status PreOrderTraver(BiTree T,Status (* visit)(TElemType e));Status InOrderTraver(BiTree T,Status (* visit)(TElemType e));Status PostOrderTraver(BiTree T,Status (* visit)(TElemType e));Status Count(BiTree T);Status Countleaf(BiTree T);Status Counttwo(int n);Status Countone(int n,int n0,int n2);Status Depth(BiTree T);#endif主函数:#include<stdio.h>#include<stdlib.h>#include"1.h"int main(){BiTree T;printf("请按照先序输入树值:\n");if(!Create(T)) printf("存储空间分配失败\n");printf("先序遍历该树为:\n");if(!PreOrderTraver(T,PrintElemType)) printf("打印函数出错\n");printf("\n");printf("中序遍历该树为:\n");if(!InOrderTraver(T,PrintElemType)) printf("打印函数出错\n");printf("\n");printf("后序遍历该树为:\n");if(!PostOrderTraver(T,PrintElemType)) printf("打印函数出错\n");printf("\n");printf("总结点数有:%d\n",Count(T));printf("其中叶子结点数有:%d\n",Countleaf(T));printf("其中一度结点数有:%d\n",Countone(Count(T),Countleaf(T),Counttwo(Countleaf(T))));printf("其中二度结点数有:%d\n",Counttwo(Countleaf(T)));printf("该二叉树的深度为:%d\n",Depth(T));return 0;}功能函数:#include<stdio.h>#include<stdlib.h>#include"1.h"//先序建立二叉Status Create(BiTree &T){char ch;scanf("%c",&ch);if(ch==' ') T=NULL;else{if(!(T=(BiTree)malloc(sizeof(BiTNode)))) exit(OVERFLOW);T->e=ch;Create(T->LChild);Create(T->RChild);}return OK;}//输出结点中的数值Status PrintElemType(TElemType e){printf("%c ",e);return OK;}//先序遍历Status PreOrderTraver(BiTree T,Status (* visit)(TElemType e)){if(T){if(visit(T->e)){if(PreOrderTraver(T->LChild,visit))if(PreOrderTraver(T->RChild,visit)) return OK;}return ERROR;}else return OK;}//中序遍历Status InOrderTraver(BiTree T,Status (* visit)(TElemType e)){if(T){if(InOrderTraver(T->LChild,visit)){if(visit(T->e))if(InOrderTraver(T->RChild,visit)) return OK;}return ERROR;}else return OK;}//后序遍历Status PostOrderTraver(BiTree T,Status (* visit)(TElemType e)) {if(T){if(PostOrderTraver(T->LChild,visit)){if(PostOrderTraver(T->RChild,visit))if(visit(T->e)) return OK;}return ERROR;}else return OK;}//总结点数Status Count(BiTree T){int num1,num2,num;if(T==NULL) num=0;else{num1=Count(T->LChild);num2=Count(T->RChild);num=num1+num2+1;}return num;}//叶子结点数Status Countleaf(BiTree T){int num1,num2,num;if(T==NULL) num=0;else{if(T->LChild==NULL&&T->RChild==NULL) num=1;else{num1=Countleaf(T->LChild);num2=Countleaf(T->RChild);num=num1+num2;}}return num;}//二度结点数Status Counttwo(int n)//n为终端结点数终端结点数==二度结点数+1 {int num;num=n-1;return num;}//一度结点数Status Countone(int n,int n0,int n2)//一度结点数==总数-0度结点数-2度结点数{int num;num=n-n0-n2;return num;}//二叉树深度Status Depth(BiTree T){int dep,depl,depr;if(T==NULL) dep=0;else{depl=Depth(T->LChild);depr=Depth(T->RChild);dep=1+(depl>depr?depl:depr);}return dep;}运行结果:(2)建立一棵二叉排序树,并对其进行先序、中序、后序遍历。
程序代码部分:头文件:#ifndef _H_#define _H_#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int TElemType;typedef struct BiTNode{TElemType e;struct BiTNode *LChild,*RChild;}BiTNode,*BiTree;Status Insert(BiTree &T,TElemType e);void Create(BiTree &T);Status PrintElemType(TElemType e);Status PreOrderTraver(BiTree T,Status (* visit)(TElemType e));Status InOrderTraver(BiTree T,Status (* visit)(TElemType e));Status PostOrderTraver(BiTree T,Status (* visit)(TElemType e));#endif主函数:#include<stdio.h>#include<stdlib.h>#include"1.h"int main(){BiTree T=NULL;printf("请输入树值建立二叉排序数(输-1表示输入结束):\n");Create(T);printf("先序遍历该树为:\n");if(!PreOrderTraver(T,PrintElemType)) printf("打印函数出错\n");printf("\n");printf("中序遍历该树为:\n");if(!InOrderTraver(T,PrintElemType)) printf("打印函数出错\n");printf("\n");printf("后序遍历该树为:\n");if(!PostOrderTraver(T,PrintElemType)) printf("打印函数出错\n");printf("\n");return 0;}功能函数:#include<stdio.h>#include<stdlib.h>#include"1.h"//插入结点Status Insert(BiTree &T,TElemType e){if(T==NULL){if(!(T=(BiTree )malloc(sizeof(BiTNode)))) exit(OVERFLOW);T->e=e;T->LChild=T->RChild=NULL;}else{if(e<T->e) Insert(T->LChild,e);if(e>T->e) Insert(T->RChild,e);}return OK;}//建立二叉排序void Create(BiTree &T){TElemType e;for(scanf("%d",&e);e!=-1;scanf("%d",&e)){Insert(T,e);}}//输出结点中的数值Status PrintElemType(TElemType e){printf("%d ",e);return OK;}//先序遍历Status PreOrderTraver(BiTree T,Status (* visit)(TElemType e)){if(T){if(visit(T->e)){if(PreOrderTraver(T->LChild,visit))if(PreOrderTraver(T->RChild,visit)) return OK;}return ERROR;}else return OK;}//中序遍历Status InOrderTraver(BiTree T,Status (* visit)(TElemType e)) {if(T){if(InOrderTraver(T->LChild,visit)){if(visit(T->e))if(InOrderTraver(T->RChild,visit)) return OK;}return ERROR;}else return OK;}//后序遍历Status PostOrderTraver(BiTree T,Status (* visit)(TElemType e)) {if(T){if(PostOrderTraver(T->LChild,visit)){if(PostOrderTraver(T->RChild,visit))if(visit(T->e)) return OK;}return ERROR;}else return OK;}运行结果:(3)应用队列结构实现二叉树的层次遍历。