C++二叉树的创建与遍历实验报告

合集下载

二叉树的建立与遍历实验报告(c语言编写,附源代码)

二叉树的建立与遍历实验报告(c语言编写,附源代码)

二叉树的建立与遍历实验报告(c语言编写,附源代码)二叉树的建立与遍历实验报告级班年月日姓名学号_1.实验题目建立一棵二叉树,并对其进行遍历(先序、中序、后序),打印输出遍历结果。

2.需求分析本程序用VC编写,实现建立一棵二叉树的功能,并对其进行遍历(先序、中序、后序),并且打印输出遍历结果。

①输入的形式和输入值的范围:输入二叉树的先序,当其结点为空时,需要输入#。

(输入的先序仅含字母和#)②输出的形式:输出二叉树的先序、中序、后序。

③程序所能达到的功能:实现建立一棵二叉树的功能,并对其进行遍历(先序、中序、后序),并且打印输出遍历结果。

④测试数据:输入数据:输入ABC##DE#G##F###输出结果:二叉树的先序遍历为:ABCDEGF二叉树的中序遍历为:CBEGDFA二叉树的后序遍历为:CGEFDBA3.概要设计1)为了实现上述程序功能,需要定义二叉链表的抽象数据类型:typedef struct BinaryTreeNode{TElemType data;//二叉树结点中的数据域struct BinaryTreeNode *lchild , *rchild; //二叉树结点的左孩子和右孩子指针}BinaryTreeNode ,*BiTree;基本操作:A.void CreateBinaryTree (BiTree &T)初始条件:无操作结果:建立了二叉树。

B. void PreOrder(BiTree T)初始条件:存在一棵二叉树操作结果:先序遍历二叉树,并且输出先序遍历的结果。

C. void MidOrder(BiTree T)初始条件:存在一棵二叉树操作结果:中序遍历二叉树,并且输出中序遍历的结果。

D. void PostOrder(BiTree T)初始条件:存在一棵二叉树操作结果:后序遍历二叉树,并且输出后序遍历的结果。

程序包含5个函数:○1主函数main()○2先序建立二叉树 void CreateBinaryTree (BiTree &T)○3先序遍历二叉树,并且输出先序遍历的结果void PreOrder(BiTree T);○4中序遍历二叉树,并且输出中序遍历的结果void MidOrder(BiTree T);○5序遍历二叉树,并且输出后序遍历的结果void PostOrder(BiTree T); 各函数间关系如下:主函数main()CreateBinaryTree PreOrder MidOrder PostOrder4.详细设计1)二叉链表的定义typedef struct BinaryTreeNode{定义一个树结点的数据域;定义一个该结点的左孩子指针和右孩子指针;}2)void CreateBinaryTree (BiTree &T)//先序建立二叉树{输入一个字符量;if(输入字符== '#') T指针置值为NULL;else{动态申请一个指向二叉树结构体的指针把输入字符赋值给新指针的数据域data;调用CreateBinaryTree(新指针的lchild成员);调用CreateBinaryTree(新指针的rchild成员);}}3)void PreOrder(BiTree T) //先序遍历二叉树{if(T指针不为NULL){输出T的data域;先序遍历左子树;先序遍历右子树;}}4)void MidOrder(BiTree T) //中序遍历二叉树{if(T指针不为NULL){中序遍历左子树;输出T的data域;中序遍历右子树;}}5)void PostOrder(BiTree T) //中序遍历二叉树{if(T指针不为NULL){后序遍历左子树;后序遍历右子树;输出T的data域;}}5.调试分析在编写程序过程中,我将scanf(”%c”,&ch)中的%c写成%d,程序运行了一段时间没有结果,经过检查,发现了这个错误。

【二叉树的建立和遍历实验报告】二叉树的遍历实验心得

【二叉树的建立和遍历实验报告】二叉树的遍历实验心得

【二叉树的建立和遍历实验报告】二叉树的遍历实验心得[题目] 建立二叉树并求指定结点路径、深度、叶子个数和左右子树交换。

[问题描述]要求能够按先序遍历次序输入二叉树中结点的值来构造二叉树T;然后用递归和非递归算法实现二叉树T 的中序遍历;接着编写算法实现求二叉树T中指定结点的路径,即从键盘输入二叉树T 的任一结点,可以输出从根结点到该结点所经历的结点;最后编写二叉树的三个应用算法(求二叉树的深度、求二叉树的叶子结点个数、将二叉树左右子树交换)。

[基本要求]分别建立二叉树存储结构的输入输出函数、输出中序遍历函数、指定节点路径函数、求深度函数、求叶子个数函数和将二叉树左右子树交换函数一、需求与规格说明1、定义二叉树的存储结构,每个结点中设置三个域,即值域、左指针域、右指针域。

要建立二叉树T的链式存储结构,即建立二叉链表。

根据输入二叉树结点的形式不同,建立的方法也不同,本系统采用先序序列递归建立二叉树,建立如下图所示的二叉树。

应该在程序运行窗口的主控菜单后,先选择“1”并回车,紧接着在程序运行窗口中提示信息“输入二叉树的先序序列结点值:”之后,采用以下字符序列:abc@@de@g@@f@@@ (以@替代空格,但是程序中直接输入空格就是,详细见代码注释)作为建立二叉树T的输入字符序列并回车,窗口出现:二叉树的链式存储结构建立完成!图1 二叉树的图形结构2、二叉树的遍历。

本系统采用非递归中序遍历算法进行中序遍历,这意味着遍历右子树时不再需要保存当前层的根指针,可直接修改栈顶记录中的指针即可。

需要在程序运行窗口的主控菜单中选择“2”并回车,程序运行窗口会出现以下中序遍历序列:该二叉树的中序遍历序列是: cbegdfa3、求二叉树的指定结点路径。

在程序运行窗口的主控菜单中选择“3”并回车,在程序运行窗口中提示信息“输入要求路径的结点值:”输入“g”并回车,会得到结果为:→a→b→d→e→g如果输入“i”并回车,会得到结果为:没有要求的结点!4、求二叉树的深度。

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

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

数据结构二叉树遍历实验报告数据结构二叉树遍历实验报告一、引言本文档旨在详细介绍二叉树遍历的实验过程和结果。

二叉树是一种在计算机科学领域常用的数据结构,通过遍历二叉树可以获取树中的所有节点数据。

本实验将分别介绍前序遍历、中序遍历和后序遍历这三种常见的遍历方法。

二、实验目的本实验的目的是通过实际操作,加深对二叉树遍历方法的理解,并验证这些遍历方法的正确性和效率。

三、实验环境本实验使用的环境如下:●操作系统: Windows 10●开发工具: Visual Studio Code●编程语言: C++四、实验步骤1.创建二叉树数据结构1.1 定义二叉树节点的结构,包含数据和左右子节点指针。

1.2 创建一个二叉树类,包含插入节点、删除节点、查找节点等方法。

1.3 使用已有的数据集构建二叉树,确保树的结构合理。

2.前序遍历前序遍历是先访问根节点,然后递归地遍历左子树和右子树。

2.1 以递归方式实现前序遍历。

2.2 以迭代方式实现前序遍历。

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

3.1 以递归方式实现中序遍历。

3.2 以迭代方式实现中序遍历。

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

4.1 以递归方式实现后序遍历。

4.2 以迭代方式实现后序遍历。

五、实验结果1.前序遍历结果:[节点1数据] [节点2数据] [节点4数据] [节点5数据] [节点3数据]2.中序遍历结果:[节点4数据] [节点2数据] [节点5数据] [节点1数据] [节点3数据]3.后序遍历结果:[节点4数据] [节点5数据] [节点2数据] [节点3数据] [节点1数据]六、实验分析通过实验结果可以看出,不同的遍历顺序得到的节点顺序也不同。

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

根据需要,可以选择合适的遍历方法来处理二叉树的节点数据。

七、结论本实验验证了前序遍历、中序遍历和后序遍历的正确性,并且对比了它们的不同。

二叉树的建立及其遍历实验报告

二叉树的建立及其遍历实验报告

数据结构实验报告———二叉树的建立及其遍历一、实验目的1、了解二叉树的建立的方法及其遍历的顺序,熟悉二叉树的三种遍历2、检验输入的数据是否可以构成一颗二叉树二、实验的描述和算法1、实验描述二叉树的建立首先要建立一个二叉链表的结构体,包含根节点和左右子树。

因为耳熟的每一个左右子树又是一颗二叉树,所以可以用递归的方法来建立其左右子树。

二叉树的遍历是一种把二叉树的每一个节点访问完并输出的过程,遍历时根结点与左右孩子的输出顺序构成了不同的遍历方法,这个过程需要按照不同的遍历的方法,先输出根结点还是先输出左右孩子,可以用选择语句实现。

2、算法#include <stdio.h>#include <stdlib.h>#define OVERFLOW 0#define OK 1#define ERROR 0typedef struct BiTNode {char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;BiTree CreateBiTree(BiTree T){scanf("%c",&e);if(e==' ') T=NULL;else {if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))exit(OVERFLOW);T->data=e;T->lchild=CreateBiTree(T->lchild);T->rchild=CreateBiTree(T->rchild);}return T; }/************************前序遍历***********************/ char PreOrderTraverse(BiTree T,char (* Visit)(char e)){if(T){if(Visit(T->data))if(PreOrderTraverse(T->lchild,Visit))if(PreOrderTraverse(T->rchild,Visit)) return OK;return ERROR;}else return OK;}char Visit(char e){printf("%5c",e);return OK;}main(){printf("请输入一颗二叉树,按回车结束:\n");T=CreateBiTree(T);printf("先序遍历的结果:");PreOrderTraverse(T,Visit);}三、调试分析在调这个程序是并没有遇到很大的困难,就是在输入一颗二叉树时,遇到了一点麻烦。

二叉树的建立和遍历的实验报告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);}【实验心得】这次实验主要是通过先序序列建立二叉树,和二叉树的先序、中序、后续遍历算法。

二叉树的遍历算法实验报告

二叉树的遍历算法实验报告

二叉树的遍历算法实验报告二叉树的遍历算法实验报告引言:二叉树是计算机科学中常用的数据结构之一,它是由节点组成的层次结构,每个节点最多有两个子节点。

在实际应用中,对二叉树进行遍历是一项重要的操作,可以帮助我们理解树的结构和节点之间的关系。

本文将介绍二叉树的三种遍历算法:前序遍历、中序遍历和后序遍历,并通过实验验证其正确性和效率。

一、前序遍历前序遍历是指先访问根节点,然后按照先左后右的顺序遍历左右子树。

具体的实现可以通过递归或者使用栈来实现。

我们以递归方式实现前序遍历算法,并进行实验验证。

实验步骤:1. 创建一个二叉树,并手动构造一些节点和它们之间的关系。

2. 实现前序遍历算法的递归函数,函数的输入为根节点。

3. 在递归函数中,首先访问当前节点,然后递归调用函数遍历左子树,最后递归调用函数遍历右子树。

4. 调用前序遍历函数,输出遍历结果。

实验结果:经过实验,我们得到了正确的前序遍历结果。

这证明了前序遍历算法的正确性。

二、中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。

同样,我们可以使用递归或者栈来实现中序遍历算法。

在本实验中,我们选择使用递归方式来实现。

实验步骤:1. 继续使用前面创建的二叉树。

2. 实现中序遍历算法的递归函数,函数的输入为根节点。

3. 在递归函数中,首先递归调用函数遍历左子树,然后访问当前节点,最后递归调用函数遍历右子树。

4. 调用中序遍历函数,输出遍历结果。

实验结果:通过实验,我们得到了正确的中序遍历结果。

这证明了中序遍历算法的正确性。

三、后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。

同样,我们可以使用递归或者栈来实现后序遍历算法。

在本实验中,我们选择使用递归方式来实现。

实验步骤:1. 继续使用前面创建的二叉树。

2. 实现后序遍历算法的递归函数,函数的输入为根节点。

3. 在递归函数中,首先递归调用函数遍历左子树,然后递归调用函数遍历右子树,最后访问当前节点。

4. 调用后序遍历函数,输出遍历结果。

二叉树遍历的实习报告

二叉树遍历的实习报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

二叉树遍历实验报告

二叉树遍历实验报告

1.实验题目二叉树的建立与遍历[问题描述]建立一棵二叉树,并对其进行遍历(先序、中序、后序),打印输出遍历结果。

2.需求分析(1)输入的形式和输入值的范围:以字符形式按先序遍历输入(2)输出的形式:依次按递归先序、中序、后序遍历,非递归先序、中序、后序遍历结果输出(3) 程序所能达到的功能:从键盘接受输入(先序)进行遍历(先序、中序、后序),将遍历结果打印输。

(4) 测试数据:ABCффDEфGффFффф(其中ф表示空格字符)则输出结果为先序:ABCDEGF中序:CBEGDFA后序:CGBFDBA3.概要设计(1)struct btnode{char data; 数据struct btnode *Lchild;左子数指针struct btnode *Rchild; 右子数指针};struct btnode *createbt(struct btnode *bt )初始条件:空二叉树存在操作结果:先序建立二叉树void preOrder(struct btnode *bt)初始条件:二叉树存在递归先序遍历二叉树void preOrder1(struct btnode *bt)初始条件:二叉树存在操作结果:非递归先序遍历void midOrder(struct btnode *bt)初始条件:二叉树存在操作结果:递归中序遍历void midOrder1(struct btnode *bt)初始条件:二叉树存在操作结果:非递归中序遍历void postOrder(struct btnode *bt)初始条件:二叉树存在操作结果:递归后序遍历void postOrder1 (struct btnode *bt)初始条件:二叉树存在操作结果:非递归后序遍历void main() 主函数(2)void main() 主函数{*createbtpreOrderpreOrder1midOrdermidOrder1postOrderpostOrder1}4.详细设计struct btnode{char data;struct btnode *Lchild;struct btnode *Rchild;};struct btnode *createbt(struct btnode *bt ){ 输入结点数据c检查存储空间将c赋给结点参数p递归建立左子树递归建立右子树}void preOrder(struct btnode *bt){判断树是否为空输出根结点数data递归遍历左子树递归遍历右子树}void preOrder1(struct btnode *bt){定义栈,结点参数pWhile(栈或p是否为空){While(p!=null){输出根结点数data将根结点压栈遍历左子树}提取栈顶元素值栈顶元素出栈访问右子树}void midOrder(struct btnode *bt){判断树是否为空递归遍历左子树输出根结点数data递归遍历右子树}void midOrder1(struct btnode *bt){定义栈,结点参数pWhile(栈或p是否为空){While(p!=null){将根结点压栈遍历左子树}提取栈顶元素值输出根结点数data栈顶元素出栈访问右子树}void postOrder(struct btnode *bt){判断树是否为空递归遍历左子树递归遍历右子树输出根结点数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);}5.调试分析(1)先序建立二叉树时,虽用到递归建左右子树,但没有把他们赋值给根节点的左右指针,造成二叉树脱节。

计算机软件实验报告(2)二叉树的建立与遍历

计算机软件实验报告(2)二叉树的建立与遍历

二叉树的建立与遍历一、实验目的进一步理解二叉树的逻辑结构和存储结构,掌握二叉树的建立与遍历算法。

二、实验内容1、用二叉链表创建二叉树①输入根结点值;②若左子树不空,则输入左子树,否则输入一个结束符;③若右子树不空,则输入右子树,否则输入一个结束符。

例如:FCA▲▲DB▲▲▲E▲GH▲▲P▲▲其中▲表示结束符2、遍历该二叉树(1) 先序遍历(DLR)若二叉树为空,则结束返回。

否则:①访问根结点;②先序遍历左子树;③先序遍历右子树。

(2) 中序遍历(LDR)若二叉树为空,则结束返回。

否则:①中序遍历左子树;②访问根结点;③中序遍历左子树。

(3) 后序遍历(LRD)若二叉树为空,则结束返回。

否则:①后序遍历左子树;②后序遍历左子树;③访问根结点。

实验思想:根据要求,输入二叉树各结点对应的编号和数值,建立一棵空树,存储相应数值并使左子树和右子树均为空树,根据计算,若编号为偶数则为左子树,若为奇数则为右子树。

最后遍历二叉树。

三、实验算法流程图与程序清单(一)二叉树的建立与先序遍历:1、算法流程图:2、实验清单:{char data;struct node1 *lchild,*rchild;}BTCHINALR;BTCHINALR * createbt( ){ BTCHINALR *q;struct node1 *s[30];int j,i,x;printf("建立二叉树,输入结点对应的编号和值,编号和值之间用逗号隔开\n\n");printf("i,x = ");scanf("%d,%c",&i,&x);while(i != 0 && x != '$'){q = (BTCHINALR*)malloc(sizeof(BTCHINALR));q->data = x; q->lchild = NULL; q->rchild = NULL;s[i] = q;if(i != 1){j = i / 2;if(i % 2 == 0) s[j]->lchild = q;else s[j]->rchild = q;}printf("i,x = ");scanf("%d,%c",&i,&x);}return s[1];}void inorder(BTCHINALR *bt){if(bt != NULL){ inorder(bt->lchild);printf("%c ",bt->data);inorder(bt->rchild); }}main( ){ BTCHINALR *bt;char ch;int i;bt = createbt(); i = 1;while(i) {printf("\n先序遍历二叉树(递归按y键,): ");fflush(stdin);scanf("%c",&ch);if(ch == 'y') inorder(bt);printf("\n");}3、实验结果:建立二叉树,输入结点对应的编号和值,编号和值之间用逗号隔开i,x = 1,li,x = 2,ki,x = 3,yi,x = 4,bi,x =5,si,x = 7,ci,x =11,vi,x = 15,ri,x = 0,$先序遍历二叉树(递归按y键,): yl k b s v y c r(二)、二叉树的建立与中序遍历:1、算法流程图:2、实验清单:{char data;struct node1 *lchild,*rchild;}BTCHINALR;BTCHINALR * createbt( ){ BTCHINALR *q;struct node1 *s[30];int j,i,x;printf("建立二叉树,输入结点对应的编号和值,编号和值之间用逗号隔开\n\n");printf("i,x = ");scanf("%d,%c",&i,&x);while(i != 0 && x != '$'){q = (BTCHINALR*)malloc(sizeof(BTCHINALR));q->data = x; q->lchild = NULL; q->rchild = NULL;s[i] = q;if(i != 1){j = i / 2;if(i % 2 == 0) s[j]->lchild = q;else s[j]->rchild = q;}printf("i,x = ");scanf("%d,%c",&i,&x);}return s[1];}void inorder(BTCHINALR *bt){if(bt != NULL){ inorder(bt->lchild);printf("%c ",bt->data);inorder(bt->rchild); }}main( ){ BTCHINALR *bt;char ch;int i;bt = createbt(); i = 1;while(i) {printf("\n先序遍历二叉树(递归按y键,): ");fflush(stdin);scanf("%c",&ch);if(ch == 'y') inorder(bt);printf("\n");}3、实验结果:建立二叉树,输入结点对应的编号和值,编号和值之间用逗号隔开i,x = 1,li,x = 2,ki,x = 3,yi,x = 4,bi,x =5,si,x = 7,ci,x =11,vi,x = 15,ri,x = 0,$先序遍历二叉树(递归按y键,): yl k b s v y c r四、实验心得体会通过这次实验,锻炼了自己编程的能力,加深了自己对有关知识的理解。

遍历二叉树实验报告

遍历二叉树实验报告

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

在实际应用中,对二叉树进行遍历是一项重要的操作。

本实验旨在通过实际操作,探索二叉树的遍历算法,并分析其时间复杂度和空间复杂度。

一、实验目的通过实际操作,掌握二叉树的前序遍历、中序遍历和后序遍历算法,并分析它们的特点和适用场景。

二、实验环境本实验使用C++语言进行编程,运行环境为Windows操作系统。

三、实验过程1. 创建二叉树首先,我们需要创建一个二叉树作为实验的基础数据结构。

在本实验中,我们选择手动创建一个简单的二叉树,以便更好地理解遍历算法的实现过程。

2. 前序遍历前序遍历是一种深度优先遍历算法,它的遍历顺序是先访问根节点,然后递归地遍历左子树和右子树。

通过实际操作,我们可以发现前序遍历的结果是根节点在最前面。

3. 中序遍历中序遍历也是一种深度优先遍历算法,它的遍历顺序是先递归地遍历左子树,然后访问根节点,最后递归地遍历右子树。

通过实际操作,我们可以发现中序遍历的结果是根节点在中间。

4. 后序遍历后序遍历同样是一种深度优先遍历算法,它的遍历顺序是先递归地遍历左子树和右子树,最后访问根节点。

通过实际操作,我们可以发现后序遍历的结果是根节点在最后面。

5. 分析与总结通过对前序遍历、中序遍历和后序遍历的实际操作,我们可以得出以下结论:- 前序遍历适合于需要先处理根节点的场景,例如树的构建和复制。

- 中序遍历适合于需要按照节点值的大小顺序进行处理的场景,例如搜索二叉树的构建和排序。

- 后序遍历适合于需要先处理叶子节点的场景,例如树的销毁和内存释放。

四、实验结果通过实际操作,我们成功实现了二叉树的前序遍历、中序遍历和后序遍历算法,并得到了相应的遍历结果。

这些结果验证了我们对遍历算法的分析和总结的正确性。

五、实验总结本实验通过实际操作,深入探索了二叉树的遍历算法,并分析了它们的特点和适用场景。

二叉树的创建与遍历的实验总结

二叉树的创建与遍历的实验总结

二叉树的创建与遍历的实验总结一、实验目的二叉树是一种重要的数据结构,本实验旨在通过编写程序实现二叉树的创建和遍历,加深对二叉树的理解,并掌握二叉树相关算法。

二、实验原理1. 二叉树的定义:每个节点最多有两个子节点的树结构。

2. 二叉树的遍历方式:前序遍历、中序遍历、后序遍历和层次遍历。

3. 二叉树的创建方式:递归创建和非递归创建。

三、实验内容1. 实现递归创建二叉树:通过输入节点值,按照前序遍历方式逐个创建节点,直到输入结束符号为止。

2. 实现非递归创建二叉树:通过输入节点值,按照层次遍历方式逐个创建节点,直到输入结束符号为止。

3. 实现前序遍历、中序遍历、后序遍历和层次遍历函数,并输出结果。

四、实验步骤1. 定义节点结构体Node,包含数据域和左右子节点指针域。

2. 实现递归创建函数createTreeRecursion():读入一个字符,如果是结束符号,则返回NULL;否则新建一个节点,并依次读入左右子节点值并分别递归调用createTreeRecursion()函数,将左右子节点指针指向返回值。

3. 实现非递归创建函数createTreeNonRecursion():读入一个字符,如果是结束符号,则返回NULL;否则新建一个节点,并将其加入队列中。

在队列不为空的情况下,取出队首元素并分别读入左右子节点值并新建节点加入队列中,将左右子节点指针指向新建的节点。

4. 实现前序遍历函数preorderTraversal():输出当前节点数据,递归调用preorderTraversal()函数遍历左子树和右子树。

5. 实现中序遍历函数inorderTraversal():递归调用inorderTraversal()函数遍历左子树,输出当前节点数据,再递归调用inorderTraversal()函数遍历右子树。

6. 实现后序遍历函数postorderTraversal():递归调用postorderTraversal()函数遍历左子树和右子树,输出当前节点数据。

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

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

竭诚为您提供优质文档/双击可除二叉树的建立和遍历的实验报告篇一:二叉树遍历实验报告数据结构实验报告报告题目:二叉树的基本操作学生班级:学生姓名:学号:一.实验目的1、基本要求:深刻理解二叉树性质和各种存储结构的特点及适用范围;掌握用指针类型描述、访问和处理二叉树的运算;熟练掌握二叉树的遍历算法;。

2、较高要求:在遍历算法的基础上设计二叉树更复杂操作算法;认识哈夫曼树、哈夫曼编码的作用和意义;掌握树与森林的存储与便利。

二.实验学时:课内实验学时:3学时课外实验学时:6学时三.实验题目1.以二叉链表为存储结构,实现二叉树的创建、遍历(实验类型:验证型)1)问题描述:在主程序中设计一个简单的菜单,分别调用相应的函数功能:1…建立树2…前序遍历树3…中序遍历树4…后序遍历树5…求二叉树的高度6…求二叉树的叶子节点7…非递归中序遍历树0…结束2)实验要求:在程序中定义下述函数,并实现要求的函数功能:createbinTree(binTreestructnode*lchild,*rchild;}binTnode;元素类型:intcreatebinTree(binTreevoidpreorder(binTreevoidInorder(binTreevoidpostorder(binTreevoidInordern(binTreeintleaf(bi nTreeintpostTreeDepth(binTree2、编写算法实现二叉树的非递归中序遍历和求二叉树高度。

1)问题描述:实现二叉树的非递归中序遍历和求二叉树高度2)实验要求:以二叉链表作为存储结构3)实现过程:1、实现非递归中序遍历代码:voidcbiTree::Inordern(binTreeinttop=0;p=T;do{while(p!=nuLL){stack[top]=p;;top=top+1;p=p->lchild;};if(top>0){top=top-1;p=stack[top];printf("%3c",p->data);p=p->rchild;}}while(p!=nuLL||top!=0);}2、求二叉树高度:intcbiTree::postTreeDepth(binTreeif(T!=nuLL){l=postTreeDepth(T->lchild);r=postTreeDepth(T->rchil d);max=l>r?l:r;return(max+1);}elsereturn(0);}实验步骤:1)新建一个基于consoleApplication的工程,工程名称biTreeTest;2)新建一个类cbiTree二叉树类。

c语言二叉树实验报告

c语言二叉树实验报告

c语言二叉树实验报告一、实验目的本次实验的目的是通过使用C语言编写程序,实现二叉树的基本操作,包括创建二叉树、插入节点、删除节点、遍历等功能。

通过这些操作,加深对数据结构和算法的理解,提高编程能力。

二、实验环境1. 操作系统:Windows 102. 开发工具:Code::Blocks 20.033. 编程语言:C语言三、实验过程及结果1. 创建二叉树在程序中定义了一个结构体来表示二叉树节点:```typedef struct Node {int data; // 节点数据struct Node *left; // 左子节点指针struct Node *right; // 右子节点指针} Node;```创建一个新节点的函数为:```Node *create_node(int data) {Node *node = (Node*)malloc(sizeof(Node)); node->data = data;node->left = NULL;node->right = NULL;return node;}```通过递归方式创建一棵二叉树:```Node *create_tree() {int data;scanf("%d", &data);if (data == -1) {return NULL;}Node *node = create_node(data);node->left = create_tree();node->right = create_tree();return node;}2. 插入节点插入节点需要先找到要插入位置的父节点,然后根据插入位置是左子节点还是右子节点,将新节点插入到相应的位置:```void insert_node(Node *root, int data) {Node *node = create_node(data);Node *parent = NULL;Node *current = root;while (current != NULL) {parent = current;if (data < current->data) {current = current->left;} else {current = current->right;}}if (data < parent->data) {parent->left = node;} else {parent->right = node;}```3. 删除节点删除节点需要先找到要删除的节点,然后根据其子节点的情况进行删除操作:```Node *delete_node(Node *root, int data) {if (root == NULL) {return root;}if (data < root->data) {root->left = delete_node(root->left, data);} else if (data > root->data) {root->right = delete_node(root->right, data);} else { // 找到要删除的节点if (root->left == NULL && root->right == NULL) { // 没有子节点free(root);return NULL;} else if (root->left == NULL || root->right == NULL) { // 只有一个子节点Node *temp;if (root->left != NULL) {temp = root->left;} else {temp = root->right;}free(root);return temp;} else { // 有两个子节点Node *temp = root->right;while (temp->left != NULL) {temp = temp->left;}root->data = temp->data;root->right = delete_node(root->right, temp->data); }}return root;}```4. 遍历二叉树遍历二叉树有三种方式:前序遍历、中序遍历和后序遍历。

二叉树地创建与遍历实验报告

二叉树地创建与遍历实验报告

数据结构课内实验报告书一、实验题目:二叉树的创建与遍历二、实验目的:通过本次实验,熟练掌握二叉树的存储结构定义及其遍历算法的实现,学会利用栈编写非递归的遍历算法。

三、实验要求:建立一棵用二叉链表方式存储的二叉树,并对其进行遍历(先序、中序和后序),打印输出遍历结果。

要求:从键盘接受扩展先序序列,以二叉链表作为存储结构,建立二叉树,并将遍历结果打印输出。

采用递归和非递归两种方法实现。

四、设计与实现过程(1)存储结构定义typedefcharelemtype;typedefstructNode{elemtypedata;structNode*lchild;structNode*rchild;}BitNode;(2)算法描述Node*creat(Node*pre){chare;Node*head;e=getchar();if(e!=''){head=(Node*)malloc(sizeof(Node));head->data=e;head->Lchild=creat(head);if(head->Lchild==NULL){head->Lflag=1;head->Lchild=pre;}head->Rchild=creat(head);if(pre!=NULL&&pre->Rchild==NULL){ pre->Rflag=1;pre->Rchild=head;}returnhead;}else{returnNULL;}}Node*InPre(Node*root){Node*p;if(root->Lflag==1){p=root->Lchild;}else{for(p=root->Lchild;p->Rflag==0;p=p->Rchild); }returnp;}Node*InNext(Node*root){Node*p;if(root->Rflag==1){p=root->Rchild;}else{for(p=root->Rchild;p->Lflag==0;p=p->Lchild);}returnp;}Node*Infirst(Node*root){Node*p;p=root;if(!p){fprintf(stdout,"n");returnNULL;}while(p->Lflag==0){p=p->Lchild;}returnp;}voidTInOrder(Node*root){Node*p;p=Infirst(root);while(p!=NULL){fprintf(stdout,"%c",p->data);p=InNext(p);}printf("\n");}五、运行结果输入ABECD输出BEADC六、技巧与体会通过实验,锻炼了自己的能力,加深了自己对有关知识的理解。

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

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

二叉树的建立和遍历实验报告一、引言(100字)二叉树是一种常见的数据结构,它由根节点、左子树和右子树组成,具有递归性质。

本次实验的目的是了解二叉树的建立过程和遍历算法,以及熟悉二叉树的相关操作。

本实验采用C语言进行编写。

二、实验内容(200字)1.二叉树的建立:通过输入节点的值,逐个建立二叉树的节点,并通过指针连接起来。

2.二叉树的遍历:实现二叉树的三种常用遍历算法,即前序遍历、中序遍历和后序遍历。

三、实验过程(400字)1.二叉树的建立:首先,定义二叉树的节点结构,包含节点值和指向左右子树的指针;然后,通过递归的方式,依次输入节点的值,创建二叉树节点,建立好节点之间的连接。

2.二叉树的前序遍历:定义一个函数,实现前序遍历的递归算法,先输出当前节点的值,再递归遍历左子树和右子树。

3.二叉树的中序遍历:同样,定义一个函数,实现中序遍历的递归算法,先递归遍历左子树,再输出当前节点的值,最后递归遍历右子树。

4.二叉树的后序遍历:同样,定义一个函数,实现后序遍历的递归算法,先递归遍历左子树和右子树,再输出当前节点的值。

四、实验结果(300字)通过实验,我成功建立了一个二叉树,并实现了三种遍历算法。

对于建立二叉树来说,只要按照递归的思路,先输入根节点的值,再分别输入左子树和右子树的值,即可依次建立好节点之间的连接。

建立好二叉树后,即可进行遍历操作。

在进行遍历算法的实现时,我首先定义了一个函数来进行递归遍历操作。

在每一次递归调用中,我首先判断当前节点是否为空,若为空则直接返回;若不为空,则按照特定的顺序进行遍历操作。

在前序遍历中,我先输出当前节点的值,再递归遍历左子树和右子树;在中序遍历中,我先递归遍历左子树,再输出当前节点的值,最后递归遍历右子树;在后序遍历中,我先递归遍历左子树和右子树,再输出当前节点的值。

通过运行程序,我成功进行了二叉树的建立和遍历,并得到了正确的结果。

可以看到,通过不同的遍历顺序,可以获得不同的遍历结果,这也是二叉树遍历算法的特性所在。

二叉树的遍历实验报告

二叉树的遍历实验报告

二叉树的遍历实验报告一、实验目的1.了解二叉树的基本概念和性质;2.理解二叉树的遍历方式以及它们的实现方法;3.学会通过递归和非递归算法实现二叉树的遍历。

二、实验内容1.二叉树的定义在计算机科学中,二叉树是一种重要的数据结构,由节点及它们的左右儿子组成。

没有任何子节点的节点称为叶子节点,有一个子节点的节点称为一度点,有两个子节点的节点称为二度点。

二叉树的性质:1.每个节点最多有两个子节点;2.左右子节点的顺序不能颠倒,左边是父节点的左子节点,右边是父节点的右子节点;3.二叉树可以为空,也可以只有一个根节点;4.二叉树的高度是从根节点到最深叶子节点的层数;5.二叉树的深度是从最深叶子节点到根节点的层数;6.一个深度为d的二叉树最多有2^(d+1) -1个节点,其中d>=1;7.在二叉树的第i层上最多有2^(i-1)个节点,其中i>=1。

2.二叉树的遍历方式二叉树的遍历是指从根节点出发,按照一定的顺序遍历二叉树中的每个节点。

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

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

递归算法:利用函数调用,递归实现二叉树的遍历;非递归算法:利用栈或队列,对二叉树进行遍历。

三、实验步骤1.创建二叉树数据结构并插入节点;2.实现二叉树的前序遍历、中序遍历、后序遍历递归算法;3.实现二叉树的前序遍历、中序遍历、后序遍历非递归算法;4.测试算法功能。

四、实验结果1.创建二叉树数据结构并插入节点为了测试三种遍历方式的算法实现,我们需要创建一个二叉树并插入节点,代码如下:```c++//定义二叉树节点struct TreeNode {int val;TreeNode* left;TreeNode* right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}};递归算法是实现二叉树遍历的最简单方法,代码如下:```c++//前序遍历非递归算法vector<int> preorderTraversal(TreeNode* root) {stack<TreeNode*> s;vector<int> res;if (!root) return res;s.push(root);while (!s.empty()) {TreeNode* tmp = s.top();s.pop();res.push_back(tmp->val);if (tmp->right) s.push(tmp->right);if (tmp->left) s.push(tmp->left);}return res;}4.测试算法功能return 0;}```测试结果如下:preorderTraversal: 4 2 1 3 6 5 7inorderTraversal: 1 2 3 4 5 6 7postorderTraversal: 1 3 2 5 7 6 4preorderTraversalNonRecursive: 4 2 1 3 6 5 7inorderTraversalNonRecursive: 1 2 3 4 5 6 7postorderTraversalNonRecursive: 1 3 2 5 7 6 4本次实验通过实现二叉树的递归和非递归遍历算法,加深了对二叉树的理解,并熟悉了遍历算法的实现方法。

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

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

PreOrder(T->lchild); PreOrder(T->rchild); } } //中序遍历二叉树 void InOrder(BinTree T) { if(T) { InOrder(T->lchild); printf("%c",T->data); InOrder(T->rchild); } } //后序遍历二叉树
五、 参考算法
二叉树的建立算法思路:主要利用二叉树的性质:在编号的完全二叉树中,编号为 i 的结点如果存在左孩子,则其编号为 2i;若其存在右孩子,则其编号为 2i+1;若存在父 结点,则其编号为 i/2 取整。对任意二叉树,先按满二叉树对其进行编号,算法中使用一 个辅助向量 s 来存放指向树结点的指针。如 s[i]中存放编号为 i 的结点的指针,即为该结 点的地址。当结点编号 i=1 时,所产生的结点为根结点,同时将指向该结点的指针存入 s[1]。 当结点编号 i>1 时,产生一个新的结点后,也要将指向该结点的指针存入 s[i],由上述性 质可知:j=i/2 为它的双亲结点编号。如果 i 为偶数,则它是双亲结点的左孩子,即让 s[j]->lch=s[i];若 i 为奇数,则它是双亲结点的右孩子,即让 s[j]->rch=s[i]。这样就将新输 入的结点逐一与其双亲结点相连,生成二叉树。二叉树的建立也可使用递归算法实现。
A
B
C
D
E
F
G
可以按如下次序依次输入给定二叉树及左右子树中的各结点值: (1) 输入根结点值。 (2) 若左子树不空,则输入左子树,否则输入一个空格(或其它特殊字符)。 (3) 若右子树不空,则输入右子树,否则输入一个空格(或其它特殊字符)。 如图所示二叉树,按先序遍历次序输入: A B C D E G F (/n)

二叉树的创建与遍历的实验总结

二叉树的创建与遍历的实验总结

二叉树的创建与遍历的实验总结引言二叉树是一种重要的数据结构,在计算机科学中有着广泛的应用。

了解二叉树的创建和遍历方法对于数据结构的学习和算法的理解至关重要。

本文将对二叉树的创建和遍历进行实验,并总结相应的经验和思考。

二叉树的定义在开始实验之前,我们首先需要了解二叉树的定义和基本概念。

二叉树是一种每个节点最多拥有两个子节点的树形结构。

每个节点包含一个值和指向其左右子节点的指针。

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

创建二叉树二叉树的创建可以采用多种方法,包括手动创建和通过编程实现。

在实验中,我们主要关注通过编程方式实现二叉树的创建。

1. 递归方法递归是一种常用的创建二叉树的方法。

通过递归,我们可以从根节点开始,逐层创建左子树和右子树。

具体步骤如下:1.创建一个空节点作为根节点。

2.递归地创建左子树。

3.递归地创建右子树。

递归方法的代码实现如下所示:class TreeNode:def __init__(self, value):self.value = valueself.left = Noneself.right = Nonedef create_binary_tree(values):if not values:return None# 使用队列辅助创建二叉树queue = []root = TreeNode(values[0])queue.append(root)for i in range(1, len(values)):node = TreeNode(values[i])# 当前节点的左子节点为空,则将新节点作为左子节点if not queue[0].left:queue[0].left = node# 当前节点的右子节点为空,则将新节点作为右子节点elif not queue[0].right:queue[0].right = node# 当前节点的左右子节点已经齐全,可以从队列中删除该节点queue.pop(0)# 将新节点添加到队列中,下一次循环时可以使用该节点queue.append(node)return root2. 非递归方法除了递归方法,我们还可以使用非递归方法创建二叉树。

c语言二叉树实验报告

c语言二叉树实验报告

C语言二叉树实验报告摘要本实验报告旨在详细介绍C语言中二叉树的实现方法,并深入探讨二叉树在计算机科学中的应用。

报告内容包括二叉树的定义、创建与遍历方法、二叉树的特性、二叉树的应用领域等方面的内容。

通过对二叉树的学习和实践,我们可以加深对数据结构的理解和应用能力。

1. 引言在计算机科学中,二叉树是一种重要的数据结构,被广泛应用于各种算法和实际问题的解决。

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

本实验旨在通过使用C语言来实现二叉树,加深对二叉树的理解和运用能力。

2. 二叉树的定义与创建2.1 二叉树的定义二叉树是一种树形数据结构,在计算机科学中具有广泛的应用。

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

根节点是二叉树的起点,也是唯一没有父节点的节点。

2.2 创建二叉树可以通过以下步骤创建一个二叉树:1.定义二叉树的节点结构,包括数据域和左右子节点指针域。

2.使用动态内存分配函数malloc为根节点分配内存空间。

3.输入根节点的值,并将左右子节点指针指向NULL。

4.递归地创建左子树和右子树。

3. 二叉树的遍历方法二叉树的遍历是指以某种顺序访问二叉树中的节点,可以分为前序遍历、中序遍历和后序遍历三种方式。

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

在前序遍历中,根节点总是最先被访问。

算法的伪代码如下所示:preorderTraversal(node) {if (node is not NULL) {print node.valuepreorderTraversal(node.left)preorderTraversal(node.right)}}3.2 中序遍历中序遍历是指先递归地遍历左子树,然后访问根节点,最后再递归地遍历右子树。

在中序遍历中,根节点总是被访问在中间位置。

算法的伪代码如下所示:inorderTraversal(node) {if (node is not NULL) {inorderTraversal(node.left)print node.valueinorderTraversal(node.right)}}3.3 后序遍历后序遍历是指先递归地遍历左子树和右子树,最后访问根节点。

实验四 二叉树的建立与遍历

实验四 二叉树的建立与遍历

实验四二叉树的建立与遍历【实验目的】■掌握二叉树的定义、性质及存储方式,各种遍历算法。

【实验内容】1.采用二叉树链表作为存储结构,完成二叉树的建立,先序、中序和后序遍历的递归操作。

2.分别求所有叶子结点及结点总数的操作。

提示:设计一颗二叉树,输入完全二叉树的先序序列,用#代表虚结点(空指针),如ABD###CE##F##,建立二叉树,求出先序、中序和后序遍历序列,求所有叶子及结点总数。

【程序源代码】#include<stdio.h>#include<stdlib.h>typedefcharTElemType;typedefintStatus;#defineOK1#defineERROR0#defineOVERFLOW0typedefstructBiTNode{TElemTypedata;structBiTNode*lchild,*rchild;}BiTNode,*BiTree;StatusCreateBiTree(BiTree&BT);voidCountLeaves(BiTreeBT,int&count);intNodeCount(BiTreeBT);voidPreOrder(BiTreeBT);voidInOrder(BiTreeBT);voidPostOrder(BiTreeBT);intmain(){BiTreeBT;intchoice,cho;intlogo=1;printf("输入二叉树结点,以'#'为空指针\n");CreateBiTree(BT);do{printf("\t1:遍历二叉树\n");printf("\t2:二叉树总结点数及叶子节点数\n");printf("\t3:退出程序\n");printf("\t输入选项:");scanf("%2d",&choice);switch(choice){case1:printf("1:先序遍历\n");printf("2:中序遍历\n");printf("3:后序遍历\n");scanf("%2d",&cho);switch(cho){case 1:PreOrder(BT);printf("\n");break;case 2:InOrder(BT);printf("\n");break;case 3:PostOrder(BT);printf("\n");break;default:printf("输入错误!\n");}break;case 2intcount;printf("总结点数为:%2d\n”,NodeCount(BT));CountLeaves(BT,count);printf("叶子结点数为:%2d\n",count);break;case 3:exit(0);break;default:printf("输入错误!\n");}}while(logo==1);return0;StatusCreateBiTree(BiTree&BT){charch;scanf("%c",&ch);if(ch=='#')BT=NULL;else{if(!(BT=(BiTree)malloc(sizeof(BiTNode))))exit(OVERFLOW);BT->data=ch;CreateBiTree(BT->lchild);CreateBiTree(BT->rchild);}returnOK;}voidPreOrder(BiTreeBT){if(BT!=NULL){printf("%c",BT->data);PreOrder(BT->lchild);PreOrder(BT->rchild);}}voidInOrder(BiTreeBT)if(BT!=NULL)PreOrder(BT->lchild);printf("%c",BT->data);PreOrder(BT->rchild);}}voidPostOrder(BiTreeBT){if(BT!=NULL){PreOrder(BT->lchild);PreOrder(BT->rchild);printf("%c",BT->data);}}voidCountLeaves(BiTreeBT,int&count){if(BT){if(!BT->lchild&&!BT->rchild)count++;CountLeaves(BT->lchild,count);CountLeaves(BT->rchild,count);}}intNodeCount(BiTreeBT)//统计总结点数if(BT==NULL)return0;elsereturn(NodeCount(BT->lchild)+NodeCount(BT->rchild)+1); }【运行结果分析】【实验收获与心得】在本次实验中,我对递归这个概念有了较为深刻的认识,对二叉树的建立、遍历也掌握得较为透彻,通过对书本上知识的运用,我对本章的部分知识的掌握程度得到了提高,通过将各个算法运用到编程中,也使我对原本不是太懂的算法的理解有了质的提高。

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

二叉树的创建与遍历
一、实验目的
1.学会实现二叉树结点结构和对二叉树的基本操作。

2.掌握对二叉树每种操作的具体实现,学会利用递归和非递归方法编写对二叉树这种递归数据结构进行处理的算法。

二、实验要求
1.认真阅读和掌握和本实验相关的教材内容。

2.编写完整程序完成下面的实验内容并上机运行。

3.整理并上交实验报告。

三、实验内容
1.编写程序任意输入二叉树的结点个数和结点值,构造一棵二叉树,采用三种递归和非递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历。

四、实验步骤
源程序代码1
#include<iostream>
#include<stack>
using namespace std;
template<class T>
struct BinTreeNode //二叉树结点类定义
{
T data; //数据域
BinTreeNode<T> *leftChild,*rightChild; //左子女、右子女域
BinTreeNode(T x=T(),BinTreeNode<T>* l =NULL,BinTreeNode<T>* r = NULL )
:data(x),leftChild(l),rightChild(r){} //可选择参数的默认构造函数
};
//-------------------------------------------------------------------------
template<class T>
void PreOrder_2(BinTreeNode<T> *p) //非递归前序遍历
{
stack<BinTreeNode<T> * > S;
while(p!=NULL || !S.empty())
{
while(p!=NULL)
{
cout<<p->data; //访问根结点
S.push(p);
p=p->leftChild; //遍历指针进到左子女结点
}
if(!S.empty()) //栈不空时退栈
{
p=S.top();
S.pop();
p = p->rightChild; //遍历指针进到右子女结点}
}
}
//---------------------------------------------------------------- template<class T>
void InOrder_2(BinTreeNode<T> *p) //非递归中序遍历
{
stack<BinTreeNode<T>* > S;
do
{
while(p!=NULL) //遍历指针未到最左下的结点,不空
{
S.push(p);
p=p->leftChild;
}
if(!S.empty()) //栈不空时退栈
{
p=S.top();
S.pop();
cout<<p->data;
p=p->rightChild;
}
}
while(p !=NULL || !S.empty());
}。

相关文档
最新文档