实验三 二叉树的操作及应用
实验三二叉树基本操作与应用实验
![实验三二叉树基本操作与应用实验](https://img.taocdn.com/s3/m/887f2af309a1284ac850ad02de80d4d8d15a018c.png)
实验三二叉树基本操作与应用实验第一篇:实验三二叉树基本操作与应用实验实验三二叉树基本操作与应用实验第三次实验主要包括两部分内容:1.二叉树基本操作实验;2.二叉树应用—赫夫曼树与赫夫曼编码实验。
基本操作包括存储结构建立和遍历算法,本文只给出部分参考程序,请大家尽量完成多数基本操作。
第一部分基本操作实验[问题描述] 二叉树采用二叉链表作存储结构,试编程实现二叉树的如下基本操作1.按先序序列构造一棵二叉链表表示的二叉树T;2.对这棵二叉树进行遍历:先序、中序、后序以及层次遍历序列,分别输出结点的遍历序列;3.求二叉树的深度,结点数目,叶结点数目; [数据描述] //二叉树的二叉链表存储表示先序遍历二叉树递归算法6.层次遍历二叉树的非递归算法7.求二叉树的深度[说明]1.按先序次序输入二叉树中结点的值,用‘#’表示空树,对每一个结点应当确定其左右子树的值(为空时必须用特定的空字符占位),故执行此程序时,最好先在纸上画出你想建立的二叉树,每个结点的左右子树必须确定。
若为空,则用特定字符标出,然后再按先序输入这棵二叉树的字符序列。
2.为了简化程序的书写量,以及程序的清晰性,对结点的访问以一条输出语句表示,若有更复杂的或多种访问,可以将结点的访问编写成函数,然后通过函数指针进行函数的调用。
读者若有兴趣,可自行编写。
3.c语言函数参数传递,都是以“传值”的方式,故在设计函数时,必须注意参数的传递。
若想通过函数修改实际参数的值,则必须用指针变量作参数。
具体设计时;读者一定要把指针变量及指针变量指向的值等概念弄清楚。
4.完整参考程序只给出了部分遍历算法,对于其他算法,请读者参照示例,自行编程完成,以加深学习体会。
对于二叉链表的建立也是如此,示例中只是给出了先序法建立过程,读者可自行练习中序、后序二叉链表建立法,叶子结点或二叉树结点总数求法等。
第二部分二叉树应用实验---------郝夫曼树与郝夫曼编码[问题描述] 利用HuffMan编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。
二叉树实验报告
![二叉树实验报告](https://img.taocdn.com/s3/m/4438898588eb172ded630b1c59eef8c75fbf9504.png)
二叉树实验报告二叉树实验报告引言:二叉树作为一种常用的数据结构,在计算机科学领域中具有广泛的应用。
本实验旨在通过实际操作和观察,深入理解二叉树的特性和运用。
一、二叉树的基本概念1.1 二叉树的定义二叉树是一种特殊的树形结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。
树的最顶层节点称为根节点。
1.2 二叉树的特点二叉树具有以下特点:- 每个节点最多有两个子节点,分别称为左子节点和右子节点;- 左子节点的值小于等于父节点的值,右子节点的值大于等于父节点的值;- 二叉树的左子树和右子树也是二叉树。
二、二叉树的遍历方式2.1 先序遍历先序遍历是指先访问根节点,然后按照先序遍历的方式依次访问左子树和右子树。
2.2 中序遍历中序遍历是指按照中序遍历的方式依次访问左子树,根节点和右子树。
2.3 后序遍历后序遍历是指按照后序遍历的方式依次访问左子树,右子树和根节点。
三、二叉树的实验操作3.1 二叉树的创建为了便于实验操作,我们选择使用Python编程语言来实现二叉树的创建和操作。
首先,我们需要定义一个二叉树节点的类,包含节点的值、左子节点和右子节点。
3.2 二叉树的插入在已有的二叉树中插入一个新的节点,需要遵循二叉树的规则。
如果插入的节点值小于当前节点的值,则将节点插入到当前节点的左子树;如果插入的节点值大于当前节点的值,则将节点插入到当前节点的右子树。
3.3 二叉树的查找在二叉树中查找一个特定的节点,需要遍历整个二叉树。
从根节点开始,如果要查找的节点值小于当前节点的值,则继续在左子树中查找;如果要查找的节点值大于当前节点的值,则继续在右子树中查找;如果要查找的节点值等于当前节点的值,则找到了目标节点。
3.4 二叉树的删除在二叉树中删除一个节点,需要考虑多种情况。
如果要删除的节点没有子节点,直接将其删除即可;如果要删除的节点只有一个子节点,将子节点替换为要删除的节点;如果要删除的节点有两个子节点,需要找到其右子树中的最小节点,将其值替换到要删除的节点,然后删除最小节点。
数据结构实验3:二叉树的操作
![数据结构实验3:二叉树的操作](https://img.taocdn.com/s3/m/39a5645d6ad97f192279168884868762caaebba2.png)
TextFile中。
(4) P:打印代码文件(Print)。
将文件CodeFile以紧凑格式显示在终端上,每行50个代码。
同时将此字符形式的编码文件写入文件CodePrin中。
(5) T:打印哈夫曼树(Tree printing)。
将已在内存中的哈夫曼树以直观的方式显示在终端上,同时将此字符形式的哈夫曼树写入文件TreePrint中。
3) 实现提示:(1) 文件CodeFile的基类型可以设为字节型。
(2) 用户界面可以设计为“菜单”方式:显示上述功能符号,再加上“Q”,表示退出运行Quit。
请用户键入一个选择功能符。
此功能执行完毕后再显示此菜单,直至某次用户选择了“E”为止。
(3) 在程序的一次执行过程中,第一次执行I、D或C命令之后,哈夫曼树已经在内存了,不必再读入。
每次执行中不一定执行I命令,因为文件hfmTree可能早已建好。
三、实验过程与实验结果实验3-01:以二叉链表为存储结构,实现二叉树的创建、遍历数据结构定义:typedef struct BiTNode{char data;BiTNode *lchild, *rchild;}BiTNode;typedef BiTNode *BiTree;算法设计思路简介:本实验需要实现以下操作:二叉树的初始化、前中后序遍历等基本操作1.利用递归实现前后序遍历,思路简洁,仅需要调整递归体的执行顺序即可实现。
2.利用非递归实现中序遍历,需要利用栈操作,按照中序遍历规则将节点依次入栈后出栈实现。
算法描述:图1 中序遍历(非递归)实现算法的实现和测试结果(参考OJ)实验3-02:编写算法交换二叉树中所有结点的左、右子树数据结构定义:typedef struct BiTNode{char data;BiTNode *lchild, *rchild;}BiTNode;typedef BiTNode *BiTree;算法设计思路简介:本实验需要实现以下操作:二叉树的初始化、前中后序遍历等基本操作1.利用递归实现前后序遍历,思路简洁,仅需要调整递归体的执行顺序即可实现。
实验三—树的实现与应用实验报告
![实验三—树的实现与应用实验报告](https://img.taocdn.com/s3/m/5df5e35fbe23482fb4da4c37.png)
#include <stack>
using namespace std;
typedef struct BiTNode{
char data;
BiTNode *lchild,*rchild;//左右孩子指针
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T){
while(p||!s.empty()){
if(p)
{
s.push(p);
p=p->lchild;
}//根指针进栈,遍历左子树
else
{//根指针退栈,访问根结点,遍历右子树
p=s.top();
cout<<p->data<<" ";
s.pop();
p=p->rchild;
}//else
}//while
CreateBiTree(T->lchild);//构造左子树
CreateBiTree(T->rchild);//构造右子树
}
}//CreateBiTree
void InOrderTraverse(BiTree &T){
//采用非递归算法输出二叉树中的值
stack<BiTNode *> s;
BiTree p=T;
InOrderTraverse(T->lchild);
cout<<T->data<<" ";
InOrderTraverse(T->rchild);
}
}//InOrderTraverse
树和二叉树的实验报告
![树和二叉树的实验报告](https://img.taocdn.com/s3/m/c11a11b7f71fb7360b4c2e3f5727a5e9846a274e.png)
树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构,它们在各种算法和应用中都有广泛的应用。
本实验旨在通过实际操作和观察,深入了解树和二叉树的特性和操作。
二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构,由节点和边组成。
每个节点可以有零个或多个子节点,其中一个节点没有父节点的称为根节点。
树的特点包括层次结构、唯一根节点和无环等。
2. 树的构建在本实验中,我们使用Python语言构建了一棵树。
通过定义节点类和树类,我们可以方便地创建树的实例,并添加节点和连接节点之间的边。
3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
我们在实验中实现了这三种遍历方式,并观察了它们的输出结果。
三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树,每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。
2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。
通过定义节点类和二叉树类,我们可以创建二叉树的实例,并实现插入节点、删除节点和查找节点等操作。
3. 二叉树的应用二叉树在实际应用中有很多用途。
例如,二叉搜索树可以用于实现快速查找和排序算法。
AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。
我们在实验中实现了这些应用,并通过实际操作验证了它们的效果。
四、实验结果与讨论通过实验,我们成功构建了树和二叉树的数据结构,并实现了它们的基本操作。
通过观察和分析实验结果,我们发现树和二叉树在各种算法和应用中的重要性和灵活性。
树和二叉树的特性使得它们适用于解决各种问题,例如搜索、排序、图算法等。
同时,我们也发现了一些问题和挑战,例如树的平衡性和节点的插入和删除操作等。
这些问题需要进一步的研究和优化。
五、总结本实验通过实际操作和观察,深入了解了树和二叉树的特性和操作。
二叉树的应用实验报告
![二叉树的应用实验报告](https://img.taocdn.com/s3/m/5dcdaea19e31433238689311.png)
实验报告课程名称____数据结构上机实验__________实验项目______二叉树的应用 ____________实验仪器________PC机___________________系别____________________________专业_____________________________班级/学号____________________________学生姓名_____________________________实验日期_______________________成绩_______________________指导教师_______________________实验三.二叉树的应用1.实验目的:掌握二叉树的链式存储结构和常用算法。
利用哈夫曼树设计最优压缩编码。
2.实验内容:1)编写函数,实现建立哈夫曼树和显示哈夫曼树的功能。
2)编写函数,实现生成哈夫曼编码的功能。
3)编写主函数,从终端输入一段英文文本;统计各个字符出现的频率,然后构建哈夫曼树并求出对应的哈夫曼编码;显示哈夫曼树和哈夫曼编码。
选做内容:修改程序,选择实现以下功能:4)编码:用哈夫曼编码对一段英文文本进行压缩编码,显示编码后的文本编码序列;5)统计:计算并显示文本的压缩比例;6)解码:将采用哈夫曼编码压缩的文本还原为英文文本。
3.算法说明:1)二叉树和哈夫曼树的相关算法见讲义。
2)编码的方法是:从头开始逐个读取文本字符串中的每个字符,查编码表得到它的编码并输出。
重复处理直至文本结束。
3)解码的方法是:将指针指向哈夫曼树的树根,从头开始逐个读取编码序列中的每位,若该位为1则向右子树走,为0则向左子树走。
当走到叶子节点时,取出节点中的字符并输出。
重新将指针放到树根,继续以上过程直至编码序列处理完毕。
4)压缩比例的计算:编码后的文本长度为编码序列中的0和1,的个数,原文本长度为字符数*8。
两者之比即为压缩比。
实验3 二叉树的操作及应用
![实验3 二叉树的操作及应用](https://img.taocdn.com/s3/m/6c46126fddccda38376baf71.png)
实验3 二叉树的操作及应用PB13000818 焦孟娇实验目的:1. 熟练掌握递归程序设计的方法。
2. 掌握二叉树的特性和基本算法。
问题描述:二叉树是一种基本且常用的数据结构。
二叉树的很多基本算法都可以用递归的形式来表述。
本实验要求实现二叉树的如下操作:创建、销毁、复制、打印显示、先中后序遍历、查找元素、层序遍历、求二叉树的深度、宽度、结点数和叶子个数等。
实验内容:一、队列的抽象数据类型定义为:Queue operation{数据对象:数据关系:基本操作:InitQueue(&S)操作结果:构造一个空队列SQueueLength(S)初始条件:队列S已存在操作结果:返回S的元素个数,即队列的长度QueueEmpty(S)初始条件:队列S已存在操作结果:若S为空队列,则返回TRUE,否则FALSEEnQueue(&S, e)初始条件:队列S已存在操作结果:插入元素e为队列新元素DeQueue(&S, &e)初始条件:队列S已存在且非空操作结果:删除S的队头元素,并用e返回其值GetHead(S, &e)初始条件:队列S已存在且非空操作结果:用e返回S的队头元素ClearQueue(&S)初始条件:队列S已存在操作结果:将S清为空队列DeleteQueue(&S)初始条件:队列S已存在操作结果:队列S被销毁Print(S)初始条件:队列S已存在操作结果:输出队列S} Queue operationBiTree operation{InitBiTree( &T )// 操作结果:构造空二叉树T。
DestroyBiTree( &T )// 初始条件:二叉树T已存在。
// 操作结果:销毁二叉树T。
CreateBiTree( &T, definition )// 初始条件:definition给出二叉树T的定义。
// 操作结果:按definiton构造二叉树T。
数据结构实验三——二叉树基本操作及运算实验报告
![数据结构实验三——二叉树基本操作及运算实验报告](https://img.taocdn.com/s3/m/d4dbf1882cc58bd63086bd05.png)
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目,以及二叉树常用运算。
问题分析:二叉树树型结构是一类重要的非线性数据结构,对它的熟练掌握是学习数据结构的基本要求。
由于二叉树的定义本身就是一种递归定义,所以二叉树的一些基本操作也可采用递归调用的方法。
处理本问题,我觉得应该:1、建立二叉树;2、通过递归方法来遍历(先序、中序和后序)二叉树;3、通过队列应用来实现对二叉树的层次遍历;4、借用递归方法对二叉树进行一些基本操作,如:求叶子数、树的深度宽度等;5、运用广义表对二叉树进行广义表形式的打印。
算法规定:输入形式:为了方便操作,规定二叉树的元素类型都为字符型,允许各种字符类型的输入,没有元素的结点以空格输入表示,并且本实验是以先序顺序输入的。
输出形式:通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印,再以广义表形式进行打印。
对二叉树的一些运算结果以整型输出。
程序功能:实现对二叉树的先序、中序和后序遍历,层次遍历。
计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。
对二叉树的某个元素进行查找,对二叉树的某个结点进行删除。
测试数据:输入一:ABC□□DE□G□□F□□□(以□表示空格),查找5,删除E预测结果:先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A(B(C,D(E(,G),F)))叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5,成功,查找的元素为E删除E后,以广义表形式打印A(B(C,D(,F)))输入二:ABD□□EH□□□CF□G□□□(以□表示空格),查找10,删除B预测结果:先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A(B(D,E(H)),C(F(,G)))叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10,失败。
二叉树的基本操作与应用
![二叉树的基本操作与应用](https://img.taocdn.com/s3/m/bcf9272e7f21af45b307e87101f69e314232fa55.png)
二叉树的基本操作与应用二叉树的基本操作与应用。
二叉树是一种特殊的树结构,它的每个节点最多只能有两个子节点。
在实际应用中,二叉树具有广泛的应用,例如在计算机科学中的数据结构与算法、人工智能领域中的决策树等。
本文将以二叉树的基本操作与应用为主题,一步一步回答相关问题。
一、什么是二叉树?二叉树是由节点组成的层次结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。
它的特点是每个子节点都是唯一的,没有重复的子节点。
通过将这些节点按照一定的规则进行连接,就形成了一棵二叉树。
二、二叉树的基本操作有哪些?二叉树的基本操作包括创建二叉树、遍历二叉树、插入节点、删除节点等。
下面将分别对这些操作进行介绍。
1. 创建二叉树:创建二叉树的方法有多种,最常见的方法是使用递归或迭代的方式进行创建。
例如,可以使用递归的方式根据给定的数组创建一棵二叉树。
2. 遍历二叉树:遍历二叉树是指按照一定的顺序访问二叉树中的每一个节点。
常见的遍历方式有三种:前序遍历、中序遍历和后序遍历。
前序遍历的顺序是先访问根节点,然后访问左子树,最后访问右子树。
中序遍历的顺序是先访问左子树,然后访问根节点,最后访问右子树。
后序遍历的顺序是先访问左子树,然后访问右子树,最后访问根节点。
3. 插入节点:插入节点是指在二叉树中新增一个节点。
插入节点的方法有多种,最常见的是在二叉树的某个位置插入一个节点。
例如,可以在二叉树的最后一层的某个位置插入一个节点。
4. 删除节点:删除节点是指将二叉树中的一个节点删除。
删除节点的方法有多种,最常见的是删除二叉树的某个位置上的节点。
例如,可以删除二叉树的最后一层的某个位置上的节点。
三、二叉树的应用场景有哪些?二叉树在实际应用中有很多场景,下面将介绍其中几个常见的应用。
1. 数据结构与算法:在计算机科学中,二叉树被广泛应用于构建各种数据结构和算法。
例如,二叉搜索树是一种常用的数据结构,可以用于快速查找和插入数据。
平衡二叉树是一种自平衡的二叉搜索树,可以保持二叉树的平衡性,提高查找和插入的效率。
实验三 二叉树的基本操作实现及其应用
![实验三 二叉树的基本操作实现及其应用](https://img.taocdn.com/s3/m/009c090c7cd184254b353588.png)
二叉树的基本操作实现及其应用一、实验目的1.熟悉二叉树结点的结构和对二叉树的基本操作。
2.掌握对二叉树每一种操作的具体实现。
3.学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。
4.会用二叉树解决简单的实际问题。
二、实验内容设计程序实现二叉树结点的类型定义和对二叉树的基本操作。
该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。
1 按先序次序建立一个二叉树,2按(A:先序 B:中序 C:后序)遍历输出二叉树的所有结点以上比做,以下选做3求二叉树中所有结点数4求二叉树的深度三、实验步骤㈠、数据结构与核心算法的设计描述/* 定义DataType为char类型 */typedef char DataType;/* 二叉树的结点类型 */typedef struct BitNode{ DataType data;struct BitNode *lchild,*rchild;}*BitTree;相关函数声明:1、/* 初始化二叉树,即把树根指针置空 */void BinTreeInit(BitTree *BT){BT=(BitTree)malloc(sizeof(BitNode));BT->data=NULL;cout<<"二叉树初始化成功!"<<endl;}2、/* 按先序次序建立一个二叉树*/int BinTreeCreat(BitTree &BT){char ch;cin>>ch;if(ch=='#') BT=NULL;else{if(!(BT=(BitTree)malloc(sizeof(BitNode))))exit(0);BT->data=ch;BinTreeCreat(BT->lchild);BinTreeCreat(BT->rchild);}return 0;}3、/* 检查二叉树是否为空 */void BinTreeEmpty(BitTree &BT){if(BT->data==NULL)cout<<"是空二叉树!"<<endl;elsecout<<"不是空二叉树!"<<endl;}4、/*按任一种遍历次序(包括按先序、中序、后序、按层次)输出二叉树中的所有结点 */void BinTraverse(BitTree &BT)//按先序序列建立二叉树{if(BT!=NULL){cout<<BT->data;BinTraverse(BT->lchild);BinTraverse(BT->rchild);}}5、/* 求二叉树的深度 */int BinTreeDepth(BitTree BT){int depthval;if(BT){int depthLeft=BinTreeDepth(BT->lchild);int depthRight=BinTreeDepth(BT->rchild);depthval=1+(depthLeft>depthRight?depthLeft:depthRight);}else depthval=0;return depthval;}6、/* 求二叉树中所有结点数 */int BinTreeCount(BitTree BT){int node;if(BT){int lchild=BinTreeCount(BT->lchild);int rchild=BinTreeCount(BT->rchild);node=lchild+rchild+1;}elsenode=0;return node;}㈡、函数调用及主函数设计㈢程序调试及运行结果分析测试数据: 1、初始化二叉树; 2、按先序序列建立二叉树;3、判断二叉树是否为空;4、先序序列遍历二叉树;5、求二叉树的深度;6、求二叉树节点的个数。
二叉树基本操作--实验报告
![二叉树基本操作--实验报告](https://img.taocdn.com/s3/m/a8f86874f4335a8102d276a20029bd64783e62b8.png)
⼆叉树基本操作--实验报告实验三⼆叉树的基本操作学院:物理与电⼦学院班级:电信1105班姓名:刘岩学号:29⼀、实验⽬的1、熟悉⼆叉树的基本操作,掌握⼆叉树的实现以及实际应⽤。
3、加深对于⼆叉树的理解,逐步培养解决实际问题的编程能⼒。
⼆、实验环境1台WINDOWS环境的PC机,装有Visual C++ 。
三、实验内容1、问题描述现需要编写⼀套⼆叉树的操作函数,以便⽤户能够⽅便的利⽤这些函数来实现⾃⼰的应⽤。
其中操作函数包括:1>创建⼆叉树CreateBTNode(*b,*str):根据⼆叉树括号表⽰法的字符串*str⽣成对应的链式存储结构。
2>输出⼆叉树DispBTNode(*b):以括号表⽰法输出⼀棵⼆叉树。
3>查找结点FindNode(*b,x):在⼆叉树b中寻找data域值为x的结点,并返回指向该结点的指针。
4>求⾼度BTNodeDepth(*b):求⼆叉树b的⾼度。
若⼆叉树为空,则其⾼度为0;否则,其⾼度等于左⼦树与右⼦树中的最⼤⾼度加l。
5>求⼆叉树的结点个数NodesCount(BTNode *b)6>先序遍历的递归算法:void PreOrder(BTNode *b)7>中序遍历的递归算法:void InOrder(BTNode *b)8>后序遍历递归算法:void PostOrder(BTNode *b)9>层次遍历算法void LevelOrder(BTNode *b)2、基本要求实现以上9个函数。
主函数中实现以下功能:创建下图中的树b输出⼆叉树b找到’H’节点,输出其左右孩⼦值输出b的⾼度输出b的节点个数输出b的四种遍历顺序3、程序编写上图转化为⼆叉树括号表⽰法为A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))程序:#include <>#include <>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data; /*数据元素*/struct node *lchild; /*指向左孩⼦*/struct node *rchild; /*指向右孩⼦*/} BTNode;void CreateBTNode(BTNode *&b,char *str);//创建BTNode *FindNode(BTNode *b,ElemType x);//查找节点int BTNodeHeight(BTNode *b);//求⾼度void DispBTNode(BTNode *b);//输出int NodesCount(BTNode *b);//⼆叉树的结点个数void PreOrder(BTNode *b);//先序遍历递归void InOrder(BTNode *b);//中序遍历递归void PostOrder(BTNode *b);//后序遍历递归void LevelOrder(BTNode *b);//层次遍历//创建void CreateBTNode(BTNode *&b,char *str){BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL;ch=str[j];while(ch!='\0'){switch(ch){case '(':top++;St[top]=p;k=1;break;case ')':top--;break;case ',':k=2;break;default:p=(BTNode *)malloc(sizeof(BTNode)); p->data=ch;p->lchild=p->rchild=NULL;if(b==NULL)b=p;else{switch(k){case 1:St[top]->lchild=p;break;case 2:St[top]->rchild=p;break;}}}j++;ch=str[j];}}//输出void DispBTNode(BTNode *b){if(b!=NULL){printf("%c",b->data);if(b->lchild!=NULL||b->rchild!=NULL){printf("(");DispBTNode(b->lchild);if(b->rchild!=NULL)printf(",");DispBTNode(b->rchild);printf(")");}}}//查找节点BTNode *FindNode(BTNode *b,ElemType x){ BTNode *p;if(b==NULL)return b;else if(b->data==x)return b;else{p=FindNode(b->lchild,x);if(p!=NULL)return p;elsereturn FindNode(b->rchild,x);}}//求⾼度int BTNodeHeight(BTNode *b){int lchildh,rchildh;if(b==NULL)return (0);else{lchildh=BTNodeHeight(b->lchild);rchildh=BTNodeHeight(b->rchild);return(lchildh>rchildh)(lchildh+1):(rchildh+1);}}//⼆叉树的结点个数int NodesCount(BTNode *b){if(b==NULL)return 0;elsereturn NodesCount(b->lchild)+NodesCount(b->rchild)+1; }//先序遍历递归void PreOrder(BTNode *b){ if(b!=NULL){printf("%c",b->data); PreOrder(b->lchild); PreOrder(b->rchild);}}//中序遍历递归void InOrder(BTNode *b){if(b!=NULL){InOrder(b->lchild);printf("%c",b->data); InOrder(b->rchild);}}//后序遍历递归void PostOrder(BTNode *b){ if(b!=NULL){PostOrder(b->lchild); PostOrder(b->rchild);printf("%c",b->data);}}//层次遍历void LevelOrder(BTNode *b){ BTNode *p;BTNode *qu[MaxSize];int front,rear;front=rear=-1;rear++;qu[rear]=b;while(front!=rear){front=(front+1)%MaxSize;p=qu[front];printf("%c",p->data);if(p->lchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->lchild;}if(p->rchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->rchild;}}}void main(){BTNode *b,*p,*lp,*rp;char str[]="A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";//根据树形图改写成的//⼆叉树括号表⽰法的字符串*str //char str[100];scanf("%s",&str);//⾃⾏输⼊括号表⽰的⼆叉树CreateBTNode(b,str); //创建树bprintf("\n");printf("输出⼆叉树:");//输出⼆叉树bDispBTNode(b);printf("\n");printf("'H'结点:");//找到'H'节点,输出其左右孩⼦值p=FindNode(b,'H');printf("\n");if (p!=NULL){printf("左孩⼦节点的值");printf("%c",p->lchild->data);printf("\n");printf("右孩⼦节点的值");printf("%c",p->rchild->data);printf("\n");//此处输出p的左右孩⼦节点的值}printf("\n");printf("⼆叉树b的深度:%d\n",BTNodeHeight(b));//输出b的⾼度printf("⼆叉树b的结点个数:%d\n",NodesCount(b));//输出b的节点个数printf("\n");printf(" 先序遍历序列:\n");//输出b的四种遍历顺序printf(" 算法:");PreOrder(b);printf("\n");printf(" 中序遍历序列:\n");printf(" 算法:");InOrder(b);printf("\n");printf(" 后序遍历序列:\n");printf(" 算法:");PostOrder(b);printf("\n");printf(" 层次遍历序列:\n");printf(" 算法:");LevelOrder(b); printf("\n");}四、实验⼼得与⼩结通过本次实验,我熟悉⼆叉树的基本知识内容,对课本的知识有了更加深刻的理解与掌握掌握。
二叉树的基本操作与实现实验报告
![二叉树的基本操作与实现实验报告](https://img.taocdn.com/s3/m/0549ddce6429647d27284b73f242336c1eb930d7.png)
二叉树的基本操作与实现实验报告二叉树是一种重要的数据结构,在计算机科学领域中被广泛应用。
本实验将介绍二叉树的基本操作与实现,并给出相应的实验报告。
一、引言二叉树是一种特殊的树状结构,每个节点至多有两个子节点。
二叉树有许多重要的特性,如平衡二叉树、二叉树等,应用广泛。
在本实验中,我们将介绍二叉树的基本操作和实现。
二、实验目的1.掌握二叉树的基本概念和特性;2.熟悉二叉树的基本操作,包括创建、插入、删除、遍历等;3.学会使用编程语言实现二叉树的基本操作。
三、实验内容本实验主要包括以下内容:1.二叉树的定义和基本概念;2.二叉树的基本操作,包括创建、插入、删除、遍历等;3.使用编程语言实现二叉树的基本操作;4.测试和验证二叉树的基本操作的正确性。
四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构,每个节点至多有两个子节点。
二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。
二叉树的特性有很多,如完全二叉树、平衡二叉树、二叉树等。
2.二叉树的基本操作(1)创建二叉树:可以通过手动输入节点数据来创建二叉树,也可以通过读取文件中的数据来创建二叉树。
(2)插入节点:在指定位置插入一个新节点。
(3)删除节点:删除指定位置的节点。
(4)遍历二叉树:有前序遍历、中序遍历和后序遍历三种遍历方式。
3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。
我们可以定义一个二叉树的结构体,包含节点数据和指向左右子树的指针。
然后根据具体的需求,实现相应的操作函数。
4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后,我们可以编写测试代码来验证操作的正确性。
通过创建二叉树,并进行插入、删除和遍历操作,观察输出结果是否符合预期。
五、实验结果与分析在完成二叉树的基本操作后,我们可以进行测试和验证。
通过输出二叉树的遍历结果,比对预期结果来判断操作是否正确。
同时,我们还可以观察二叉树的结构和特性,如是否满足平衡二叉树或二叉树的条件。
二叉树的基本操作实验报告
![二叉树的基本操作实验报告](https://img.taocdn.com/s3/m/6c0722ae0875f46527d3240c844769eae009a384.png)
二叉树的基本操作实验报告二叉树的基本操作实验报告引言:二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。
二叉树的基本操作包括创建、遍历、插入和删除等。
本实验旨在通过实践来深入了解二叉树的基本操作,并通过实验结果验证其正确性和有效性。
一、创建二叉树创建二叉树是二叉树操作中的第一步。
在本实验中,我们使用了递归算法来创建二叉树。
递归算法是一种重要的算法思想,通过将问题划分为更小的子问题来解决复杂的问题。
在创建二叉树时,我们首先创建根节点,然后递归地创建左子树和右子树。
二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点,然后递归遍历左子树和右子树;中序遍历先递归遍历左子树,然后访问根节点,最后递归遍历右子树;后序遍历先递归遍历左子树和右子树,最后访问根节点。
三、插入节点插入节点是向二叉树中添加新节点的操作。
插入节点的过程需要遵循二叉树的特性,即左子节点的值小于父节点的值,右子节点的值大于父节点的值。
在插入节点时,我们需要找到合适的位置,将新节点插入到正确的位置上。
四、删除节点删除节点是从二叉树中移除节点的操作。
删除节点的过程相对复杂,需要考虑多种情况。
如果要删除的节点是叶子节点,直接删除即可。
如果要删除的节点只有一个子节点,将其子节点连接到父节点上。
如果要删除的节点有两个子节点,我们需要找到其后继节点或前驱节点来替代被删除的节点。
实验结果:通过实验,我们成功地实现了二叉树的基本操作。
创建二叉树的递归算法能够正确地创建出符合要求的二叉树。
遍历二叉树的算法能够按照指定的顺序遍历每个节点。
插入节点和删除节点的操作也能够正确地修改二叉树的结构。
讨论与总结:二叉树的基本操作是数据结构中的重要内容,对于理解和应用其他数据结构具有重要意义。
通过本次实验,我们深入了解了二叉树的创建、遍历、插入和删除等操作,并通过实验验证了其正确性和有效性。
实验报告 实验三 二叉排序树的建立和查找
![实验报告 实验三 二叉排序树的建立和查找](https://img.taocdn.com/s3/m/5927821ecc7931b765ce1568.png)
实验三二叉排序树的建立和查找一、实验目的1.掌握二叉排序树的建立算法2.掌握二叉排序树查找算法。
二、实验环境操作系统和C语言系统三、预习要求复习二叉排序树的生成及查找算法,编写完整的程序。
四、实验内容实现二叉排序树上的查找算法。
具体实现要求:用二叉链表做存储结构,输入键值序列,建立一棵二叉排序树并在二叉排序树上实现查找算法。
五、参考算法#include <stdio.h>#include <stdlib.h>typedef int InfoType;typedef int KeyType; /*假定关键字类型为整数*/typedef struct node /*结点类型*/{KeyType key; /*关键字项*/InfoType otherinfo; /*其它数据域,InfoType视应用情况而定,下面不处理它*/struct node *lchild,*rchild; /*左右孩子指针*/}BSTNode;typedef BSTNode *BSTree; /*BSTree是二叉排序树的类型*/BSTNode *SearchBST(BSTree T,KeyType key){ /*在二叉排序树T上查找关键字为key的结点,成功时返回该结点位置,否则返回NULL*/if(T==NULL||key==T->key) /*递归的终结条件*/return T; /*若T为空,查找失败;否则成功,返回找到的结点位置*/if(key<T->key)return SearchBST(T->lchild,key);elsereturn SearchBST(T->rchild,key); /*继续在右子树中查找*/}void InsertBST(BSTree *T,int key){ /*插入一个值为key的节点到二叉排序树中*/BSTNode *p,*q;if((*T)==NULL){ /*树为空树*/(*T)=(BSTree)malloc(sizeof(BSTNode));(*T)->key=key;(*T)->lchild=(*T)->rchild=NULL;}else{p=(*T);while(p){q=p;if(p->key>key)p=q->lchild;else if(p->key<key)p=q->rchild;else{printf("\n 该二叉排序树中含有关键字为%d的节点!\n",key);return;}}p=(BSTree)malloc(sizeof(BSTNode));p->key=key;p->lchild=p->rchild=NULL;if(q->key>key)q->lchild=p;elseq->rchild=p;}}BSTree CreateBST(void){ /*输入一个结点序列,建立一棵二叉排序树,将根结点指针返回*/BSTree T=NULL; /*初始时T为空树*/KeyType key;scanf("%d",&key); /*读入一个关键字*/while(key){ /*假设key=0是输入结束标志*/ InsertBST(&T,key); /*将key插入二叉排序树T*/scanf("%d",&key); /*读入下一关键字*/}return T; /*返回建立的二叉排序树的根指针*/ }void ListBinTree(BSTree T) /*用广义表示二叉树*/{if(T!=NULL){printf("%d",T->key);if(T->lchild!=NULL||T->rchild!=NULL){printf("(");ListBinTree(T->lchild);if(T->rchild!=NULL)printf(",");ListBinTree(T->rchild);printf(")");}}}void main(){BSTNode *SearchBST(BSTree T,KeyType key);void InsertBST(BSTree *Tptr,KeyType key);BSTree CreateBST();void ListBinTree(BSTree T);BSTree T;BSTNode *p;int key;printf("请输入关键字(输入0为结束标志):\n");T=CreateBST();ListBinTree(T);printf("\n");printf("请输入欲查找关键字:");scanf("%d",&key);p=SearchBST(T,key);if(p==NULL)printf("没有找到%d!\n",key);elseprintf("找到%d!\n",key);ListBinTree(p);printf("\n");}实验中出现的问题及对问题的解决方案输入数据时,总是不能得到结果,原因是在建立二叉树函数定义中,是对指针的值进行了修改。
数据结构二叉树实验报告
![数据结构二叉树实验报告](https://img.taocdn.com/s3/m/16191703e518964bce847c4c.png)
实验三二叉树的遍历一、实验目的1、熟悉二叉树的结点类型和二叉树的基本操作。
2、掌握二叉树的前序、中序和后序遍历的算法。
3、加深对二叉树的理解,逐步培养解决实际问题的编程能力。
二、实验环境运行C或VC++的微机。
三、实验内容1、依次输入元素值,以链表方式建立二叉树,并输出结点的值。
2、分别以前序、中序和后序遍历二叉树的方式输出结点内容。
四、设计思路1. 对于这道题,我的设计思路是先做好各个分部函数,然后在主函数中进行顺序排列,以此完成实验要求2.二叉树采用动态数组3.二叉树运用9个函数,主要有主函数、构建空二叉树函数、建立二叉树函数、访问节点函数、销毁二叉树函数、先序函数、中序函数、后序函数、范例函数,关键在于访问节点五、程序代码#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef struct TNode//结构体定义{-int data; //数据域struct TNode *lchild,*rchild; // 指针域包括左右孩子指针}TNode,*Tree;void CreateT(Tree *T)//创建二叉树按,依次输入二叉树中结点的值{int a;scanf("%d",&a);if(a==00) // 结点的值为空*T=NULL;else // 结点的值不为空{*T=(Tree)malloc(sizeof(TNode));if(!T){printf("分配空间失败!!TAT");exit(ERROR);}(*T)->data=a;CreateT(&((*T)->lchild)); // 递归调用函数,构造左子树CreateT(&((*T)->rchild)); // 递归调用函数,构造右子树}}void InitT(Tree *T)//构建空二叉树{T=NULL;}void DestroyT(Tree *T)//销毁二叉树{if(*T) // 二叉树非空{DestroyT(&((*T)->lchild)); // 递归调用函数,销毁左子树DestroyT(&((*T)->rchild)); // 递归调用函数,销毁右子树free(T);T=NULL;}}void visit(int e)//访问结点{printf("%d ",e);}-void PreOrderT(Tree *T,void(*visit)(int))//先序遍历T{if(*T) // 二叉树非空{visit((*T)->data); // 先访问根结点PreOrderT(&((*T)->lchild),visit); // 递归调用函数,先序遍历左子树PreOrderT(&((*T)->rchild),visit); // 递归调用函数,先序遍历右子树}}void InOrderT(Tree *T,void(*visit)(int)){if(*T){InOrderT(&((*T)->lchild),visit); // 递归调用函数,中序遍历左子树visit((*T)->data); // 访问根结点InOrderT(&((*T)->rchild),visit); // 递归调用函数,中序遍历右子树}}void PostOrderT(Tree *T,void(*visit)(int)){if(*T){PostOrderT(&((*T)->lchild),visit); // 递归调用函数,后序遍历左子树PostOrderT(&((*T)->rchild),visit); // 递归调用函数,序遍历右子树visit((*T)->data); // 访问根结点}}void example(){int i;printf("如果你想建立如图所示的二叉树\n");printf("\n");printf(" 1 \n");printf(" / \\ \n");printf(" 3 3 \n");printf(" / \\ \\ \n");printf(" 4 5 7 \n");printf("\n");printf("请输入:1 3 4 00 00 5 00 00 3 00 7 00 00\n");printf("\n按先序次序输入二叉树中结点的值(输入00表示节点为空)\n");for(i=0;i<71;i++)printf("*");printf("\n");}int main (){Tree T;printf("**************欢迎使用!**************潘俊达\n"); example();printf("\n请输入所要建立的二叉树:\n");CreateT(&T);InitT(&T);int i;printf("先序遍历二叉树:\n");PreOrderT(&T,visit);printf("\n");printf("\n中序遍历二叉树:\n");InOrderT(&T,visit);printf("\n");printf("\n后序遍历二叉树:\n");PostOrderT(&T,visit);printf("\n");system("PAUSE");return 0;}六、程序截图1.范例函数显示,并输入先序二叉树节点值2.先序遍历二叉树3.中序遍历二叉树3.后序遍历二叉树。
二叉树实现及应用实验报告
![二叉树实现及应用实验报告](https://img.taocdn.com/s3/m/13ebcc8559f5f61fb7360b4c2e3f5727a5e92412.png)
二叉树实现及应用实验报告实验名称:二叉树实现及应用实验目的:1. 实现二叉树的创建、插入和删除操作。
2. 学习二叉树的遍历方法,并能够应用于实际问题。
3. 掌握二叉树在数据结构和算法中的一些常用应用。
实验内容:1. 实现二叉树的创建、插入和删除操作,包括二叉树的构造函数、插入函数和删除函数。
2. 学习二叉树的三种遍历方法:前序遍历、中序遍历和后序遍历,并应用于实际问题。
3. 掌握二叉树的一些常用应用,如二叉搜索树、平衡二叉树和哈夫曼树等。
实验步骤:1. 创建二叉树的结构体,包括树节点和树的根节点。
2. 实现二叉树的构造函数,用于创建二叉树的根节点。
3. 实现二叉树的插入函数,用于将元素插入到二叉树中的合适位置。
4. 实现二叉树的删除函数,用于删除二叉树中的指定元素。
5. 学习并实现二叉树的前序遍历、中序遍历和后序遍历函数。
6. 运用二叉树的遍历方法解决实际问题,如查找二叉树中的最大值和最小值。
7. 学习并应用二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构。
实验结果:1. 成功创建、插入和删除二叉树中的元素,实现了二叉树的基本操作。
2. 正确实现了二叉树的前序遍历、中序遍历和后序遍历,并能够正确输出遍历结果。
3. 通过二叉树的遍历方法成功解决了实际问题,如查找二叉树中的最大值和最小值。
4. 学习并熟练应用了二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构,丰富了对二叉树的理解。
实验分析:1. 二叉树是一种重要的数据结构,具有较好的数据存储和查找性能,广泛应用于计算机科学和算法领域。
2. 通过实验,我们深入了解了二叉树的创建、插入和删除操作,以及前序遍历、中序遍历和后序遍历的原理和应用。
3. 实际问题往往可以转化为二叉树的遍历问题进行求解,通过实验,我们成功应用了二叉树的遍历方法解决了实际问题。
4. 熟练掌握二叉搜索树、平衡二叉树和哈夫曼树的原理和应用,对于提高我们在数据结构和算法方面的设计能力具有重要意义。
实验3 二叉树的应用
![实验3 二叉树的应用](https://img.taocdn.com/s3/m/5bc78413cc7931b765ce15c5.png)
实验五:二叉树的应用一、实验预备知识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; }五、实验结果:。
实验三 二叉树的基本运算
![实验三 二叉树的基本运算](https://img.taocdn.com/s3/m/36750b573b3567ec102d8a4e.png)
数据结构实验报告(实验三&实验四)班级:软件121学号:201200834122姓名:程猛实验三二叉树的基本运算一、实验目的1、使学生熟练掌握二叉树的逻辑结构和存储结构。
2、熟练掌握二叉树的各种遍历算法。
二、实验内容[问题描述]建立一棵二叉树,试编程实现二叉树的如下基本操作:1. 按先序序列构造一棵二叉链表表示的二叉树T;2. 对这棵二叉树进行遍历:先序、中序、后序以及层次遍历,分别输出结点的遍历序列;3. 求二叉树的深度/结点数目/叶结点数目;(选做)4. 将二叉树每个结点的左右子树交换位置。
(选做)[基本要求]从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立),[测试数据]如输入:ABCффDEфGффFффф(其中ф表示空格字符)则输出结果为先序:ABCDEGF中序:CBEGDFA后序:CGEFDBA层序:ABCDEFG[选作内容]采用非递归算法实现二叉树遍历。
三、实验前的准备工作1、掌握树的逻辑结构。
2、掌握二叉树的逻辑结构和存储结构。
3、掌握二叉树的各种遍历算法的实现。
四、源代码#include<iostream.h>#include<iomanip.h>#include<stdlib.h>#include<strstrea.h>//定义二叉树结点类型template<class T>class BinaryTree;template<class T> struct BTreeNode {private:BTreeNode<T> *left;//左子树指针BTreeNode<T> *right;//右子树指针public:T data;//数据域//构造函数BTreeNode():left(NULL),right(NULL) { }BTreeNode(T item,BTreeNode<T> *left1=NULL,BTreeNode<T> *right1=NULL):data(item),left(left1),right(right1){ }BTreeNode<T> *&Left(){return left;}BTreeNode<T> *&Right(){return right;}friend class BinaryTree<T>;};//二叉树类定义template<class T>class BinaryTree {private:BTreeNode<T> *root;public://构造函数,初始化二叉树为空BinaryTree() {root=NULL;}//根据字符数组a的二叉树广义表建立对应的二叉树存储结构void CreateBTree(char* a);//判断二叉树是否为空bool BTreeEmpty() {return root==NULL;}//按任一种遍历次序输出二叉树中的所有结点void TraverseBTree(int mark);//用于遍历的递归函数void Traverse(BTreeNode<T> *&BT,int mark);//求二叉树的深度int BTreeDepth();//用于求二叉树深度的递归函数int Depth(BTreeNode<T> *&BT);//求二叉树中所有结点数int BTreeCount();//用于求二叉树中所有结点数的递归函数int Count(BTreeNode<T> *&BT);//求二叉树中所有叶子结点数int BTreeLeafCount();//用于求二叉树中所有叶子结点数的递归函数int LeafCount(BTreeNode<T> *&BT);//按照二叉树的一种表示方法输出整个二叉树void PrintBTree();//用于输出整个二叉树的递归函数void Print(BTreeNode<T> *&BT);//用于清除二叉树的递归函数void Clear(BTreeNode<T> *&BT);//析构函数,清除二叉树~BinaryTree();};//根据字符数组a的二叉树广义表建立对应的二叉树存储结构template<class T>void BinaryTree<T>::CreateBTree(char *a){BTreeNode<T> *s[80];//s数组作为存储二叉树中根结点指针的栈int top=-1; //top作为s栈的栈顶指针root=NULL; //给树根指针置空BTreeNode<T> *p=NULL;//定义p为指向二叉树结点的指针//用k作为处理结点的左子树和右子树的标记,k=1处理左子树,k=2处理右子树int k;istrstream ins(a);//把字符串a定义为输入字符串流对象ins char ch;ins>>ch;//从ins流对象顺序读入一个字符,while (ch!='@'){//每循环一次处理一个读入的字符,直到扫描到'@'字符为止switch(ch){case '(':top++;s[top]=p;k=1;break;case ')':top--;break;case ',':top++;k=2;break;default:p=new BTreeNode<T>;p->data=ch;p->left=p->right=NULL;cout<<setw(2)<<p->data;if(root==NULL) root=p;else {if(k==1) s[top]->left=p;else s[top]->right=p;}}ins>>ch;}}//按任一种遍历次序输出二叉树中的所有结点template<class T>void BinaryTree<T>::TraverseBTree(int mark){Traverse(root,mark);}//用于遍历的递归函数template<class T>void BinaryTree<T>::Traverse(BTreeNode<T> *&BT,int mark) {if(mark==1){ //先序遍历if(BT!=NULL){cout<<BT->data<<' ';Traverse(BT->left,mark);Traverse(BT->right,mark);}}elseif(mark==2)//中序遍历{if(BT!=NULL){Traverse(BT->left,mark);cout<<BT->data<<' ';Traverse(BT->right,mark);}}elseif(mark==3) {//后序遍历if(BT!=NULL) {Traverse(BT->left,mark);Traverse(BT->right,mark);cout<<BT->data<<' ';}}elseif(mark==4) //按层遍历{const MaxLength=80;BTreeNode<T> *Q[MaxLength];//定义存储二叉树结点指针的数组空间作为队列使用int front=0, rear=0;//定义队首指针和队尾指针,初始均置0表示空队BTreeNode<T> *p;if(BT!=NULL) {rear=(rear+1)%MaxLength; //后移队尾指针Q[rear]=BT;} //将树根结点指针进队while(front!=rear){//当队列非空时执行循环front=(front+1)%MaxLength;//后移队首指针p=Q[front];//删除队首结点cout<<p->data<<' ';//输出队首结点的值if(p->left!=NULL){//若结点存在左孩子,则左孩子结点指针进队rear=(rear+1)%MaxLength;Q[rear]=p->left;}if(p->right!=NULL){//若结点存在右孩子,则右孩子结点指针进队rear=(rear+1)%MaxLength;Q[rear]=p->right;}}}else{cerr<<"mark的值无效!遍历失败!"<<endl;exit(1); }}//求二叉树的深度template<class T>int BinaryTree<T>::BTreeDepth(){return Depth(root);}//用于求二叉树深度的递归函数template<class T>int BinaryTree<T>::Depth(BTreeNode<T> *&BT){if(BT==NULL) return 0;//对于空树,返回0并结束递归else{//计算左子树的深度int dep1=Depth(BT->left);//计算右子树的深度int dep2=Depth(BT->right);//返回树的深度if(dep1>dep2) return dep1+1;else return dep2+1;}}//求二叉树中所有结点数template<class T>int BinaryTree<T>::BTreeCount(){return Count(root);}//用于求二叉树中所有结点数的递归函数template<class T>int BinaryTree<T>::Count(BTreeNode<T> *&BT){if(BT==NULL) return 0;elsereturn Count(BT->left)+Count(BT->right)+1;}//求二叉树中所有叶子结点数template<class T>int BinaryTree<T>::BTreeLeafCount(){return LeafCount(root);}//用于求二叉树中所有叶子结点数的递归函数template<class T>int BinaryTree<T>::LeafCount(BTreeNode<T> *&BT){if(BT==NULL) return 0;else if(BT->left==NULL && BT->right==NULL) return 1; else return LeafCount(BT->left)+LeafCount(BT->right); }//按照二叉树的广义表表示输出整个二叉树template<class T>void BinaryTree<T>::PrintBTree(){Print(root);}//用于输出整个二叉树的递归函数template<class T>void BinaryTree<T>::Print(BTreeNode<T> *&BT){if(BT==NULL) return;//树为空时返回else {//否则执行如下操作cout<<BT->data;//输出根结点的值if(BT->left!=NULL || BT->right!=NULL){cout<<'('; //输出左括号Print(BT->left);//输出左子树if(BT->right!=NULL)cout<<',';//若右子树不为空则输出逗号分隔符Print(BT->right);//输出右子树cout<<')';} //输出右括号}}//析构函数,清除二叉树template<class T>BinaryTree<T>::~BinaryTree(){Clear(root);}//用于清除二叉树的递归函数template<class T>void BinaryTree<T>::Clear(BTreeNode<T> *&BT){if(BT!=NULL){ //当二叉树非空时进行如下操作Clear(BT->left); //删除左子树Clear(BT->right);//删除右子树delete BT; //删除根结点BT=NULL;} //置根指针为空}void main(){int n;char b[80]="(A)(B),C(D),E(F),G(H),I(J),K(L),M(N),O@"; BinaryTree<char> B;cout<<"创建的二叉树为:\n";B.CreateBTree(b);cout<<endl;if(!B.BTreeEmpty())cout<<"二叉树非空!\n";elsecout<<"二叉树为空!\n";cout<<"先序遍历二叉树:\n";B.TraverseBTree(1);cout<<endl;cout<<"中序遍历二叉树:\n";B.TraverseBTree(2);cout<<endl;cout<<"后序遍历二叉树:\n";B.TraverseBTree(3);cout<<endl;cout<<"按层遍历二叉树:\n";B.TraverseBTree(4);cout<<endl;n=B.BTreeDepth();cout<<"二叉树的深度="<<n<<endl;n=B.BTreeCount();cout<<"二叉树的所有结点数="<<n<<endl;n=B.BTreeLeafCount();cout<<"二叉树的所有叶子结点数="<<n<<endl;cout<<"按二叉树的广义表输出:\n";B.PrintBTree();cout<<endl;}五、实验过程实验四哈夫曼树与哈夫曼编码一、实验目的1、熟练掌握哈夫曼树的生成算法。
二叉树应用实验
![二叉树应用实验](https://img.taocdn.com/s3/m/79775f2458fb770bf78a553f.png)
二叉树应用实验实验目的(1)掌握二叉树的动态链表存储结构及表示。
(2)掌握二叉树的三种遍历算法(递归和非递归两类)。
(3)运用二叉树三种遍历的方法求解有关问题。
实验运行环境Visual C++实验任务为使实验程序简洁直观,下面的部分实验程序中的一些功能实现仍以调用库函数程序"btrechar.h"中的函数的形式给出,并假设该库函数中定义了二叉树指针和结点类型分别为bitre和bnode,以及部分常用运算,例如构建二叉树、以某种方式显示二叉树等。
各运算的名称较为直观,因而易于理解。
为便于数据的描述,将测试数据结构列出,并以一个文件名的形式给出标注,例如测试数据名为full41.cbt的二叉树,其具体结构形式参见二叉树列表中的标有full41.cbt 的二叉树。
实验内容第一题:求二叉树的高度。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: cbitre.cbt实验准备:第一步:将指针指向根结点,判断根结点是否为空,如果是则返回0,否则进入第二步。
第二步:判断当前结点是否有子树,如果没有,当前结点的高度为1,否则进入第三步。
第三步:求当前结点左右子树的高度,并将两者中较大的加1作为该结点的高度。
进入下一个结点,返回第二步。
第二题:设计算法按中序次序输出二叉树中各结点的值及其所对应的层次数。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: cbitre.cbt实验准备:第一步:将根节点的层次赋值为1。
第二步:判断当前结点是否为先序遍历的最后一个结点,是则输出二叉树中各结点的值及其所对应的层次数,并结束;否则,将当前结点的值以及层次输出,并将它的层次加1赋值给左右子树的层次。
移向下一个结点继续进行。
第三题:将按顺序方式存储在数组中的二叉树转换为二叉链表形式。
实验测试数据基本要求:第一组数据: full41.cbt第二组数据: letter.cbt实验准备:第一步:根据数组中的信息判断当前结点是否有左右子树,如果有并且已经建立了连接,就返回上一层,如果有但没建立连接就建立它与子树的连接。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验三二叉树的操作及应用实验课程名:数据结构与算法专业班级:15计科1班学号:201540410109 姓名:刘江实验时间:2016.10.24-10.31 实验地点:K4-102 指导教师:冯珊成绩:一、实验目的及要求1、进一步掌握指针变量、动态变量的含义。
2、掌握二叉树的结构特性,以及各种存储结构的特点和适用范围。
3、掌握用指针类型描述、访问和处理二叉树的运算。
二、实验内容任务一:完成下列程序,该程序以二叉链表作存储结构,构建如图1所示的二叉树,并依次进行二叉树的前序、中序、后序及层次遍历。
图1解答:(1)源代码:#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0typedef char DataType;/* 二叉树节点的存储类型 */typedef struct Node //define stricture BiTree{ DataType data;struct Node *lchild,*rchild;}Node, *BiTree;/*按先序序列建立一棵二叉树*/BiTree CreatBiTree(BiTree &T){DataType ch;scanf("%c",&ch);if(ch==' ') {T=NULL;}else{if(!(T=(Node*)malloc(sizeof(Node)))){printf("Overflow.\n") ;exit(0);}T->data =ch;CreatBiTree(T->lchild );CreatBiTree(T->rchild );}return T;}void PrintData(DataType x){printf("%c",x);}void PreOrder(BiTree T, void (*Visit)( DataType item))/*前序遍历二叉树T,访问操作为Visit()函数*/{if(T!= NULL){Visit(T->data);PreOrder(T->lchild, Visit);PreOrder(T->rchild, Visit);}}void InOrder(BiTree T, void (*Visit)( DataType item)) /*中序t */ {if(T!= NULL){InOrder(T->lchild, Visit);Visit(T->data);InOrder(T->rchild, Visit);}}void PostOrder(BiTree T, void (*Visit)( DataType item)) /*后序 */ {if(T!= NULL){PostOrder(T->lchild, Visit);PostOrder(T->rchild, Visit);Visit(T->data);}}int main(){int choice;BiTree root;printf("下面建立一棵二叉树,结点数据输入按先序次序。
\n");printf("输入数据请注意,每一个非空结点的所有孩子数据都要给出\n"); printf("若孩子为空,请用空格符表示。
\n");printf("请输入二叉树结点的数据,这里设定为字符:\n");CreatBiTree(root);printf("================================\n");printf("1:先序序列:\n");printf("2:中序序列:\n");printf("3:后序序列:\n");printf("其它值则退出:\n");printf("================================\n");do{printf("请输入对应的操作码:");scanf("%d",&choice);switch(choice){case 1:printf("\n先序序列为:");PreOrder(root,PrintData);printf("\n");break;case 2:printf("\n中序序列为:");InOrder(root,PrintData);printf("\n");break;case 3:printf("\n后序序列为:");PostOrder(root,PrintData);printf("\n");}}while(choice>0&&choice<4);return 0;}(2)运行结果:(3)运行结果分析:运用遍历方法实现二叉树的建立任务二:完成下列程序,该程序以二叉链表作存储结构,构建如图2所示二叉树,计算二叉树深度、所有结点总数、叶子结点数、双孩子结点个数、单孩子结点个数。
图2解答:(1)源代码:#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0typedef char TElemType;/* 二叉树节点的存储类型 */typedef struct BiTNode //define stricture BiTree{ TElemType data;struct BiTNode *lchild,*rchild;}BiTNode, *BiTree;/*按先序序列建立一棵二叉树*/void CreatBiTree(BiTree &T){TElemType ch;scanf("%c",&ch);if(ch==' ') {T=NULL;return;}else{if(!(T=(BiTNode*)malloc(sizeof(BiTNode)))){printf("Overflo w.\n");exit(0);}(T)->data =ch;CreatBiTree(T->lchild );CreatBiTree(T->rchild );}}void PrintData(TElemType x){printf("%c",x);}void PreOrder(BiTree T, void (*Visit)( TElemType item))/*前序遍历二叉树T,访问操作为Visit()函数*/{if(T!= NULL){Visit(T->data);PreOrder(T->lchild, Visit);PreOrder(T->rchild, Visit);}}void InOrder(BiTree T, void (*Visit)( TElemType item)) /*中序t */ {if(T!= NULL){InOrder(T->lchild, Visit);Visit(T->data);InOrder(T->rchild, Visit);}}void PostOrder(BiTree T, void (*Visit)( TElemType item)) /*后序 */ {if(T!= NULL){PostOrder(T->lchild, Visit);PostOrder(T->rchild, Visit);Visit(T->data);}}//以上代码与任务一的完全相同,下面是完成任务二的代码//注意这些函数算法的相似性int BTreeDepth(BiTree BT){int leftdep,rightdep;if (BT==NULL)return(0);else{leftdep=BTreeDepth(BT->lchild);rightdep=BTreeDepth(BT->rchild);if (leftdep>rightdep)return(leftdep+1);elsereturn(rightdep+1);}}int NodeCount(BiTree BT){if (BT==NULL)return(0);elsereturn(NodeCount (BT-> lchild)+ NodeCount (BT-> rchild)+1); }int LeafCount(BiTree BT){if (BT==NULL)return(0);else if (BT-> lchild ==NULL && BT-> rchild ==NULL)return(1);elsereturn(LeafCount (BT-> lchild)+ LeafCount (BT-> rchild)); }int NotLeafCount(BiTree BT){if (BT==NULL)return(0);else if (BT-> lchild ==NULL && BT-> rchild ==NULL)return(0);elsereturn(NotLeafCount (BT-> lchild)+ NotLeafCount (BT->rchild)+1);}int OneChildCount(BiTree BT){if (BT==NULL)return(0);else if ((BT-> lchild ==NULL && BT-> rchild!=NULL) ||(BT-> lchild!=NULL && BT-> rchild ==NULL))return(OneChildCount (BT-> lchild)+ OneChildCount (BT->rchild)+1);elsereturn(OneChildCount (BT-> lchild)+ OneChildCount (BT->rchild));}int TwoChildCount(BiTree BT){if (BT==NULL)return(0);else if (BT-> lchild ==NULL || BT-> rchild ==NULL)return(TwoChildCount (BT-> lchild)+ TwoChildCount (BT->rchild));else if (BT-> lchild!=NULL && BT-> rchild!=NULL)return(TwoChildCount (BT-> lchild)+ TwoChildCount (BT->rchild)+1);}//主函数在任务一的基础上进行适当的增添int main(){int choice;BiTree root;printf("下面建立一棵二叉树,结点数据输入按先序次序。