实验三 二叉树的基本运算

合集下载

实验报告二叉树

实验报告二叉树
p->data);PreOrder(p->lchild);PreOrder(p->rchild);}}void InOrder(BiTree p){ /* 中序遍历二叉树*/ if( p!= NULL ) {InOrder( p->lchild ) ;printf("%c", p->data);InOrder( p->rchild) ; } }void PostOrder(BiTree p){ /* 后序遍历二叉树*/ if ( p!= NULL ) {PostOrder( p->lchild ) ;PostOrder( p->rchild) ;printf("%c", p->data); } }void Preorder_n(BiTree p){ /*先序遍历的非递归算法*/ BiTree stack[MAX],q; int top=0,i;for(i=0;i while(q!=NULL){printf("%c",q->data);if(q->rchild!=NULL) stack[top++]=q->rchild;if(q->lchild!=NULL) q=q->lchild;elseif(top>0) q=stack[--top]; else q=NULL; } }void release(BiTree t){ /*释放二叉树空间*/ if(t!=NULL){release(t->lchild); release(t->rchild);
递归遍历右子树输出根结点数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);

二叉树基本运算

二叉树基本运算

二叉树基本运算二叉树基本运算二叉树是计算机科学中最基础的数据结构之一,它由节点和指向其左右子节点的指针组成。

在实际应用中,二叉树作为一种重要的数据结构,可以用于解决各种问题。

在进行二叉树的操作时,常见的有插入节点、删除节点、查找节点以及遍历。

这些操作都是二叉树的基本运算。

第一类运算是插入节点的操作。

插入节点到二叉树中,需要根据一定的规则将新节点放置在合适的位置。

例如,若新节点的值比当前节点的值小,则将其放在当前节点的左侧;若新节点的值大,则将其放在当前节点的右侧。

这样,可以保持二叉树的有序性。

插入节点的运算可以通过递归或迭代的方式实现。

无论是哪种方式,重要的是要保证插入后的二叉树仍然是一棵二叉树。

第二类运算是删除节点的操作。

删除节点的操作相对比较复杂,需要考虑被删除节点的子节点情况。

若被删除节点没有子节点,则直接删除即可;若被删除节点只有一个子节点,则将其子节点连接到被删除节点的父节点上即可;若被删除节点有两个子节点,则需找到其右子树的最小节点,用该最小节点替代被删除节点,并删除该最小节点。

删除节点的运算同样可以通过递归或迭代的方式实现。

第三类运算是查找节点的操作。

查找节点的操作可以用于判断二叉树中是否存在某个特定值的节点。

查找节点的运算可以通过递归或迭代的方式实现。

在递归实现中,从根节点开始,若当前节点的值等于目标值,则返回该节点,否则分别在左子节点和右子节点中进行查找。

在迭代实现中,可以借助栈或队列等数据结构来辅助查找。

最后一类运算是遍历二叉树的操作。

二叉树的遍历有三种方式:前序遍历、中序遍历和后序遍历。

前序遍历先访问根节点,然后依次遍历左子树和右子树;中序遍历先遍历左子树,然后访问根节点,最后遍历右子树;后序遍历先遍历左子树,然后遍历右子树,最后访问根节点。

这三种遍历方式均可以通过递归或迭代的方式实现。

在二叉树的基本运算中,不同的操作可以根据具体的需求进行选择。

其中,插入节点、删除节点和查找节点操作都涉及到对二叉树结构的修改,需要小心处理,以保证操作的正确性。

二叉树的定义及基本操作

二叉树的定义及基本操作
五、实验结果及分析
(所输入的数据及相应的运行结果,运行结果要有提示信息,运行结果采用截图 方式给出。)
2
① 输入界面
②输出结果
③测试式子 6*((5+(2+)*8)+3)
六、总结与体会
(调试程序的心得与体会,若实验课上未完成调试,要认真找出错误并分析原因 等。)
每次的实验,总是很受打击。不过,在这过程中,能让我发现自己的 不足,逐渐改善,这是做实验给我最大的收获。 七、程序清单(包含注释)
四、实验记录
(调试过程及调试中遇到的问题及解决办法,其他算法的存在与实践等。) ① 调试过程老是出现访问冲突的错问,通过上网查找访问冲突方面的消息,才
知道应该是指针指错地址,经过调试,最终解决了问题。 ②
调试过程中还出现了这个问题,Status CreateBiTree(BiTree T),当这样定 义时,问题就出现了,但是 Status CreateBiTree(BiTree &T)这样定义就没问题 了,这个想不通。
-
+
/
1.中缀表达式(中序遍历): a+(b*(c-d))-(e/f)
a
*e
2.前缀表达式/波兰式(前序遍历):
f
-+a*b-cd/ef
b-
3.后缀表达式/逆波兰式(后序遍历): abcd-*+ef/-
《《《《《
《 《《《《
C《《《 《 P129
cd
表达式二叉树
1
三、实验所涉及的知识点 递归函数 二叉树
输入说明
***\n"); printf("*** 请按先序输入表达式,当结点的左子树或者右
子树为空时输入‘#‘***\n");

实验三--二叉树的基本运算

实验三--二叉树的基本运算

实验三二叉树的基本运算一、实验目的1、使学生熟练掌握二叉树的逻辑结构和存储结构。

2、熟练掌握二叉树的各种遍历算法。

二、实验内容1、问题描述建立一棵二叉树,试编程实现二叉树的如下基本操作:(1). 按先序序列构造一棵二叉链表表示的二叉树T;(2). 对这棵二叉树进行遍历:先序、中序、后序以及层次遍历,分别输出结点的遍历序列;(3). 求二叉树的深度/结点数目/叶结点数目;(选做)(4). 将二叉树每个结点的左右子树交换位置。

(选做)2、基本要求从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立)。

3、测试数据如输入:abc00de0g00f000(其中ф表示空格字符)则输出结果为:先序:a->b->c->d->e->g->f中序:a->b->c->d->e->g->f后序:a->b->c->d->e->g->f三、程序代码#include<malloc.h>#include<iostream.h>#define OK 1#define ERROR -1typedef char TElemType;int i;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int CreateBiTree(BiTree&T) //创建二叉树{char a;cin>>a;if(a=='0') T=NULL;else{if(!(T=(BiTNode*)malloc(sizeof(BiTNode)))) {return ERROR;}T->data=a;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return OK;}int PreOrderTraverse(BiTree&T) //先序遍历二叉树{if(T){//cout<<"此为先序遍历"<<endl;cout<<T->data<<"->";if(PreOrderTraverse(T->lchild))if(PreOrderTraverse(T->rchild))return OK;return ERROR;}else return OK;}int InOrderTraverse(BiTree&T) //中序遍历二叉树{if(T){//cout<<"此为中序遍历"<<endl;if(InOrderTraverse(T->lchild)){cout<<T->data<<"->";if(InOrderTraverse(T->rchild))return OK;}return ERROR;}else return OK;}int PostOrderTraverse(BiTree&T) //后序遍历二叉树{if(T){//cout<<"此为后序遍历"<<endl;if (PostOrderTraverse(T->lchild))if(PostOrderTraverse(T->rchild)){cout<<T->data<<"->";i++;return (OK);}return (ERROR);}elsereturn (OK);}int CountDepth(BiTree&T) //计算二叉树的深度{if(T==NULL){return 0;}else{int depl=CountDepth(T->lchild);int depr=CountDepth(T->lchild);if(depl>depr){return depl+1;}else{return depr+1;}}}void main() //主函数{BiTree T;cout<<"请输入二叉树节点的值以创建树"<<endl;CreateBiTree(T);cout<<"此为先序遍历";PreOrderTraverse(T);cout<<"end"<<endl;cout<<"此为中序遍历";InOrderTraverse(T);cout<<"end"<<endl;cout<<"此为后序遍历";PostOrderTraverse(T);cout<<"end"<<endl<<"此树节点数是"<<i<<endl<<"此树深度是"<<CountDepth(T)<<endl;}四、调试结果及运行界面:五、实验心得通过这次程序上机实验让我认识到了以前还不太了解的二叉树的性质和作用,这次实验的的确确的加深了我对它的理解。

数据结构实验三实验报告

数据结构实验三实验报告

数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。

具体来说,我们需要实现一个树的数据结构,并对其进行插入、删除、查找等操作,同时还需要实现树的遍历算法,包括先序、中序和后序遍历。

二、实验原理树是一种非线性的数据结构,由结点和边组成。

树的每个结点都可以有多个子结点,但是每个结点只有一个父结点,除了根结点外。

树的基本操作包括插入、删除和查找。

在本次实验中,我们采用二叉树作为实现树的数据结构。

二叉树是一种特殊的树,每个结点最多只有两个子结点。

根据二叉树的特点,我们可以使用递归的方式实现树的插入、删除和查找操作。

三、实验过程1. 实现树的数据结构首先,我们需要定义树的结点类,包括结点值、左子结点和右子结点。

然后,我们可以定义树的类,包括根结点和相应的操作方法,如插入、删除和查找。

2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。

我们可以通过递归的方式实现插入操作。

具体来说,如果要插入的值小于当前结点的值,则将其插入到左子树中;如果要插入的值大于当前结点的值,则将其插入到右子树中。

如果当前结点为空,则将新的结点作为当前结点。

3. 实现删除操作删除操作是将指定的结点从树中移除的过程。

我们同样可以通过递归的方式实现删除操作。

具体来说,如果要删除的值小于当前结点的值,则在左子树中继续查找;如果要删除的值大于当前结点的值,则在右子树中继续查找。

如果要删除的值等于当前结点的值,则有三种情况:- 当前结点没有子结点:直接将当前结点置为空。

- 当前结点只有一个子结点:将当前结点的子结点替代当前结点。

- 当前结点有两个子结点:找到当前结点右子树中的最小值,将其替代当前结点,并在右子树中删除该最小值。

4. 实现查找操作查找操作是在树中寻找指定值的过程。

同样可以通过递归的方式实现查找操作。

具体来说,如果要查找的值小于当前结点的值,则在左子树中继续查找;如果要查找的值大于当前结点的值,则在右子树中继续查找。

二叉树的操作实验报告

二叉树的操作实验报告

二叉树的操作实验报告二叉树的操作实验报告引言二叉树是计算机科学中常用的数据结构,它具有良好的搜索性能和灵活的插入和删除操作。

本实验旨在通过实际操作,深入理解二叉树的基本操作和特性。

1. 二叉树的定义和基本概念二叉树是一种特殊的树状结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。

二叉树的节点由数据和指向左右子节点的指针组成。

根据节点的位置,可以将二叉树分为左子树、右子树和根节点。

2. 二叉树的遍历二叉树的遍历是指按照一定的顺序访问二叉树中的所有节点。

常用的遍历方式有前序遍历、中序遍历和后序遍历。

前序遍历先访问根节点,然后按照左子树、右子树的顺序遍历;中序遍历先访问左子树,然后根节点,最后右子树;后序遍历先访问左子树,然后右子树,最后根节点。

3. 二叉树的插入操作插入操作是将一个新节点插入到二叉树中的特定位置。

插入操作需要考虑节点的大小关系,小于当前节点则插入到左子树,大于当前节点则插入到右子树。

插入操作可以保持二叉树的有序性。

4. 二叉树的删除操作删除操作是将指定节点从二叉树中删除。

删除操作需要考虑被删除节点的子节点情况,如果被删除节点没有子节点,则直接删除;如果有一个子节点,则将子节点替代被删除节点的位置;如果有两个子节点,则选择被删除节点的后继节点或前驱节点替代被删除节点。

5. 二叉树的查找操作查找操作是在二叉树中搜索指定的节点。

二叉树的查找操作可以使用递归或迭代的方式实现。

递归方式会自动遍历整个二叉树,直到找到目标节点或遍历完整个树。

迭代方式则需要手动比较节点的值,并根据大小关系选择左子树或右子树进行进一步查找。

6. 二叉树的平衡性二叉树的平衡性是指左子树和右子树的高度差不超过1。

平衡二叉树可以提高搜索效率,避免出现极端情况下的性能下降。

常见的平衡二叉树有AVL树和红黑树。

7. 二叉树应用场景二叉树在计算机科学中有广泛的应用场景。

例如,文件系统的目录结构可以使用二叉树来表示;数据库中的索引结构也可以使用二叉树来实现。

实现二叉树的各种基本运算的算法

实现二叉树的各种基本运算的算法

实现二叉树的各种基本运算的算法1.二叉树的定义及概述二叉树是一种重要的数据结构,它是由节点组成的序列,每个节点最多有两个子节点。

二叉树的根节点是唯一的,且每个节点都有一个“父节点”,除了根节点外,每个子节点称作“左孩子”和“右孩子”。

二叉树的组成部分是节点,每个节点包括一个数据元素和左右孩子指针。

通过这些指针构成的树形结构,可以便捷地进行数据存储和操作。

本文将介绍二叉树的各种基本运算及实现方法。

2.二叉树的遍历二叉树的遍历分为三种:前序遍历、中序遍历和后序遍历。

前序遍历:按照“根节点-左孩子-右孩子”的顺序遍历二叉树。

中序遍历:按照“左孩子-根节点-右孩子”的顺序遍历二叉树。

后序遍历:按照“左孩子-右孩子-根节点”的顺序遍历二叉树。

3.二叉树的建立二叉树的建立有三种方法:链式存储法、顺序存储法和扩展二叉树。

链式存储法:链式存储法是用链表来表示二叉树的方法,每个节点包括数据域和左右孩子指针域。

链式存储法建立二叉树比较容易,操作起来也比较方便。

顺序存储法:顺序存储法是用数组来表示二叉树的方法,便于存取、操作和查找。

但是顺序存储法的空间利用率不高,只有满二叉树才能利用完全。

扩展二叉树:是指二叉树中所有的空节点都必须存储起来,以构成一颗可以存储不满的二叉树。

由于扩展二叉树浪费了大量的空间,因此很少使用。

4.二叉树的查找二叉树的查找分为两种:层序遍历和二叉排序树的查找。

层序遍历:是一种广度优先搜索的方式来遍历二叉树。

层序遍历可以找到二叉树中从根节点到任意节点的路径,具有较高的效率。

层序遍历可以使用队列来实现。

二叉排序树的查找:是指在一颗二叉排序树中查找某个元素的算法。

二叉排序树(BST)是一颗二叉树,其中每个节点的值都比它的左子节点大,比它的右子节点小。

通过对BST的查找操作,可以将查找的效率高效地进行。

5.二叉树的删除在二叉树中删除节点有两种情况:删除叶子节点和删除非叶子节点。

下面给出二叉树的删除基本操作。

二叉树的各种基本运算的实现实验报告

二叉树的各种基本运算的实现实验报告

二叉树的各种基本运算的实现实验报告
一、实验目的
实验目的为了深入学习二叉树的各种基本运算,通过操作实现二叉树的建立、存储、查找、删除、遍历等各种基本运算操作。

二、实验内容
1、构造一个二叉树。

我们首先用一定的节点来构建一棵二叉树,包括节点的左子节点和右子节点。

2、实现查找二叉树中的节点。

在查找二叉树中的节点时,我们根据二叉树的特点,从根节点开始查找,根据要查找的节点的值与根节点的值的大小的关系,来决定接下来查找的方向,直到找到要查找的节点为止。

3、实现删除二叉树中的节点。

在删除二叉树节点时,我们要做的是找到要删除节点的父节点,然后让父节点的链接指向要删除节点的子节点,有可能要删除节点有一个子节点,有可能有两个极点,有可能没有子节点,我们要根据每种情况进行处理,来保持二叉树的结构不变。

4、对二叉树进行遍历操作。

二叉树的遍历有多种方法,本实验使用的是先序遍历。

首先从根节点出发,根据先序遍历的顺序,先访问左子树,然后再访问右子树,最后访问根节点。

三、实验步骤
1、构建二叉树:
我们用一个数组代表要构建的二叉树,第一项为根节点,第二项和第三项是根节点的子节点。

二叉树各种基本运算与遍历算法

二叉树各种基本运算与遍历算法
return(num1+num2+1);
}
}
int LeafNodes(BTNode*b)
{
int num1,num2;
if(b==NULL)
return 0;
else if(b->lchild==NULL&&b->rchild==NULL)
return 1;
else
{
num1=LeafNodes(b->lchild);
{
return p->lchild;
}
BTNode *RchildNode(BTNode *p)
{
return p->rchild;
}
int BTNodeDepth(BTNode *b)
{
int lchilddep,rchilddep;
if(b==NULL)
return(0);
else
{
lchilddep=BT}
int Nodes(BTNode*b)
{
int num1,num2;
if(b==NULL)
return 0;
else if(b->lchild==NULL&&b->rchild==NULL)
return 1;
else
{
num1=Nodes(b->lchild);
num2=Nodes(b->rchild);
St[top].pt=p->rchild;
St[top].tag=1;
top++;
St[top].pt=p->lchild;
St[top].tag=1;

树和二叉树的实验报告

树和二叉树的实验报告

树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构,它们在各种算法和应用中都有广泛的应用。

本实验旨在通过实际操作和观察,深入了解树和二叉树的特性和操作。

二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构,由节点和边组成。

每个节点可以有零个或多个子节点,其中一个节点没有父节点的称为根节点。

树的特点包括层次结构、唯一根节点和无环等。

2. 树的构建在本实验中,我们使用Python语言构建了一棵树。

通过定义节点类和树类,我们可以方便地创建树的实例,并添加节点和连接节点之间的边。

3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。

常见的遍历方式有前序遍历、中序遍历和后序遍历。

我们在实验中实现了这三种遍历方式,并观察了它们的输出结果。

三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树,每个节点最多有两个子节点,分别称为左子节点和右子节点。

二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。

2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。

通过定义节点类和二叉树类,我们可以创建二叉树的实例,并实现插入节点、删除节点和查找节点等操作。

3. 二叉树的应用二叉树在实际应用中有很多用途。

例如,二叉搜索树可以用于实现快速查找和排序算法。

AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。

我们在实验中实现了这些应用,并通过实际操作验证了它们的效果。

四、实验结果与讨论通过实验,我们成功构建了树和二叉树的数据结构,并实现了它们的基本操作。

通过观察和分析实验结果,我们发现树和二叉树在各种算法和应用中的重要性和灵活性。

树和二叉树的特性使得它们适用于解决各种问题,例如搜索、排序、图算法等。

同时,我们也发现了一些问题和挑战,例如树的平衡性和节点的插入和删除操作等。

这些问题需要进一步的研究和优化。

五、总结本实验通过实际操作和观察,深入了解了树和二叉树的特性和操作。

实验三 二叉树基本运算以及遍历

实验三 二叉树基本运算以及遍历

实验三二叉树基本运算以及遍历一实验目的:了解树的逻辑和存储特点,掌握二叉树的建立,以及前中后序遍历的理论思想和运算方法。

二实验内容:建立一棵二叉树,添加树中结点的元素,对该二叉树进行前、中、后序遍历,并打印遍历结果三实验原理:二叉树(Binary Tree)是个有限元素的集合,该集合或者为空、或者由一个称为根(root)的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。

当集合为空时,称该二叉树为空二叉树。

在二叉树中,一个元素也称作一个结点。

二叉树是有序的,即若将其左、右子树颠倒,就成为另一棵不同的二叉树。

即使树中结点只有一棵子树,也要区分它是左子树还是右子树。

即用链来指示着元素的与rchild分别存放指向左孩子和右孩子的指针,当左孩子或右孩子不存在时,相应指针域值为空。

二叉树的建立:1 建立根结点。

2 若左子树不空则建左子树。

3 若右子树不空则建右子树。

二叉树的前序遍历1 访问根结点;2 先序遍历根结点的左子树;3 先序遍历根结点的右子树。

二叉树的中序遍历1 中序遍历根结点的左子树;2 访问根结点;3 中序遍历根结点的右子树。

二叉树的后序遍历1后序遍历根结点的左子树;2后序遍历根结点的右子树。

3访问根结点;四实验步骤1 进入Turbo C2.0,新建一个文件。

2 输入程序,程序要求使用子函数进行组织。

3 将源程序保存到指定文件夹“D:\学生姓名”。

4 按F9调试,纠正语法错误。

5按Ctrl+F9运行,调试逻辑错误。

6 按Alt+F5查看结果。

五、实验中应注意的问题与思考题:1 如果需要对树中的数据进行查询修改,应该如何实现?先找到需要修改的数据的位置,再让对其赋值。

2对各个功能模块采用独立编制子函数,增强程序的可执行性、可移植性和可读性。

增加情报信息量,对实际应用中可能发生的情况考虑周全,对非法情形要提出适当的处理方案。

3 深入了解树的逻辑结构,重点掌握递归方法的原理和实现,在确定递归终点条件的时候应特别小心,避免产生死循环。

数据结构实验三——二叉树基本操作及运算实验报告

数据结构实验三——二叉树基本操作及运算实验报告

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为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,失败。

二叉树实验报告

二叉树实验报告

二叉树实验报告1. 引言二叉树是一种常用的数据结构,广泛应用于计算机科学和信息技术领域。

本实验旨在通过对二叉树的理解和实现,加深对数据结构与算法的认识和应用能力。

本报告将介绍二叉树的定义、基本操作以及实验过程中的设计和实现。

2. 二叉树的定义二叉树是一个有序树,其每个节点最多有两个子节点。

树的左子节点和右子节点被称为二叉树的左子树和右子树。

3. 二叉树的基本操作3.1 二叉树的创建在实验中,我们通过定义一个二叉树的节点结构来创建一个二叉树。

节点结构包含一个数据域和左右指针,用于指向左右子节点。

创建二叉树的过程可以通过递归或者迭代的方式来完成。

3.2 二叉树的插入和删除二叉树的插入操作是将新节点插入到树中的合适位置。

插入时需要考虑保持二叉树的有序性。

删除操作是将指定节点从树中删除,并保持二叉树的有序性。

在实验中,我们可以使用递归或者循环的方式实现这些操作。

3.3 二叉树的遍历二叉树的遍历是指按照某种次序访问二叉树的所有节点。

常见的遍历方式包括前序遍历、中序遍历和后序遍历。

前序遍历先访问根节点,然后按照左孩子-右孩子的顺序递归遍历左右子树。

中序遍历按照左孩子-根节点-右孩子的顺序递归遍历左右子树。

后序遍历按照左孩子-右孩子-根节点的顺序递归遍历左右子树。

3.4 二叉树的查找查找操作是指在二叉树中查找指定的值。

可以通过递归或者循环的方式实现二叉树的查找操作。

基本思路是从根节点开始,通过比较节点的值和目标值的大小关系,逐步向左子树或者右子树进行查找,直到找到目标节点或者遍历到叶子节点。

4. 实验设计和实现在本实验中,我们设计并实现了一个基于Python语言的二叉树类。

具体实现包括二叉树的创建、插入、删除、遍历和查找操作。

在实验过程中,我们运用了递归和迭代的方法实现了这些操作,并进行了测试和验证。

4.1 二叉树类的设计我们将二叉树的节点设计为一个类,其中包括数据域和左右子节点的指针。

另外,我们设计了一个二叉树类,包含了二叉树的基本操作方法。

二叉树的基本操作与实现实验报告

二叉树的基本操作与实现实验报告

二叉树的基本操作与实现实验报告二叉树是一种重要的数据结构,在计算机科学领域中被广泛应用。

本实验将介绍二叉树的基本操作与实现,并给出相应的实验报告。

一、引言二叉树是一种特殊的树状结构,每个节点至多有两个子节点。

二叉树有许多重要的特性,如平衡二叉树、二叉树等,应用广泛。

在本实验中,我们将介绍二叉树的基本操作和实现。

二、实验目的1.掌握二叉树的基本概念和特性;2.熟悉二叉树的基本操作,包括创建、插入、删除、遍历等;3.学会使用编程语言实现二叉树的基本操作。

三、实验内容本实验主要包括以下内容:1.二叉树的定义和基本概念;2.二叉树的基本操作,包括创建、插入、删除、遍历等;3.使用编程语言实现二叉树的基本操作;4.测试和验证二叉树的基本操作的正确性。

四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构,每个节点至多有两个子节点。

二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。

二叉树的特性有很多,如完全二叉树、平衡二叉树、二叉树等。

2.二叉树的基本操作(1)创建二叉树:可以通过手动输入节点数据来创建二叉树,也可以通过读取文件中的数据来创建二叉树。

(2)插入节点:在指定位置插入一个新节点。

(3)删除节点:删除指定位置的节点。

(4)遍历二叉树:有前序遍历、中序遍历和后序遍历三种遍历方式。

3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。

我们可以定义一个二叉树的结构体,包含节点数据和指向左右子树的指针。

然后根据具体的需求,实现相应的操作函数。

4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后,我们可以编写测试代码来验证操作的正确性。

通过创建二叉树,并进行插入、删除和遍历操作,观察输出结果是否符合预期。

五、实验结果与分析在完成二叉树的基本操作后,我们可以进行测试和验证。

通过输出二叉树的遍历结果,比对预期结果来判断操作是否正确。

同时,我们还可以观察二叉树的结构和特性,如是否满足平衡二叉树或二叉树的条件。

二叉树的基本操作实验报告

二叉树的基本操作实验报告

二叉树的基本操作实验报告二叉树的基本操作实验报告引言:二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。

二叉树的基本操作包括创建、遍历、插入和删除等。

本实验旨在通过实践来深入了解二叉树的基本操作,并通过实验结果验证其正确性和有效性。

一、创建二叉树创建二叉树是二叉树操作中的第一步。

在本实验中,我们使用了递归算法来创建二叉树。

递归算法是一种重要的算法思想,通过将问题划分为更小的子问题来解决复杂的问题。

在创建二叉树时,我们首先创建根节点,然后递归地创建左子树和右子树。

二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。

常见的遍历方式有前序遍历、中序遍历和后序遍历。

前序遍历先访问根节点,然后递归遍历左子树和右子树;中序遍历先递归遍历左子树,然后访问根节点,最后递归遍历右子树;后序遍历先递归遍历左子树和右子树,最后访问根节点。

三、插入节点插入节点是向二叉树中添加新节点的操作。

插入节点的过程需要遵循二叉树的特性,即左子节点的值小于父节点的值,右子节点的值大于父节点的值。

在插入节点时,我们需要找到合适的位置,将新节点插入到正确的位置上。

四、删除节点删除节点是从二叉树中移除节点的操作。

删除节点的过程相对复杂,需要考虑多种情况。

如果要删除的节点是叶子节点,直接删除即可。

如果要删除的节点只有一个子节点,将其子节点连接到父节点上。

如果要删除的节点有两个子节点,我们需要找到其后继节点或前驱节点来替代被删除的节点。

实验结果:通过实验,我们成功地实现了二叉树的基本操作。

创建二叉树的递归算法能够正确地创建出符合要求的二叉树。

遍历二叉树的算法能够按照指定的顺序遍历每个节点。

插入节点和删除节点的操作也能够正确地修改二叉树的结构。

讨论与总结:二叉树的基本操作是数据结构中的重要内容,对于理解和应用其他数据结构具有重要意义。

通过本次实验,我们深入了解了二叉树的创建、遍历、插入和删除等操作,并通过实验验证了其正确性和有效性。

二叉树基本运算算法的实现

二叉树基本运算算法的实现

二叉树基本运算算法的实现
二叉树是一种常见的数据结构,基本运算算法包括二叉树的遍历、查找、插入、删除等操作。

下面是这些算法的实现:
1. 二叉树遍历:二叉树遍历有三种方式,分别是前序遍历、中序遍历和后序遍历。

其中,前序遍历先访问根节点,再访问左子树和右子树;中序遍历先访问左子树,再访问根节点和右子树;后序遍历先访问左子树,再访问右子树和根节点。

遍历可以使用递归算法或栈实现。

2. 二叉树查找:二叉树查找可以使用递归算法或循环算法实现。

递归算法通过比较节点值实现查找,如果查找值小于当前节点值,则在左子树中查找,否则在右子树中查找。

循环算法使用二叉树的特性,比较查找值和当前节点值的大小,根据大小关系不断移动到左子树或右子树中进行查找,直到找到目标节点或遍历到叶子节点为止。

3. 二叉树插入:二叉树插入需要先查找到插入位置,然后在该位置插入一个新节点。

插入操作可以使用递归算法或循环算法实现。

4. 二叉树删除:二叉树删除分为三种情况:删除叶子节点、删除只有一个孩子的节点和删除有两个孩子的节点。

删除叶子节点很简单,只需要将其父节点的指针设为NULL即可。

删除只有一个孩子的节点需要将父节点的指针指向该节点的
孩子节点。

删除有两个孩子的节点需要找到该节点的后继节点(或前驱节点),将后继节点的值复制到该节点中,然后删除后继节点。

上述算法的实现需要根据具体的编程语言进行调整和实现。

实验报告 实验三 二叉排序树的建立和查找

实验报告 实验三 二叉排序树的建立和查找

实验三二叉排序树的建立和查找一、实验目的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");}实验中出现的问题及对问题的解决方案输入数据时,总是不能得到结果,原因是在建立二叉树函数定义中,是对指针的值进行了修改。

实验3 二叉树的应用

实验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; }五、实验结果:。

二叉树各种基本运算与遍历算法

二叉树各种基本运算与遍历算法
3、调试程序,编译运行并用数据测试程序
四、实验步骤:
(对实验步骤的说明应该能够保证根据该说明即可重复完整的实验内容,得到正确结果。)
1、对实现二叉树的基本运算算法以及遍历算法做分析,绘制算法流程图
1)设计二叉树的节点表示方法
2)设计和实现相关算法函数
2、在VS6.0环境下编译实现代码
1)编辑源程序,达到调试编译运行的目的
数据结构与算法实验报告
实验名称:
二叉树各种基本运算与遍历算法
班级:Biblioteka 姓名:学号:类型:
综合
实验地点:
鹤琴404
日期:
2012.11.15
一、实验目的:
1.理解二叉树的概念及其基本运算算法(这些算法包括二叉树的创建、节点访问、求二叉树的深度以及二叉树的先根遍历、中根遍历、后根遍历算法)
2.用c语言实现二叉树的基本运算算法和遍历算法。
2)利用数据进行测试验证
五、实验结果与分析(含程序、数据记录及分析和实验总结等):
六:思考题:
学生用户名密码liweiguostu liweiguostu
> ftp://219.230.50.126/
3.调试程序,编译运行并用数据测试程序
4.熟悉c语言编程
二、实验环境:
1.PC机一台(带有VS 6.0软件)
三、实验内容和要求:
1、用c语言实现二叉树的基本运算算法(包括二叉树的创建、节点访问、求二叉树的深度);
2、用c语言实现二叉树的三种遍历算法(先根遍历、中根遍历、后根遍历),其中中根遍历算法用递归和非递归两种方式实现,加深理解栈在非递归实现中的应用;

实验三 二叉树的基本运算

实验三  二叉树的基本运算

数据结构实验报告(实验三&实验四)班级:软件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、熟练掌握哈夫曼树的生成算法。

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

实验三二叉树的基本运算
一、实验目的
1、使学生熟练掌握二叉树的逻辑结构和存储结构。

2、熟练掌握二叉树的各种遍历算法。

二、实验内容
[问题描述]
建立一棵二叉树,试编程实现二叉树的如下基本操作:
1. 按先序序列构造一棵二叉链表表示的二叉树T;
2. 对这棵二叉树进行遍历:先序、中序、后序以及层次遍历,分别输出结点的遍历序列;
3. 求二叉树的深度/结点数目/叶结点数目;(选做)
4. 将二叉树每个结点的左右子树交换位置。

(选做)
[基本要求]
从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立),
[测试数据]
如输入:ABCффDEфGффFффф(其中ф表示空格字符)
则输出结果为
先序:ABCDEGF
中序:CBEGDFA
后序:CGEFDBA
层序:ABCDEFG
[选作内容]
采用非递归算法实现二叉树遍历。

三、实验程序
#include <iostream>
#include <math.h>
using namespace std;
typedef char TElemType;
typedef struct BiTNode{ //定
义节点
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
int DLRcreat(BiTree &T) //先序建立二叉树
{
char d;
cin>>d;
if(d=='#')T=NULL;
else
{
T=new BiTNode;
if(!T)exit(1);
T->data=d;
DLRcreat(T->lchild);
DLRcreat(T->rchild);
}
return 0;
}
int florder(BiTree T) //
层序遍历指针数组
{
BiTNode *Q[100]; //树节点指针数组,用于存放遍历到的元素地址
if(T==NULL)cout<<"空的二叉树"<<endl;
Q[0]=T; //存入树根
int i;
int j=1;
for(i=0;i<j;i++)
{
if(Q[i]->lchild!=NULL) //如果有左孩子,存入地址,j加一,否则没操作
{
Q[j]=Q[i]->lchild ;
j++;
}
if(Q[i]->rchild!=NULL) //如果有右孩子,存入地址,j加一,否则没操作
{
Q[j]=Q[i]->rchild ;
j++;
}
for(i=0;i<j;i++)cout<<" "<<Q[i]->data;
return 0;
}
int howmuch(BiTree T,int h)
{
BiTNode *Q[100]; //树节点指针数组,用于存放遍历到的元素地址
if(T==NULL)cout<<"空的二叉树"<<endl;
Q[0]=T; //存入树根
int i,k=0;
int j=1; //j-1为总节点
for(i=0;i<j;i++)
{
if(Q[i]->lchild!=NULL) //如果有左孩子,存入地址,j加一,否则没操作
{
Q[j]=Q[i]->lchild ;
j++;
if(Q[i]->rchild!=NULL) //如果
有右孩子,存入地址,j加一,否则没操作
{
Q[j]=Q[i]->rchild ;
j++;
}
if(Q[i]->lchild==NULL&&Q[i]->rchild==NULL)k++; //计算叶子数
}
i=ceil(log(j-1))+1; //计算深度
if(h==0)return j;
else if(h==1)return k;
else if(h==2)return i;
else {cout<<"参数错误";}
return 0;
}
int DLRorder(BiTree T) //先序遍历
{
if(T != NULL)
{
cout<<" "<<T->data; // 访问根结点
DLRorder(T->lchild); // 前序遍历左子树
DLRorder(T->rchild); // 前序遍历右子树
}
return 0;
}
int LDRorder(BiTree T) //中序遍历递归
{
if(T!=NULL)
{
LDRorder(T->lchild);
cout<<" "<<T->data;
LDRorder(T->rchild );
}
return 0;
}
int LRDorder(BiTree T)
//后序遍历递归
{
if(T!=NULL)
{
LDRorder(T->lchild);
LDRorder(T->rchild );
cout<<" "<<T->data;
}
return 0;
}
int exchang(BiTree &T) //交换左右子树
{
if(T != NULL)
{
if(T->lchild!=NULL&&T->rchild!=NULL)
//当有左右孩子时才交换
{
char t;
t=T->lchild->data;T->lchild->data=T->rchild->data;
T->rchild->data=t;
//交换数据
}
exchang(T->lchild);
// 递归调用
exchang(T->rchild);
}
return 0;
}
int choose(BiTree T) //功能选择
{
int a;cin>>a;
if(a==1){cout<<"先序遍历";DLRorder(T);}
else if(a==2){cout<<"中序遍历";LDRorder(T);}
else if(a==3){cout<<"后序遍历";LRDorder(T);}
else if(a==4){cout<<"层序遍历";florder(T);}
else if(a==5){cout<<"总节点数:"<<howmuch(T,0);}
else if(a==6){cout<<"总叶子数:"<<howmuch(T,1);}
else if(a==7){cout<<"树的深度:"<<howmuch(T,2);}
else if(a==8){cout<<"交换前
"<<endl;florder(T);exchang(T);cout<<"交换后
";florder(T);}
else if(a==9)exit(1);
else cout<<"没有这个操作"<<endl;
cout<<endl<<"操作完成,请输入下一个操作"<<endl;
choose(T);
return 0;
}
int main() //主函数
{
cout<<"----------------二叉树的基本操作
----------------"<<endl;
cout<<"请先建立二叉树,按先序的方式输入如果数据为空
输入#"<<endl;
BiTree T; //定义二叉树,初始化
DLRcreat(T);
cout<<"1.先序遍历二叉树 2.中序遍历二
叉树"<<endl;
cout<<"3.后序遍历二叉树 4.层序遍历二
叉树"<<endl;
cout<<"5.求总节点数 6.求叶子总数
"<<endl;
cout<<"7.深度-完全二叉树有效 8.左右子树交换"<<endl;
cout<<"9.退出"<<endl;
choose(T);
return 0;
}
四、实验过程及结果截图。

相关文档
最新文档