二叉树的遍历及其应用实验报告
二叉树的遍历及其应用实验报告
实验报告题目:二叉树的遍历及应用院系:数学系专业:数学与应用数学学号: **********姓名:***一、实验名称:二叉树的遍历及应用二、实验日期:2012年11月14日三、实验要求:编程实现二叉树的建立并对其进行遍历四、实验目的:1、掌握二叉树链式存储结构的类型定义及实现;2、掌握二叉树链式存储结构的各类基本运算方法;3、掌握二叉树各个重要性质在解决实际问题中的应用;4、掌握二叉树的分析方法、解决方法,从而提高实际编程能力及程序调试能力。
五、实验内容1、创建二叉树;2、用递归方法实现二叉树的各种遍历。
六、程序代码#include<stdio.h>#include<malloc.h>#define TRUE 1#define FALSE 0#define Stack_Size 50typedef struct Node{char data;struct Node *LChild;struct Node *RChild;}BiTNode,*BiTree;typedef BiTree StackElementType;typedef struct{StackElementType elem[Stack_Size];int top;}SeqStack;//初始化void InitStack(SeqStack *S){S->top=-1;}//进栈int Push(SeqStack *S,StackElementType x) { if(S->top==Stack_Size-1) return(FALSE); S->top++;S->elem[S->top]=x;return(TRUE);}//出栈int Pop(SeqStack *S,StackElementType *x) {if(S->top==-1)return(FALSE);else{*x=S->elem[S->top];S->top--;return(TRUE);}}//先序遍历void PreOrder(BiTree root){if(root!=NULL){printf("%c",root->data);PreOrder(root->LChild);PreOrder(root->RChild);}}//中序遍历void InOrder(BiTree root) { if(root!=NULL){ InOrder(root->LChild); printf("%c",root->data); InOrder(root->RChild);}}//后序遍历void PostOrder(BiTree root) {if(root!=NULL){PostOrder(root->LChild); PostOrder(root->RChild); printf("%c",root->data);}}//创建二叉链表void CreateBiTree(BiTree *bt){char ch;ch=getchar();if(ch=='.') *bt=NULL;else{*bt=(BiTree)malloc(sizeof(BiTNode)); (*bt)->data=ch;CreateBiTree(&((*bt)->LChild)); CreateBiTree(&((*bt)->RChild));}}//后序遍历球二叉树高度int PostTreeDepth(BiTree bt){int hl,hr,max;if(bt!=NULL){hl=PostTreeDepth(bt->LChild);hr=PostTreeDepth(bt->RChild);max=hl>hr?hl:hr;return(max+1);}else return(0);}//横向打印二叉树void PrintTree(BiTree bt,int nLayer) {int i;if(bt==NULL) return;PrintTree(bt->RChild,nLayer+1);for( i=0;i<nLayer;i++)printf(" ");printf("%c\n",bt->data);PrintTree(bt->LChild,nLayer+1);}void main(){BiTree root;printf("请输入序列:\n"); CreateBiTree(&root);printf("输出结果为:\n");printf("先序遍历结果:\n"); PreOrder(root);printf("\n中序遍历结果:\n"); InOrder(root);printf("\n后序遍历结果:\n"); PostOrder(root);printf("\n二叉树的深度:\n");printf("%d",PostTreeDepth(root)); printf("\n横向打印二叉树结果:\n"); PrintTree(root,5);}七、成果展示。
【二叉树的建立和遍历实验报告】二叉树的遍历实验心得
【二叉树的建立和遍历实验报告】二叉树的遍历实验心得[题目] 建立二叉树并求指定结点路径、深度、叶子个数和左右子树交换。
[问题描述]要求能够按先序遍历次序输入二叉树中结点的值来构造二叉树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、求二叉树的深度。
二叉树的遍历实验报告
二叉树的遍历实验报告二叉树的遍历实验报告引言:二叉树是一种常见的数据结构,它由节点和连接节点的边组成。
在实际应用中,我们经常需要对二叉树进行遍历,以便对其中的节点进行访问和操作。
本次实验旨在探索二叉树的遍历算法,并通过实验验证其正确性和效率。
一、二叉树的定义和基本操作二叉树是一种特殊的树结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。
根据节点的访问顺序,二叉树的遍历可以分为前序遍历、中序遍历和后序遍历三种方式。
前序遍历是指先访问根节点,然后按照左子树、右子树的顺序递归地进行遍历;中序遍历是指先按照左子树、根节点、右子树的顺序递归地进行遍历;后序遍历是指先按照左子树、右子树、根节点的顺序递归地进行遍历。
二、实验设计和方法为了验证二叉树的遍历算法的正确性和效率,我们设计了以下实验方案:1. 构建二叉树:我们首先构建一个具有一定规模的二叉树,以模拟实际应用中的情况。
为了方便起见,我们选择随机生成一棵二叉树,并确保其结构合理。
2. 实现遍历算法:我们根据前文所述的遍历方式,实现了相应的遍历算法。
在实现过程中,我们考虑到了递归和迭代两种方式,并分别进行了实验比较。
3. 遍历实验:我们使用不同规模的二叉树进行遍历实验,并记录遍历的结果和所花费的时间。
通过对比不同规模下不同遍历方式的结果和时间,我们可以评估遍历算法的效率和准确性。
三、实验结果和分析在实验中,我们构建了一棵具有1000个节点的二叉树,并分别使用前序、中序和后序遍历算法进行遍历。
通过实验结果的比较,我们得出以下结论:1. 遍历结果的正确性:无论是前序、中序还是后序遍历,我们都能够正确地访问到二叉树中的每个节点。
这表明我们所实现的遍历算法是正确的。
2. 遍历算法的效率:在1000个节点的二叉树中,我们发现中序遍历算法的执行时间最短,后序遍历算法的执行时间最长,前序遍历算法的执行时间居中。
这是因为中序遍历算法在访问节点时可以尽可能地减少递归次数,而后序遍历算法需要递归到最深层才能返回。
数据结构二叉树遍历实验报告
数据结构二叉树遍历实验报告一、实验目的本次实验的主要目的是深入理解和掌握二叉树的三种遍历方式:前序遍历、中序遍历和后序遍历,并通过实际编程实现来加深对这些遍历算法的理解和应用能力。
二、实验环境本次实验使用的编程语言为 Python,开发工具为 PyCharm。
三、实验原理1、二叉树的定义二叉树是一种每个节点最多有两个子节点的树结构,分别称为左子节点和右子节点。
2、前序遍历前序遍历首先访问根节点,然后递归地前序遍历左子树,最后递归地前序遍历右子树。
3、中序遍历中序遍历首先递归地中序遍历左子树,然后访问根节点,最后递归地中序遍历右子树。
4、后序遍历后序遍历首先递归地后序遍历左子树,然后递归地后序遍历右子树,最后访问根节点。
四、实验步骤1、定义二叉树节点类```pythonclass TreeNode:def __init__(self, value):selfvalue = valueselfleft = Noneselfright = None```2、实现前序遍历函数```pythondef pre_order_traversal(root):if root is not None:print(rootvalue, end="")pre_order_traversal(rootleft)pre_order_traversal(rootright)```3、实现中序遍历函数```pythondef in_order_traversal(root):if root is not None:in_order_traversal(rootleft) print(rootvalue, end="")in_order_traversal(rootright)```4、实现后序遍历函数```pythondef post_order_traversal(root):if root is not None:post_order_traversal(rootleft) post_order_traversal(rootright) print(rootvalue, end="")```5、构建二叉树并进行遍历```python构建二叉树root = TreeNode(1) rootleft = TreeNode(2) rootright = TreeNode(3) rootleftleft = TreeNode(4) rootleftright = TreeNode(5)前序遍历print("前序遍历:")pre_order_traversal(root) print()中序遍历print("中序遍历:")in_order_traversal(root) print()后序遍历print("后序遍历:")post_order_traversal(root)print()```五、实验结果1、前序遍历结果:1 2 4 5 32、中序遍历结果:4 2 5 1 33、后序遍历结果:4 5 2 3 1六、结果分析1、前序遍历在前序遍历中,首先访问根节点,然后再访问左子树和右子树。
二叉树的建立和遍历的实验报告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)先序建立二叉树时,虽用到递归建左右子树,但没有把他们赋值给根节点的左右指针,造成二叉树脱节。
二叉树的遍历实验报告
二叉树的遍历实验报告实验报告:二叉树的遍历(先序遍历、中序遍历、后序遍历)一、引言二叉树是一种非常常见的数据结构,在计算机领域有着广泛的应用。
对二叉树进行遍历操作是其中最基本的操作之一、本实验旨在通过对二叉树的先序遍历、中序遍历和后序遍历的实践,加深对二叉树遍历算法的理解和掌握。
二、目的1.掌握二叉树先序遍历的算法原理和实现方法;2.掌握二叉树中序遍历的算法原理和实现方法;3.掌握二叉树后序遍历的算法原理和实现方法;4.使用递归和非递归两种方式实现以上三种遍历算法;5.进行正确性验证和性能评估。
三、方法1.算法原理:1.1先序遍历:先访问根节点,然后递归遍历左子树,再递归遍历右子树;1.2中序遍历:先递归遍历左子树,然后访问根节点,最后递归遍历右子树;1.3后序遍历:先递归遍历左子树,再递归遍历右子树,最后访问根节点。
2.实现方法:2.1递归实现:采用函数递归调用的方式,实现对二叉树的遍历;2.2非递归实现:采用栈的数据结构,模拟递归的过程,实现对二叉树的遍历。
四、实验步骤1.数据结构设计:1.1定义二叉树的节点结构,包括节点值和两个指针(分别指向左子节点和右子节点);1.2定义一个栈结构,用于非递归实现时的辅助存储。
2.先序遍历:2.1递归实现:按照先序遍历的原理,通过递归调用遍历左子树和右子树,再输出根节点;2.2非递归实现:通过栈结构模拟递归的过程,先将根节点入栈,然后循环将栈顶节点弹出并输出,再将其右子节点入栈,最后将左子节点入栈,直到栈为空。
3.中序遍历:3.1递归实现:按照中序遍历的原理,通过递归调用先遍历左子树,再输出根节点,最后遍历右子树;3.2非递归实现:先将根节点入栈,然后循环将左子节点入栈,直到左子节点为空,然后弹出栈顶节点并输出,再将其右子节点入栈,重复以上过程直到栈为空。
4.后序遍历:4.1递归实现:按照后序遍历的原理,通过递归调用先遍历左子树,再遍历右子树,最后输出根节点;4.2非递归实现:通过栈结构模拟递归的过程,先将根节点入栈,然后重复以下步骤直到栈为空。
遍历二叉树实验报告
遍历二叉树实验报告遍历二叉树实验报告引言:二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。
在实际应用中,对二叉树进行遍历是一项重要的操作。
本实验旨在通过实际操作,探索二叉树的遍历算法,并分析其时间复杂度和空间复杂度。
一、实验目的通过实际操作,掌握二叉树的前序遍历、中序遍历和后序遍历算法,并分析它们的特点和适用场景。
二、实验环境本实验使用C++语言进行编程,运行环境为Windows操作系统。
三、实验过程1. 创建二叉树首先,我们需要创建一个二叉树作为实验的基础数据结构。
在本实验中,我们选择手动创建一个简单的二叉树,以便更好地理解遍历算法的实现过程。
2. 前序遍历前序遍历是一种深度优先遍历算法,它的遍历顺序是先访问根节点,然后递归地遍历左子树和右子树。
通过实际操作,我们可以发现前序遍历的结果是根节点在最前面。
3. 中序遍历中序遍历也是一种深度优先遍历算法,它的遍历顺序是先递归地遍历左子树,然后访问根节点,最后递归地遍历右子树。
通过实际操作,我们可以发现中序遍历的结果是根节点在中间。
4. 后序遍历后序遍历同样是一种深度优先遍历算法,它的遍历顺序是先递归地遍历左子树和右子树,最后访问根节点。
通过实际操作,我们可以发现后序遍历的结果是根节点在最后面。
5. 分析与总结通过对前序遍历、中序遍历和后序遍历的实际操作,我们可以得出以下结论:- 前序遍历适合于需要先处理根节点的场景,例如树的构建和复制。
- 中序遍历适合于需要按照节点值的大小顺序进行处理的场景,例如搜索二叉树的构建和排序。
- 后序遍历适合于需要先处理叶子节点的场景,例如树的销毁和内存释放。
四、实验结果通过实际操作,我们成功实现了二叉树的前序遍历、中序遍历和后序遍历算法,并得到了相应的遍历结果。
这些结果验证了我们对遍历算法的分析和总结的正确性。
五、实验总结本实验通过实际操作,深入探索了二叉树的遍历算法,并分析了它们的特点和适用场景。
二叉树的遍历实验报告
二叉树的遍历实验报告一、需求分析在二叉树的应用中,常常要求在树中查找具有某种特征的结点,或者对树中全部结点逐一进行某种处理,这就是二叉树的遍历问题。
对二叉树的数据结构进行定义,建立一棵二叉树,然后进行各种实验操作。
二叉树是一个非线性结构,遍历时要先明确遍历的规则,先访问根结点还时先访问子树,然后先访问左子树还是先访问有右子树,这些要事先定好,因为采用不同的遍历规则会产生不同的结果。
本次实验要实现先序、中序、后序三种遍历。
基于二叉树的递归定义,以及遍历规则,本次实验也采用的是先序遍历的规则进行建树的以及用递归的方式进行二叉树的遍历。
二、系统总框图三、各模块设计分析(1)建立二叉树结构建立二叉树时,要先明确是按哪一种遍历规则输入,该二叉树是按你所输入的遍历规则来建立的。
本实验用的是先序遍历的规则进行建树。
二叉树用链表存储来实现,因此要先定义一个二叉树链表存储结构。
因此要先定义一个结构体。
此结构体的每个结点都是由数据域data 、左指针域Lchild 、右指针域Rchild 组成,两个指针域分别指向该结点的左、右孩子,若某结点没有左孩子或者右孩子时,对应的指针域就为空。
最后,还需要一个链表的头指针指向根结点。
要注意的是,第一步的时候一定要先定义一个结束标志符号,例如空格键、#等。
当它遇到该标志时,就指向为空。
建立左右子树时,仍然是调用create()函数,依此递归进行下去,直到遇到结束标志时停止操作。
(2)输入二叉树元素输入二叉树时,是按上面所确定的遍历规则输入的。
最后,用一个返回值来表示所需要的结果。
(3)先序遍历二叉树当二叉树为非空时,执行以下三个操作:访问根结点、先序遍历左子树、先序遍历右子树。
(4)中序遍历二叉树当二叉树为非空时,程序执行以下三个操作:访问根结点、先序遍历左子树、先序遍历右子树。
(5)后序遍历二叉树当二叉树为非空时,程序执行以下三个操作:访问根结点、先序遍历左子树、先序遍历右子树。
二叉树遍历 实验报告
数据结构实验报告报告题目: 二叉树的基本操作学生班级:学生姓名: 学号:一. 实验目的1、基本要求: 深刻理解二叉树性质和各种存储结构的特点及适用范围;掌握用指针类型描述、访问和处理二叉树的运算;熟练掌握二叉树的遍历算法;。
2. 较高要求: 在遍历算法的基础上设计二叉树更复杂操作算法;认识哈夫曼树、哈夫曼编码的作用和意义;掌握树与森林的存储与便利。
二.实验学时:课内实验学时: 3学时课外实验学时: 6学时三. 实验题目1. 以二叉链表为存储结构, 实现二叉树的创建、遍历(实验类型: 验证型)1)问题描述:在主程序中设计一个简单的菜单, 分别调用相应的函数功能:1…建立树2…前序遍历树3…中序遍历树4…后序遍历树5…求二叉树的高度6…求二叉树的叶子节点7…非递归中序遍历树0…结束2)实验要求: 在程序中定义下述函数, 并实现要求的函数功能:CreateBinTree(BinTree &T): 按从键盘输入的前序序列, 创建树Preorder(BinTree &T): 前序遍历树(递归)Inorder(BinTree &T): 中序(递归)遍历树Postorder(BinTree &T): 后序遍历树(递归)PostTreeDepth(BinTree &T): 树的高度leaf(BinTree &T):树的叶子节点InorderN(BinTree &T): 中序(非递归)遍历树3)数据结构二叉链表存储数据类型定义typedef struct node{TElemType data;struct node *lchild,*rchild;}BinTNode;元素类型:int CreateBinTree(BinTree &T);void Preorder(BinTree &T);void Inorder(BinTree &T);void Postorder(BinTree &T);void InorderN(BinTree &T);int PostTreeDepth(BinTree &T);int leaf(BinTree &T);2.编写算法实现二叉树的非递归中序遍历和求二叉树高度。
二叉树遍历实验报告
二叉树遍历实验报告二叉树遍历实验报告一、引言二叉树是计算机科学中常用的数据结构之一,它由节点组成,每个节点最多有两个子节点。
二叉树的遍历是指按照一定的规则访问二叉树中的所有节点。
本实验旨在通过实际操作,探索二叉树的三种遍历方式:前序遍历、中序遍历和后序遍历,并分析它们的应用场景和性能特点。
二、实验方法1. 实验环境本实验使用Python编程语言进行实现,并在Jupyter Notebook中运行代码。
2. 实验步骤(1)定义二叉树节点类首先,我们定义一个二叉树节点类,该类包含节点值、左子节点和右子节点三个属性。
(2)构建二叉树在主函数中,我们手动构建一个二叉树,包含多个节点,并将其保存为根节点。
(3)实现三种遍历方式通过递归的方式,实现二叉树的前序遍历、中序遍历和后序遍历。
具体实现过程如下:- 前序遍历:先访问根节点,然后递归遍历左子树,最后递归遍历右子树。
- 中序遍历:先递归遍历左子树,然后访问根节点,最后递归遍历右子树。
- 后序遍历:先递归遍历左子树,然后递归遍历右子树,最后访问根节点。
(4)测试遍历结果在主函数中,我们调用实现的三种遍历方式,对构建的二叉树进行遍历,并输出结果。
三、实验结果与分析经过实验,我们得到了二叉树的前序遍历、中序遍历和后序遍历的结果。
以下是我们的实验结果及分析:1. 前序遍历结果前序遍历结果为:A - B - D - E - C - F - G前序遍历的应用场景包括:复制整个二叉树、计算二叉树的深度和宽度等。
前序遍历的时间复杂度为O(n),其中n为二叉树的节点数。
2. 中序遍历结果中序遍历结果为:D - B - E - A - F - C - G中序遍历的应用场景包括:二叉搜索树的中序遍历可以得到有序的节点序列。
中序遍历的时间复杂度为O(n),其中n为二叉树的节点数。
3. 后序遍历结果后序遍历结果为:D - E - B - F - G - C - A后序遍历的应用场景包括:计算二叉树的高度、判断二叉树是否对称等。
数据结构二叉树遍历实验报告
数据结构二叉树遍历实验报告正文: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. 实验原理2.1 二叉树二叉树是一种特殊的树状数据结构,它的每个节点最多只能有两个子节点。
二叉树可以为空树,也可以是由根节点、左子树和右子树组成的非空树。
2.2 遍历算法二叉树的遍历算法包括前序遍历、中序遍历和后序遍历。
- 前序遍历:先访问根节点,然后依次递归访问左子树和右子树。
- 中序遍历:先递归访问左子树,然后访问根节点,最后递归访问右子树。
- 后序遍历:先递归访问左子树,然后递归访问右子树,最后访问根节点。
3. 实验过程3.1 数据结构设计首先,我们需要设计表示二叉树的数据结构。
在本次实验中,二叉树的每个节点包含三个成员变量:值、左子节点和右子节点。
我们可以使用面向对象编程语言提供的类来实现。
具体实现如下:```pythonclass TreeNode:def __init__(self, val=0, left=None, right=None): self.val = valself.left = leftself.right = right```3.2 前序遍历算法前序遍历算法的实现主要包括以下步骤:1. 若二叉树为空,则返回空列表。
2. 创建一个栈,用于存储遍历过程中的节点。
3. 将根节点入栈。
4. 循环执行以下步骤,直到栈为空:- 弹出栈顶节点,并将其值添加到结果列表中。
- 若当前节点存在右子节点,则将右子节点压入栈。
- 若当前节点存在左子节点,则将左子节点压入栈。
具体实现如下:```pythondef preorderTraversal(root):if not root:return []stack = []result = []stack.append(root)while stack:node = stack.pop()result.append(node.val)if node.right:stack.append(node.right)if node.left:stack.append(node.left)return result```3.3 中序遍历算法中序遍历算法的实现主要包括以下步骤:1. 若二叉树为空,则返回空列表。
二叉树的遍历实验报告(二)
二叉树的遍历实验报告(二)引言:本实验报告是对二叉树的遍历进行实验,并对实验结果进行分析和总结。
二叉树的遍历是指按照某种顺序遍历二叉树中的节点,分为三种遍历方式:前序遍历、中序遍历和后序遍历。
本实验通过设计并实现相应的算法,对三种遍历方式进行实验,并比较它们在不同情况下的效率和应用场景。
一、前序遍历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. 从实际使用场景上看,前序遍历适合用于打印二叉树的结构、以及复制整棵树等;中序遍历适合用于查找二叉搜索树中的某个值;后序遍历适合用于计算二叉树中节点的高度或深度等。
二叉树的建立和遍历实验报告
二叉树的建立和遍历实验报告一、引言(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本次实验通过实现二叉树的递归和非递归遍历算法,加深了对二叉树的理解,并熟悉了遍历算法的实现方法。
实现二叉树的各种遍历算法实验报告
实现二叉树的各种遍历算法实验报告一实验题目: 实现二叉树的各种遍历算法二实验要求:2.1:(1)输出二叉树 b(2)输出H节点的左右孩子节点值(3)输出二叉树b 的深度(4)输出二叉树 b的宽度(5)输出二叉树 b的节点个数(6)输出二叉树 b的叶子节点个数(7)释放二叉树 b2.2:(1)实现二叉树的先序遍历(2)实现二叉树的中序遍历(3)实现二叉树的后序遍历三实验内容:3.1 树的抽象数据类型:ADT Tree{数据对象D:D是具有相同特性的数据元素的集合。
数据关系R:若D为空集,则称为空树;若D仅含有一个数据元素,则R为空集,否则R={H},H是如下二元关系:(1) 在D中存在唯一的称为根的数据元素root,它在关系H下无前驱;(2) 若D-{root}≠NULL,则存在D-{root}的一个划分D1,D2,D3, …,Dm(m>0),对于任意j≠k(1≤j,k≤m)有Dj∩Dk=NULL,且对任意的i(1≤i≤m),唯一存在数据元素xi∈Di有<root,xi>∈H;(3) 对应于D-{root}的划分,H-{<root,xi>,…,<root,xm>}有唯一的一个划分H1,H2,…,Hm(m>0),对任意j≠k(1≤j,k≤m)有Hj∩Hk=NULL,且对任意i(1≤i≤m),Hi是Di上的二元关系,(Di,{Hi})是一棵符合本定义的树,称为根root的子树。
基本操作P:InitTree(&T);操作结果:构造空树T。
DestroyTree(&T);初始条件:树T存在。
操作结果:销毁树T。
CreateTree(&T,definition);初始条件:definition给出树T的定义。
操作结果:按definition构造树T。
ClearTree(&T);初始条件:树T存在。
操作结果:将树T清为空树。
TreeEmpty(T);初始条件:树T存在。
数据结构二叉树遍历实验报告[1]简版
数据结构二叉树遍历实验报告数据结构二叉树遍历实验报告实验目的本实验旨在通过二叉树的遍历方法,加深对二叉树结构的理解,并掌握其遍历的实现方法。
实验内容实验内容包括以下两个部分:1. 实现二叉树的先序遍历方法;2. 实现二叉树的中序遍历方法。
实验原理和实现方法1. 先序遍历先序遍历即从根节点开始,先输出当前节点的值,然后先序遍历左子树,最后先序遍历右子树。
先序遍历的实现方法有递归和迭代两种。
递归实现递归实现的核心是先输出当前节点的值,并递归调用函数对左子树和右子树进行先序遍历。
以下是递归实现的伪代码示例:```pythondef preOrderTraversal(node):if node is None:returnprint(node.value)preOrderTraversal(node.left)preOrderTraversal(node.right)```迭代实现迭代实现需要借助栈来保存节点的信息。
整体思路是先将根节点入栈,然后循环执行以下步骤:弹出栈顶节点并输出,将栈顶节点的右子节点和左子节点依次入栈。
当栈为空时,遍历结束。
以下是迭代实现的伪代码示例:```pythondef preOrderTraversal(node):if node is None:returnstack = [node]while stack:curr = stack.pop()print(curr.value)if curr.right:stack.append(curr.right)if curr.left:stack.append(curr.left)```2. 中序遍历中序遍历即从根节点开始,先中序遍历左子树,然后输出当前节点的值,最后中序遍历右子树。
中序遍历的实现方法同样有递归和迭代两种。
递归实现递归实现的核心是先中序遍历左子树,并输出当前节点的值,最后递归调用函数对右子树进行中序遍历。
以下是递归实现的伪代码示例:```pythondef inOrderTraversal(node):if node is None:returninOrderTraversal(node.left)print(node.value)inOrderTraversal(node.right)```迭代实现迭代实现同样需要借助栈来保存节点的信息。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告
题目:二叉树的遍历及应用
院系:数学系
专业:数学与应用数学
学号: **********
姓名:***
一、实验名称:二叉树的遍历及应用
二、实验日期:2012年11月14日
三、实验要求:编程实现二叉树的建立并对其进行遍历
四、实验目的:
1、掌握二叉树链式存储结构的类型定义及实现;
2、掌握二叉树链式存储结构的各类基本运算方法;
3、掌握二叉树各个重要性质在解决实际问题中的应用;
4、掌握二叉树的分析方法、解决方法,从而提高实际编程能
力及程序调试能力。
五、实验内容
1、创建二叉树;
2、用递归方法实现二叉树的各种遍历。
六、程序代码
#include<stdio.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define Stack_Size 50
typedef struct Node
{
char data;
struct Node *LChild;
struct Node *RChild;
}BiTNode,*BiTree;
typedef BiTree StackElementType;
typedef struct
{
StackElementType elem[Stack_Size];
int top;
}SeqStack;
//初始化
void InitStack(SeqStack *S)
{
S->top=-1;
}
//进栈
int Push(SeqStack *S,StackElementType x) { if(S->top==Stack_Size-1) return(FALSE); S->top++;
S->elem[S->top]=x;
return(TRUE);
}
//出栈
int Pop(SeqStack *S,StackElementType *x) {
if(S->top==-1)
return(FALSE);
else
{
*x=S->elem[S->top];
S->top--;
return(TRUE);
}
}
//先序遍历
void PreOrder(BiTree root)
{
if(root!=NULL)
{
printf("%c",root->data);
PreOrder(root->LChild);
PreOrder(root->RChild);
}
}
//中序遍历
void InOrder(BiTree root) { if(root!=NULL)
{ InOrder(root->LChild); printf("%c",root->data); InOrder(root->RChild);
}
}
//后序遍历
void PostOrder(BiTree root) {
if(root!=NULL)
{
PostOrder(root->LChild); PostOrder(root->RChild); printf("%c",root->data);
}
}
//创建二叉链表
void CreateBiTree(BiTree *bt)
{
char ch;
ch=getchar();
if(ch=='.') *bt=NULL;
else
{
*bt=(BiTree)malloc(sizeof(BiTNode)); (*bt)->data=ch;
CreateBiTree(&((*bt)->LChild)); CreateBiTree(&((*bt)->RChild));
}
}
//后序遍历球二叉树高度
int PostTreeDepth(BiTree bt)
{
int hl,hr,max;
if(bt!=NULL)
{
hl=PostTreeDepth(bt->LChild);
hr=PostTreeDepth(bt->RChild);
max=hl>hr?hl:hr;
return(max+1);
}
else return(0);
}
//横向打印二叉树
void PrintTree(BiTree bt,int nLayer) {
int i;
if(bt==NULL) return;
PrintTree(bt->RChild,nLayer+1);
for( i=0;i<nLayer;i++)
printf(" ");
printf("%c\n",bt->data);
PrintTree(bt->LChild,nLayer+1);
}
void main()
{
BiTree root;
printf("请输入序列:\n"); CreateBiTree(&root);
printf("输出结果为:\n");
printf("先序遍历结果:\n"); PreOrder(root);
printf("\n中序遍历结果:\n"); InOrder(root);
printf("\n后序遍历结果:\n"); PostOrder(root);
printf("\n二叉树的深度:\n");
printf("%d",PostTreeDepth(root)); printf("\n横向打印二叉树结果:\n"); PrintTree(root,5);
}
七、成果展示。