二叉树实验报告

合集下载

实验报告二叉树

实验报告二叉树
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);

实验报告:二叉树

实验报告:二叉树

实验报告:二叉树第一篇:实验报告:二叉树实验报告二叉树一实验目的1、进一步掌握指针变量,动态变量的含义;2、掌握二叉树的结构特性以及各种存储结构的特点及适用范围。

3、掌握用指针类型描述、访问和处理二叉树的运算。

4、熟悉各种存储结构的特征以及如何应用树结构解决具体问题。

二实验原理树形结构是一种应用十分广泛和重要的非线性数据结构,是一种以分支关系定义的层次结构。

在这种结构中,每个数据元素至多只有一个前驱,但可以有多个后继;数据元素之间的关系是一对多的层次关系。

树形结构主要用于描述客观世界中具有层次结构的数据关系,它在客观世界中大量存在。

遍历二叉树的实质是将非线性结构转为线性结构。

三使用仪器,材料计算机 2 Wndows xp 3 VC6.0四实验步骤【问题描述】建立一个二叉树,请分别按前序,中序和后序遍历该二叉树。

【基本要求】从键盘接受输入(按前序顺序),以二叉链表作为存储结构,建立二叉树(以前序来建立),并采用递归算法对其进行前序,中序和后序遍历,将结果输出。

【实现提示】按前序次序输入二叉树中结点的值(一个整数),0表示空树,叶子结点的特征是其左右孩子指针为空。

五实验过程原始记录基本数据结构描述; 2 函数间的调用关系;用类C语言描述各个子函数的算法;附录:源程序。

六试验结果分析将实验结果分析、实验中遇到的问题和解决问题的方法以及关于本实验项目的心得体会,写在实验报告上。

第二篇:数据结构-二叉树的遍历实验报告实验报告课程名:数据结构(C语言版)实验名:二叉树的遍历姓名:班级:学号:时间:2014.11.03一实验目的与要求1.掌握二叉树的存储方法2.掌握二叉树的三种遍历方法3.实现二叉树的三种遍历方法中的一种二实验内容• 接受用户输入一株二叉树• 输出这株二叉树的前根, 中根, 后根遍历中任意一种的顺序三实验结果与分析//*********************************************************** //头文件#include #include //*********************************************************** //宏定义#define OK 1 #define ERROR 0 #define OVERFLOW 0//*********************************************************** typedef struct BiTNode { //二叉树二叉链表存储结构char data;struct BiTNode *lChild,*rChild;}BiTNode,*BiTree;//******************************** *************************** int CreateBiTree(BiTree &T){ //按先序次序输入二叉中树结点的值,空格表示空树//构造二叉链表表示的二叉树T char ch;fflush(stdin);scanf(“%c”,&ch);if(ch==' ')T=NULL;else{ if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))return(OVERFLOW);T->data=ch;Creat eBiTree(T->lChild);CreateBiTree(T->rChild);} return(OK);} //********************************************************* void PreOrderTraverse(BiTree T){ //采用二叉链表存储结构,先序遍历二叉树的递归算法if(T){ printf(“%c”,T->data);PreOrderTraverse(T->lChild);PreOrd erTraverse(T->rChild);} } /***********************************************************/ void InOrderTraverse(BiTree T){ //采用二叉链表存储结构,中序遍历二叉树的递归算法if(T){ InOrderTraverse(T->lChild);printf(“%c”,T->data);InOrderT raverse(T->rChild);} }//*********************************************************** void PostOrderTraverse(BiTree T){ //采用二叉链表存储结构,后序遍历二叉树的递归算法if(T){ PostOrderTraverse(T->lChild);PostOrderTraverse(T->rChild) ;printf(“%c”,T->data);} }//*********************************************************** void main(){ //主函数分别实现建立并输出先、中、后序遍历二叉树printf(“please input your tree follow the PreOrder:n”);BiTNode *Tree;CreateBiTree(Tree);printf(“n先序遍历二叉树:”);PreOrderTraverse(Tree);printf(“n中序遍历二叉树:”);InOrderTraverse(Tree);printf(“n后序遍历二叉树:”);PostOrderTraverse(Tree);}图1:二叉树的遍历运行结果第三篇:数据结构二叉树操作验证实验报告班级:计算机11-2 学号:40 姓名:朱报龙成绩:_________实验七二叉树操作验证一、实验目的⑴ 掌握二叉树的逻辑结构;⑵ 掌握二叉树的二叉链表存储结构;⑶ 掌握基于二叉链表存储的二叉树的遍历操作的实现。

二叉排序树的实验报告

二叉排序树的实验报告

二叉排序树的实验报告二叉排序树的实验报告引言:二叉排序树(Binary Search Tree,简称BST)是一种常用的数据结构,它将数据按照一定的规则组织起来,便于快速的查找、插入和删除操作。

本次实验旨在深入了解二叉排序树的原理和实现,并通过实验验证其性能和效果。

一、实验背景二叉排序树是一种二叉树,其中每个节点的值大于其左子树的所有节点的值,小于其右子树的所有节点的值。

这种特性使得在二叉排序树中进行查找操作时,可以通过比较节点的值来确定查找的方向,从而提高查找效率。

二、实验目的1. 理解二叉排序树的基本原理和性质;2. 掌握二叉排序树的构建、插入和删除操作;3. 验证二叉排序树在查找、插入和删除等操作中的性能和效果。

三、实验过程1. 构建二叉排序树首先,我们需要构建一个空的二叉排序树。

在构建过程中,我们可以选择一个节点作为根节点,并将其他节点插入到树中。

插入节点时,根据节点的值与当前节点的值进行比较,如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。

重复这个过程,直到所有节点都被插入到树中。

2. 插入节点在已有的二叉排序树中插入新的节点时,我们需要遵循一定的规则。

首先,从根节点开始,将新节点的值与当前节点的值进行比较。

如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。

如果新节点的值与当前节点的值相等,则不进行插入操作。

3. 删除节点在二叉排序树中删除节点时,我们需要考虑不同的情况。

如果要删除的节点是叶子节点,即没有左右子树,我们可以直接删除该节点。

如果要删除的节点只有一个子树,我们可以将子树连接到要删除节点的父节点上。

如果要删除的节点有两个子树,我们可以选择将其右子树中的最小节点或左子树中的最大节点替代该节点,并删除相应的替代节点。

四、实验结果通过对二叉排序树的构建、插入和删除操作的实验,我们得到了以下结果:1. 二叉排序树可以高效地进行查找操作。

二叉树的建立和遍历的实验报告doc

二叉树的建立和遍历的实验报告doc

二叉树的建立和遍历的实验报告篇一:二叉树的建立及遍历实验报告实验三:二叉树的建立及遍历【实验目的】(1)掌握利用先序序列建立二叉树的二叉链表的过程。

(2)掌握二叉树的先序、中序和后序遍历算法。

【实验内容】1. 编写程序,实现二叉树的建立,并实现先序、中序和后序遍历。

如:输入先序序列abc###de###,则建立如下图所示的二叉树。

并显示其先序序列为:abcde中序序列为:cbaed后序序列为:cbeda【实验步骤】1.打开VC++。

2.建立工程:点File->New,选Project标签,在列表中选Win32 Console Application,再在右边的框里为工程起好名字,选好路径,点OK->finish。

至此工程建立完毕。

3.创建源文件或头文件:点File->New,选File标签,在列表里选C++ Source File。

给文件起好名字,选好路径,点OK。

至此一个源文件就被添加到了你刚创建的工程之中。

4.写好代码5.编译->链接->调试#include#include#define OK 1#define OVERFLOW -2typedef int Status;typedef char TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild, *rchild;}BiTNode,*BiTree;Status CreateBiTree(BiTree &T){TElemType ch;scanf("%c",&ch);if (ch=='#')T= NULL;else{if (!(T = (BiTNode *)malloc(sizeof(BiTNode))))return OVERFLOW;T->data = ch; CreateBiTree(T->lchild); CreateBiTree(T->rchild); }return OK;} // CreateBiTreevoid PreOrder(BiTree T) {if(T){printf("%c",T->data); PreOrder(T->lchild); PreOrder(T->rchild);}}void InOrder(BiTree T) {if(T){InOrder(T->lchild);printf("%c",T->data);InOrder(T->rchild);}}void PostOrder(BiTree T){if(T){PostOrder(T->lchild); PostOrder(T->rchild);printf("%c",T->data);}}void main(){BiTree T;CreateBiTree(T);printf("\n先序遍历序列:"); PreOrder(T);printf("\n中序遍历序列:"); InOrder(T);printf("\n后序遍历序列:"); PostOrder(T);}【实验心得】这次实验主要是通过先序序列建立二叉树,和二叉树的先序、中序、后续遍历算法。

二叉树遍历的实习报告

二叉树遍历的实习报告

实习报告实习内容:二叉树遍历实习时间:2023实习单位:某高校计算机实验室一、实习目的本次实习的主要目的是通过实现二叉树的遍历,加深对二叉树数据结构的理解,掌握二叉树的常见操作,提高编程能力。

二、实习内容1. 理解二叉树的基本概念和性质,包括节点之间的关系、树的深度、高度等。

2. 掌握二叉树的存储结构,包括顺序存储和链式存储。

3. 实现二叉树的前序遍历、中序遍历和后序遍历。

4. 通过实际编程,验证二叉树遍历的正确性。

三、实习过程1. 二叉树的基本概念和性质:二叉树是一种非线性的数据结构,每个节点最多有两个子节点。

节点之间的关系包括父子关系、兄弟关系等。

树的深度是指从根节点到最远叶子节点的最长路径上的边数,高度是指从根节点到最远叶子节点的最长路径上的边数加1。

2. 二叉树的存储结构:二叉树可以用顺序存储结构或链式存储结构表示。

顺序存储结构使用数组来实现,每个节点存储在数组的一个位置中,节点之间的父子关系通过数组下标来表示。

链式存储结构使用链表来实现,每个节点包含数据域和两个指针域,分别指向左子节点和右子节点。

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

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

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

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

后序遍历是指先递归遍历左子树,然后递归遍历右子树,最后访问根节点。

4. 编程实现:根据二叉树的存储结构和遍历方法,编写C语言程序实现二叉树的前序遍历、中序遍历和后序遍历。

程序中使用递归函数来实现遍历操作,通过建立链式存储结构,验证遍历的正确性。

四、实习心得通过本次实习,我对二叉树的数据结构有了更深入的了解,掌握了二叉树的存储方式和常见操作。

在实现二叉树遍历的过程中,我学会了如何使用递归函数解决问题,提高了编程能力。

同时,通过实际编程验证了二叉树遍历的正确性,增强了对算法理解的信心。

二叉树实验报告

二叉树实验报告

二叉树实验报告二叉树是数据结构中最常见且重要的一种类型。

它由节点组成,每个节点最多有两个子节点,分别称为左节点和右节点。

通过连接这些节点,可以构建一个有序且具有层次结构的树形结构。

本实验报告将介绍二叉树的概念、特点以及常见的操作,同时介绍二叉树在实际应用中的一些典型案例。

一、二叉树的定义和特点二叉树是一种树形结构,它的每个节点至多只有两个子节点。

它的定义可以使用递归的方式进行描述:二叉树要么是一棵空树,要么由根节点和两棵分别称为左子树和右子树的二叉树组成。

二叉树的特点是每个节点最多只有两个子节点。

二、二叉树的创建和操作1.创建二叉树:二叉树可以通过两种方式来创建,一种是使用树的节点类来手动构建二叉树;另一种是通过给定的节点值列表,使用递归的方式构建二叉树。

2.遍历二叉树:二叉树的遍历有三种方式,分别是前序遍历、中序遍历和后序遍历。

a.前序遍历:先遍历根节点,再遍历左子树,最后遍历右子树。

b.中序遍历:先遍历左子树,再遍历根节点,最后遍历右子树。

c.后序遍历:先遍历左子树,再遍历右子树,最后遍历根节点。

3.查找节点:可以根据节点的值或者位置来查找二叉树中的节点。

4.插入节点:可以通过递归的方式在指定位置上插入一个新节点。

5.删除节点:可以通过递归的方式删除二叉树中的指定节点。

三、二叉树的应用案例二叉树在实际应用中有很多重要的用途,下面介绍几个典型的案例。

1.表示文件系统结构:文件系统可以使用二叉树来进行表示,每个文件或文件夹都可以看作是树中一个节点,节点之间的父子关系可以通过左右子树建立连接。

2.实现二叉树:二叉树是一种特殊的二叉树,它要求左子树上的节点值小于根节点的值,右子树上的节点值大于根节点的值。

这种树结构可以快速实现元素的插入、删除和查找等操作。

3.表达式求值:二叉树可以用来表示数学表达式,并且可以通过遍历来对表达式进行求值。

四、实验总结通过本次实验,我们深入了解了二叉树的定义和特点,学会了二叉树的创建和操作方法,以及了解了二叉树在实际应用中的一些典型案例。

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

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

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

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

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

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

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

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

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

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

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

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

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

实验报告平衡二叉树

实验报告平衡二叉树

实习报告一、需求分析1、问题描述利用平衡二叉树实现一个动态查找表。

(1)实现动态查找表的三种基本功能:查找、插入和删除。

(2)初始时,平衡二叉树为空树,操作界面给出查找、插入和删除三种操作供选择。

每种操作均要提示输入关键字。

在查找时,如果查找的关键字不存在,则把其插入到平衡二叉树中。

每次插入或删除一个结点后,应更新平衡二叉树的显示。

(3)每次操作的关键字都要从文件中读取,并且关键字的集合限定为短整型数字{1,2,3······},关键字出现的顺序没有限制,允许出现重复的关键字,并对其进行相应的提示。

(4)平衡二叉树的显示采用图形界面画出图形。

2、系统功能打开数据文件,用文件中的关键字来演示平衡二叉树操作的过程。

3、程序中执行的命令包括:(1)(L)oad from data file //在平衡的二叉树中插入关键字;(2)(A)ppend new record //在平衡的二叉树中查找关键字;(3)(U)pate special record //显示调整过的平衡二叉树;(4)(D)elete special record //删除平衡二叉树中的关键字;(5)(Q)uit //结束。

4、测试数据:平衡二叉树为:图 1 插入关键字10之前的平衡二叉树插入关键字:10;调整后:图 2 插入关键字10之后的平衡二叉树删除关键字:14;调整后:图 3 删除关键字14后的平衡二叉树查找关键字:11;输出:The data is here!图 3 查找关键字11后的平衡二叉树二、概要设计本次实验目的是为了实现动态查找表的三种基本功能:查找、插入和删除。

动态查找表可有不同的表示方法,在此次实验中主要是以平衡二叉树的结构来表示实现的,所以需要两个抽象数据类型:动态查找表和二叉树。

1、动态查找表的抽象数据类型定义为:ADT DynamicSearchTable{数据对象D :D是具有相同特性的数据元素的集合。

二叉树 实验报告

二叉树 实验报告

二叉树实验报告二叉树实验报告引言:二叉树是一种常见的数据结构,它由节点和边组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。

在本次实验中,我们将探索二叉树的基本概念、特性以及应用。

一、二叉树的定义与性质1.1 二叉树的定义二叉树是一种递归定义的数据结构,它可以为空,或者由一个根节点和两个二叉树组成,分别称为左子树和右子树。

1.2 二叉树的性质(1)每个节点最多有两个子节点,分别称为左子节点和右子节点。

(2)左子树和右子树也是二叉树。

(3)二叉树的子树之间没有关联性,它们是相互独立的。

二、二叉树的遍历方式2.1 前序遍历前序遍历是指先访问根节点,然后按照先左后右的顺序遍历左子树和右子树。

2.2 中序遍历中序遍历是指先遍历左子树,然后访问根节点,最后遍历右子树。

2.3 后序遍历后序遍历是指先遍历左子树,然后遍历右子树,最后访问根节点。

2.4 层次遍历层次遍历是指按照从上到下、从左到右的顺序遍历二叉树的每个节点。

三、二叉树的应用3.1 二叉搜索树二叉搜索树是一种特殊的二叉树,它的每个节点的值大于其左子树的所有节点的值,小于其右子树的所有节点的值。

这种特性使得二叉搜索树可以高效地进行查找、插入和删除操作。

3.2 哈夫曼树哈夫曼树是一种带权路径长度最短的二叉树,它常用于数据压缩中。

哈夫曼树的构建过程是通过贪心算法,将权值较小的节点放在离根节点较远的位置,从而实现最优编码。

3.3 表达式树表达式树是一种用于表示数学表达式的二叉树,它的叶节点是操作数,而非叶节点是操作符。

通过对表达式树的遍历,可以实现对表达式的求值。

结论:通过本次实验,我们对二叉树的定义、性质、遍历方式以及应用有了更深入的了解。

二叉树作为一种重要的数据结构,在计算机科学和算法设计中发挥着重要的作用。

在今后的学习和工作中,我们应该进一步探索二叉树的高级应用,并灵活运用于实际问题的解决中。

二叉树实验报告

二叉树实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

二叉树实验总结

二叉树实验总结

二叉树实验总结二叉树是计算机科学中一种重要的数据结构,具有广泛的应用。

通过对二叉树的实验总结,我深刻认识到了二叉树的特点、操作和应用。

在本文中,我将分享我对二叉树的实验总结,并提供一些示例来说明其应用。

二叉树是由节点组成的树状结构,每个节点最多有两个子节点。

二叉树的特点之一是其高度平衡,这意味着树的左子树和右子树的高度差不超过一。

这种平衡性使得二叉树在搜索和排序等操作中具有较高的效率。

在实验中,我学习了二叉树的基本操作,包括插入、删除和搜索。

插入操作将一个新节点添加到树中的适当位置,删除操作将指定节点从树中移除,而搜索操作则用于查找指定值的节点。

这些操作的实现依赖于二叉树的特性,例如根节点比左子树的任何节点大,比右子树的任何节点小。

除了基本操作,二叉树还具有其他一些重要的属性和应用。

其中之一是二叉查找树(Binary Search Tree,BST),它是一种特殊的二叉树,其中每个节点的值都大于其左子节点的值,小于其右子节点的值。

BST可以用于高效地进行搜索和排序操作。

例如,我们可以使用BST来实现一个字典,通过快速查找实现单词的翻译或定义。

二叉树还可以用于构建表达式树,这是一种用于存储和计算数学表达式的数据结构。

在表达式树中,每个节点都表示一个操作符或操作数,而子节点则表示操作符的操作数。

通过遍历表达式树,我们可以轻松地进行数学表达式的计算。

例如,对于表达式“(2 + 3)* 4”,构建的表达式树如下所示:*/ \+ 4/ \2 3通过对表达式树的后序遍历,我们可以得到计算结果为20。

除了上述应用,二叉树还可以用于构建哈夫曼树(Huffman Tree),这是一种用于数据压缩的树状结构。

哈夫曼树通过将频率较高的字符表示为较短的编码,而将频率较低的字符表示为较长的编码,从而实现数据的高效压缩。

这种压缩方法广泛应用于文件压缩、图像压缩和音频压缩等领域。

通过这些实验,我对二叉树有了更深入的了解。

我能够理解二叉树的特点、操作和应用,并能够在实际问题中灵活应用。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

二叉树操作实验报告

二叉树操作实验报告

二叉树操作实验报告一、实验背景二叉树是一种常用的数据结构,它由节点和连接节点的边组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。

在二叉树的操作中,常用的操作包括创建二叉树、插入节点、删除节点、查找节点、遍历等。

本次实验旨在通过对二叉树的操作,加强对二叉树数据结构的理解,并熟练掌握其操作方法。

二、实验目的1.掌握二叉树的创建方法,能够编写代码创建一个二叉树;2.了解二叉树的插入节点操作,掌握节点的插入方法;3.掌握二叉树的删除节点操作,了解节点删除的细节和方法;4.熟练掌握二叉树的查找节点操作;5.掌握二叉树的遍历方法,能够实现对二叉树的前序、中序、后序、层次遍历。

三、实验原理1.二叉树的创建方法:通过递归的方式,先创建根节点,再依次创建左子树和右子树;2.二叉树的插入节点操作:从根节点开始,根据节点值的大小关系,将待插入节点放到适当的位置;3.二叉树的删除节点操作:首先查找待删除的节点,然后根据其子节点的情况,进行相应的删除处理;4.二叉树的查找节点操作:从根节点开始遍历,根据节点值的大小关系,在左子树或右子树中继续查找,直到找到目标节点或遍历到叶子节点;5.二叉树的遍历方法:前序遍历先访问根节点,再遍历左子树和右子树;中序遍历先遍历左子树,再访问根节点和右子树;后序遍历先遍历左子树和右子树,再访问根节点;层次遍历按层次逐个访问节点。

四、实验过程1.创建二叉树:首先,定义二叉树的节点类,包含节点值和左右子节点;然后,通过递归的方式创建根节点、左子树和右子树。

2.插入节点:要插入一个节点,首先需要找到插入位置。

如果待插入节点大于当前节点的值,则插入到右子树中,否则插入到左子树中。

如果节点为空,则表示找到了插入位置。

3.删除节点:删除节点有以下几种情况:(1) 待删除节点为叶子节点:直接删除即可;(2) 待删除节点只有一个子节点:用子节点替换待删除节点的位置;(3) 待删除节点有两个子节点:找到待删除节点的后继节点(右子树的最左下角节点),用后继节点替换待删除节点的位置。

数据结构二叉树遍历实验报告

数据结构二叉树遍历实验报告

数据结构二叉树遍历实验报告正文:1.实验目的本实验旨在实现二叉树的四种遍历方式:前序遍历、中序遍历、后序遍历和层次遍历,并对其进行验证和性能评估。

2.实验原理2.1 二叉树的定义二叉树是一种特殊的树状结构,其中每个节点最多有两个子节点,分别称为左子节点和右子节点。

2.2 二叉树的遍历方式2.2.1 前序遍历前序遍历的顺序是先访问根节点,然后递归地遍历左子树和右子树。

2.2.2 中序遍历中序遍历的顺序是先递归地遍历左子树,然后访问根节点,最后递归地遍历右子树。

2.2.3 后序遍历后序遍历的顺序是先递归地遍历左子树和右子树,最后访问根节点。

2.2.4 层次遍历层次遍历按照二叉树的层次从上到下、从左到右的顺序遍历节点。

3.实验内容3.1 实现二叉树的数据结构首先,我们需要定义二叉树的数据结构。

二叉树节点应包含键值和左右子节点的指针。

3.2 实现二叉树的各种遍历方式接下来,我们实现四种遍历方式:前序遍历、中序遍历、后序遍历和层次遍历。

针对每种遍历方式,编写相应的算法实现逻辑。

3.3 实验验证和性能评估使用已实现的算法,对一棵二叉树进行各种遍历方式操作,并将结果输出。

验证输出结果与预期结果是否一致。

同时,记录每种遍历方式的算法时间复杂度和空间复杂度,并进行性能评估。

4.实验结果与分析对于给定的二叉树,分别进行了前序遍历、中序遍历、后序遍历和层次遍历操作,并得到了相应的输出结果。

结果与预期相符。

通过对算法的时间复杂度和空间复杂度的计算和分析,可以看出各种遍历方式的效率和资源消耗情况。

5.结论本实验成功实现了二叉树的四种遍历方式,并验证了其正确性。

同时,对这些遍历方式的性能进行了评估,为后续使用二叉树进行数据操作提供了参考。

附件:无法律名词及注释:- N/A。

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

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

宁波工程学院电信学院计算机教研室实验报告一、实验目的1、熟悉二叉树树的基本操作。

2、掌握二叉树的实现以及实际应用。

3、加深二叉树的理解,逐步培养解决实际问题的编程能力。

二、实验环境1台WINDOWS环境的PC机,装有Visual C++ 6.0。

三、实验内容【问题描述】现需要编写一套二叉树的操作函数,以便用户能够方便的利用这些函数来实现自己的应用。

其中操作函数包括: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)【基本要求】实现以上9个函数。

主函数中实现以下功能:创建下图中的树b输出二叉树b找到’H’节点,输出其左右孩子值输出b的高度输出b的节点个数输出b的四种遍历顺序上图转化为二叉树括号表示法为A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))程序:#include <stdio.h>#include <malloc.h>#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");}四、实验心得与小结通过实验,我熟悉二叉树树的基本操作,掌握二叉树的实现以及实际应用。

数据结构实验报告—二叉树

数据结构实验报告—二叉树

数据结构实验报告—二叉树目录1. 引言1.1 背景1.2 目的2. 前期准备2.1 问题定义2.2 数据准备3. 算法设计3.1 插入节点3.2 删除节点3.3 查找节点3.4 遍历二叉树4. 实验过程4.1 实验环境4.2 实验步骤5. 实验结果与分析5.1 插入节点的结果 5.2 删除节点的结果 5.3 查找节点的结果5.4 遍历二叉树的结果6. 总结与讨论6.1 实验总结6.2 实验改进方向7. 结论8. 参考文献1. 引言1.1 背景介绍二叉树的概念和应用领域,以及在数据结构中的重要性。

1.2 目的明确本实验的目标,即设计一个能够实现插入、删除、查找和遍历二叉树的算法,并对其进行实验验证。

2. 前期准备2.1 问题定义对二叉树的基本操作进行定义,包括插入节点、删除节点、查找节点和遍历二叉树。

2.2 数据准备准备一组用于测试的数据集,包括插入节点、删除节点和查找节点时所需的数据。

3. 算法设计3.1 插入节点详细描述如何设计实现插入节点的算法,并分析算法的时间复杂度和空间复杂度。

3.2 删除节点详细描述如何设计实现删除节点的算法,并分析算法的时间复杂度和空间复杂度。

3.3 查找节点详细描述如何设计实现查找节点的算法,并分析算法的时间复杂度和空间复杂度。

3.4 遍历二叉树详细描述如何设计实现遍历二叉树的算法,并分析算法的时间复杂度和空间复杂度。

4. 实验过程4.1 实验环境描述实验所用的编程语言和相关工具的环境配置。

4.2 实验步骤详细描述实验的具体步骤,包括数据准备、算法实现、代码编写、实验运行和结果分析等。

5. 实验结果与分析5.1 插入节点的结果展示插入节点的实验结果,并对结果进行详细分析和讨论。

5.2 删除节点的结果展示删除节点的实验结果,并对结果进行详细分析和讨论。

5.3 查找节点的结果展示查找节点的实验结果,并对结果进行详细分析和讨论。

5.4 遍历二叉树的结果展示遍历二叉树的实验结果,并对结果进行详细分析和讨论。

二叉树的遍历实验报告(二)

二叉树的遍历实验报告(二)

二叉树的遍历实验报告(二)引言:本实验报告是对二叉树的遍历进行实验,并对实验结果进行分析和总结。

二叉树的遍历是指按照某种顺序遍历二叉树中的节点,分为三种遍历方式:前序遍历、中序遍历和后序遍历。

本实验通过设计并实现相应的算法,对三种遍历方式进行实验,并比较它们在不同情况下的效率和应用场景。

一、前序遍历1. 创建一个空栈,将二叉树的根节点压入栈中。

2. 当栈不为空时,执行以下操作:2.1 弹出栈顶节点,输出节点值。

2.2 若节点存在右子树,将右子树的根节点压入栈中。

2.3 若节点存在左子树,将左子树的根节点压入栈中。

3. 重复步骤2,直到栈为空。

二、中序遍历1. 创建一个空栈,并将二叉树的根节点置为当前节点。

2. 当栈不为空或当前节点不为空时,执行以下操作:2.1 若当前节点不为空,将当前节点入栈,并将当前节点指向其左子节点。

2.2 若当前节点为空,弹出栈顶节点并输出节点值,将当前节点指向其右子节点。

3. 重复步骤2,直到栈为空且当前节点为空。

三、后序遍历1. 创建两个栈,分别为stack1和stack2。

将二叉树的根节点压入stack1中。

2. 当stack1不为空时,执行以下操作:2.1 弹出stack1的栈顶节点,并将该节点压入stack2中。

2.2 若节点存在左子树,将左子树的根节点压入stack1中。

2.3 若节点存在右子树,将右子树的根节点压入stack1中。

3. 当stack1为空时,执行以下操作:3.1 弹出stack2的栈顶节点并输出节点值。

4. 重复步骤2和3,直到stack1和stack2均为空。

四、效率比较1. 前序遍历的时间复杂度为O(n),其中n为二叉树的节点数量。

2. 中序遍历的时间复杂度为O(n)。

3. 后序遍历的时间复杂度为O(n)。

4. 从时间复杂度上看,三种遍历方式的效率相同。

5. 从实际使用场景上看,前序遍历适合用于打印二叉树的结构、以及复制整棵树等;中序遍历适合用于查找二叉搜索树中的某个值;后序遍历适合用于计算二叉树中节点的高度或深度等。

二叉树实验报告总结(共10篇)

二叉树实验报告总结(共10篇)

二叉树实验报告总结(共10篇)二叉树实验报告实验报告课程名称算法与数据结构专业学号姓名实验日期算法与数据结构实验报告一、实验目的1.了解二叉树的结构特点及有关概念,掌握二叉树建立的基本算法2.了解二叉树遍历的概念,掌握遍历二叉的算法3.进一步掌握树的结构及非线性特点,递归特点和动态性。

二、实验内容二叉树的实现和运算三、实验要求1.用C++/C完成算法设计和程序设计并上机调试通过。

2.撰写实验报告,提供实验结果和数据。

3.分析算法,并简要给出算法设计小结和心得。

四、算法步骤用户以三元组形式输入二叉树的结点元素及其位置关系,建立二叉树,并打印输出该二叉树。

用户输入选择结点,程序调用BiTNode* Find Node(char tag, BiTNode* node)函数,返回子树的根结点,然后调用BiTreeDepth(BiTree T)函数,求出子树的深度,并输出该值。

3.用户可以选择是否继续执行程序,若继续,则输入1,否则输入0,结束程序。

五、主程序代码:int main(void){BiTree T;TElemType e1;char node; // node为用户选择输入的结点//int b,choose; // b为以选定结点为子树的深度,choose为实现多次选择输入的标志//BiTNode* a; // a为选定结点为子树的根结点//choose=1; // 多次选择的标志,当choose为1时运行程序,为0时结束程序// InitBiTree(T);printf(构造空二叉树后,树空否?%d(1:是0:否), 树的深度=%d\n,BiTreeEmpty(T),BiTreeDepth(T));e1 = Root(T);if(e1 != Nil)#ifdef CHARprintf(二叉树的根为: %c\n,e1);#endif#ifdef INTprintf(二叉树的根为: %d\n,e1);#endifelseprintf(树空,无根\n); //三元组构建二叉树striile(x!=end){AddNode(T, x[0], x[1], x[2]);GetUserWord(x);} //输出树PrintTreeLevel( T );//以三元组形式输入任意二叉树(以大写字母表示结点),求以任意一选定结点为子树的深度。

二叉排序树实验报告

二叉排序树实验报告

二叉排序树实验报告二叉排序树实验报告一、引言二叉排序树,也被称为二叉搜索树,是一种常见的数据结构,它具有快速的查找和插入操作的特点。

在本次实验中,我们将探索二叉排序树的原理和实现,并通过实际操作来验证其性能和效果。

二、实验目的本次实验的目的是通过实际操作,深入理解二叉排序树的原理和实现,并通过对比不同操作的时间复杂度,评估其性能和效果。

三、实验过程1. 实验环境的搭建在开始实验之前,我们需要搭建一个合适的实验环境。

我们可以选择使用C++或者其他编程语言来实现二叉排序树。

在本次实验中,我们选择使用C++来实现。

2. 二叉排序树的实现首先,我们需要定义一个二叉排序树的数据结构。

这个数据结构包含一个根节点,每个节点包含一个值和两个指针,分别指向左子树和右子树。

通过递归的方式,我们可以实现二叉排序树的插入、删除和查找操作。

3. 实验数据的准备为了验证二叉排序树的性能和效果,我们需要准备一组实验数据。

这组数据可以是随机生成的整数,也可以是具有特定规律的数据。

我们可以选择不同规模的数据集来进行实验,以评估二叉排序树在不同情况下的表现。

4. 实验操作的执行通过实验数据的准备,我们可以开始执行实验操作。

首先,我们将数据依次插入到二叉排序树中,并记录下插入操作的时间。

然后,我们可以执行查找操作,查找树中是否包含某个特定的值,并记录下查找操作的时间。

最后,我们可以执行删除操作,删除树中的某个节点,并记录下删除操作的时间。

5. 实验结果的分析通过实验操作的执行,我们可以得到一组实验结果。

我们可以通过对比不同操作的时间复杂度,来评估二叉排序树的性能和效果。

同时,我们还可以观察实验结果中树的结构,以验证二叉排序树的正确性。

四、实验结果与讨论通过实验操作的执行,我们得到了一组实验结果。

我们可以观察到,随着数据规模的增加,插入、查找和删除操作的时间逐渐增加。

这是因为二叉排序树的操作时间复杂度与树的高度相关,当树的高度增加时,操作的时间复杂度也会增加。

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

实验报告
一、实验目的
1.掌握二叉树的结构特性。

2.熟悉二叉树的各种存储结构的特点及应用范围。

3.学会编写实现树的各种操作的算法。

二、实验要求
实现二叉树的基本运算,编写一个程序实现以下功能;
1.先序递归遍历二叉树
2.先序非递归遍历二叉树
3.中序递归遍历二叉树
4.中序非递归遍历二叉树
5.子叶个数
6.结点个数
三、实验分析
抽象数据类型
ADT Tree
{
数据对象D:D是具有相同特性的数据元素的集合。

数据关系R:若D为空集,则称为空树。

基本操作;
void CreateBTNode()
创建二叉树
void DispBTNode()
输出二叉树
void PreOrder()
先序递归遍历输出二叉树
void PreOrder2()
先序非递归遍历输出二叉树
void InOrder()
中序递归遍历输出二叉树
void InOrder1()
中序非递归遍历输出二叉树
int Nodes()
求二叉树的结点个数
int LeafNodes()
求二叉树的叶子结点个数
四、功能代码
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 PreOrder(BTNode *b)
{
if (b!=NULL)
{
printf("%c ",b->data); //访问根结点
PreOrder(b->lchild); //递归访问左子树
PreOrder(b->rchild); //递归访问右子树
}
}
void PreOrder2(BTNode *b)
{
BTNode *St[MaxSize],*p;
int top=-1;
if (b!=NULL)
{
top++; //根结点入栈/
St[top]=b;
while (top>-1) //栈不为空时循环
{
p=St[top]; //退栈并访问该结点
top--;
printf("%c ",p->data);
if (p->rchild!=NULL) //右孩子入栈
{
top++;
St[top]=p->rchild;
}
if (p->lchild!=NULL) //左孩子入栈
{
top++;
St[top]=p->lchild;
}
}
printf("\n");
}
}
void InOrder(BTNode *b) //中序遍历的递归遍历{
if (b!=NULL)
{
InOrder(b->lchild); //递归访问左子树
printf("%c ",b->data); //访问根结点
InOrder(b->rchild); //递归访问右子树}
}
void InOrder1(BTNode *b)//中序非递归遍历
{
BTNode *p;
struct
{
BTNode *pt;
int tag;
} St[MaxSize];
int top=-1;
top++;
St[top].pt=b;St[top].tag=1;
while (top>-1) //栈不空时循环
{
if (St[top].tag==1) //不能直接访问的情况
{
p=St[top].pt;
top--;
if (p!=NULL)
{
top++; //右孩子进栈
St[top].pt=p->rchild;
St[top].tag=1;
top++; //根结点进栈
St[top].pt=p;
St[top].tag=0;
top++; //左孩子进栈
St[top].pt=p->lchild;
St[top].tag=1;
}
}
if (St[top].tag==0) //直接访问的情况
{
printf("%c ",St[top].pt->data);
top--;
}
}
}
int Nodes(BTNode *b) //求二叉树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);
int i;
i= (num1+num2+1);
printf("%d",i);
}
}
int LeafNodes(BTNode *b) //求二叉树b的叶子结点个数{
int num1,num2;
if (b==NULL)
return 0;
else if (b->lchild==NULL && b->rchild==NULL)
return 1;
else
{
num1=LeafNodes(b->lchild);
num2=LeafNodes(b->rchild);
int i;
i = (num1+num2);
printf("%d",i);
}
}
五、调试分析
初始定义数据元素时重写类型导致错误。

在运行个别函数时不能调用,显示参数错误。

碰到定义表长过小,记录冲突次数、处理记录数据错误时程序的异常。

六、运行结果。

相关文档
最新文档