实验二_二叉树的建立与遍历
- 格式:doc
- 大小:429.50 KB
- 文档页数:5
二叉树的建立与遍历实验报告(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,程序运行了一段时间没有结果,经过检查,发现了这个错误。
树和图的遍历实验报告2011-4-9实验题目:树和图的遍历实验目的:1.实现二叉树的建立与先序,中序,后序,层次遍历2.选择建立图的类型;根据所选择的类型用邻接矩阵的存储结构构建图;对图进行深度优先搜索和广度优先搜索;实验内容:一、算法描述:(1)二叉树的建立要建立一棵树就要有根节点和两棵子树。
两棵子树的建立同样需要这样的过程。
建立二叉树的过程也是遍历树的过程,实验要求以前序遍历的方式输入数据,因此我们也应按前序遍历的顺序,动态申请存储空间的方式建立这棵树并返回根节点的指针。
BiTNode *CreateBiTree(BiTNode *T){char ch;if((ch=getchar())==' ') T=NULL;else if(ch!='\n'){if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))exit(1);T->data=ch;T->lchild=CreateBiTree(T->lchild);T->rchild=CreateBiTree(T->rchild);}return T;}(2)二叉树的遍历遍历作为二叉树所有操作的基础,因此我把它放在二叉树建立的前面。
前序遍历:即按照根节点,左子树,右子树的顺序访问。
具体操作:遇到节点,立即打印根节点的值,然后访问左子树,再访问右子树。
对左子树和右子树的访问也进行相同的操作。
void PreOrderTraverse(BiTree T){if(T){putchar(T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}同理,易得中序遍历,后序遍历的操作。
//中序遍历二叉树void InOrderTraverse(BiTree T){if(T){InOrderTraverse(T->lchild);putchar(T->data);InOrderTraverse(T->rchild);}}//后序遍历二叉树void PostOrderTraverse(BiTree T){if(T){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);putchar(T->data);}}层次遍历:先访问的节点,其孩子节点也必然优先访问,这就用到了队列的思想。
数据结构实验报告———二叉树的建立及其遍历一、实验目的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);}三、调试分析在调这个程序是并没有遇到很大的困难,就是在输入一颗二叉树时,遇到了一点麻烦。
二叉树的建立和遍历的实验报告篇一:二叉树的建立及遍历实验报告实验三:二叉树的建立及遍历【实验目的】(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.需求分析(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.掌握对二叉树每种操作的具体实现,学会利用递归方法编写对二叉树这种递归数据结构进展处理的算法.二、实验要求1.认真阅读和掌握和本实验相关的教材内容.2.编写完整程序完成下面的实验内容并上机运行.3.整理并上交实验报告.三、实验内容1.编写程序任意输入二叉树的结点个数和结点值,构造一棵二叉树,采用三种递归遍历算法<前序、中序、后序>对这棵二叉树进展遍历并计算出二叉树的高度.2 .编写程序生成下面所示的二叉树,并采用先序遍历的非递归算法对此二叉树进展遍历.四、实验步骤〔描述实验步骤与中间的结果或现象.在实验中做了什么事情,怎么做的,发生的现象和中间结果〕第一题#include "stdafx.h"#include"iostream.h"#include"stdlib.h"#include"stdio.h"#include<stack>using namespace std;#define NULL 0#define OK 1#define OVERFLOW -1typedef int Status;typedef struct node{char data;struct node *lchild;struct node *rchild;}*bitree;int k=0;int depth<bitree T>//树的高度{if<!T>return 0;else{int m=depth<T->lchild>;int n=depth<T->rchild>;return <m>n?m:n>+1;}}//先序,中序建树struct node *create<char *pre,char *ord,int n> {struct node * T;int m;T=NULL;if<n<=0>{return NULL;}else{m=0;T=new<struct node>;T->data=*pre;T->lchild=T->rchild=NULL;while<ord[m]!=*pre>m++;T->lchild=create<pre+1,ord,m>;T->rchild=create <pre+m+1,ord+m+1,n-m-1>; return T;}}//中序递归遍历void inorder<struct node *T>{if<!T>return;else{inorder<T->lchild >;cout<<T->data;inorder<T->rchild >;}}void inpre<struct node *T> {if<!T>return;else{cout<<T->data;inpre<T->lchild >;inpre<T->rchild >;}}void postorder<struct node *T> {if<!T>return;else{postorder <T->lchild >; postorder <T->rchild >;cout<<T->data;}}//先序非递归遍历void inpre1<struct node *T> {struct node *p;struct node *stack[20];int top=0;p=T;cout<<"非递归先序";while<p||top!=0>{while <p>{stack[top++]=p;cout<<p->data;p=p->lchild;}p=stack[--top];p=p->rchild ;}//中序非递归遍历void inorder1<struct node *T>{struct node *p;struct node *stack[20];int top=0;p=T;cout<<"非递归中序";while<p||top!=0>{while <p>{stack[top++]=p;p=p->lchild ;}p=stack[--top];cout<<p->data;p=p->rchild ;}}//主函数int main<>{bitree T;char pre[30],ord[30];int n,m;gets<pre>;gets<ord>;n=strlen<pre>;T=create<pre,ord,n>;inpre<T>;cout<<endl;postorder <T>;cout<<endl;inorder<T>;cout<<endl;inpre1<T>;cout<<endl;inorder1<T>;cout<<endl;m=depth<T>;cout<<"二叉树高度为:"<<m<<endl; return 0;第二题:#include "stdafx.h"#include"iostream.h"#include"stdlib.h"#include"stdio.h"#include<stack>using namespace std;#define NULL 0#define OK 1#define OVERFLOW -1typedef int Status;typedef struct node{char data;struct node *lchild;struct node *rchild;}*bitree;Status Create<bitree &T> //按先序次序输入二叉树中结点的值,!表示空树{char e;cout<<"输入树的元素:"<<endl;cin>>e;if<e=='!'> T=NULL;else{if<!<T=<node *>malloc<sizeof<node>>>>exit <OVERFLOW>;T->data=e;Create<T->lchild>;Create<T->rchild>;}return OK;}//先序非递归遍历void inpre<struct node *T>{struct node *p;struct node *stack[20];int top=0;p=T;cout<<"非递归先序";while<p||top!=0>{while <p>{stack[top++]=p;cout<<p->data;p=p->lchild;}p=stack[--top];p=p->rchild ;}}//主函数int main<>{bitree T;Create<T>;cout<<"输出的元素为:"<<endl;inpre<T>;return 0;}五实验结果第一题:输入先序为-+a*b%cd/ef输入后序为a+b*c%d-e/f得出结果:输入先序为abcd输入后序为bacd得出结果:第二题:六实验总结1 为什么头文件只用#include <iostream>using namespace std;不行,要把所写到的程序中所包含的头文件头写进去..于是就在想,反正以后不管这些头文件有没用到头写进去,省得一大堆麻烦.2 用先序建树的时候虽然只要输入一个字符串,但是要判断空树的情况.比拟麻烦.我个人觉得用先序与中序联合建树比拟简单.因为这样只要输入先序与中序就可以建树了.3 对于三种遍历的过程,要是用递归写的就根据书上所给出的遍历步骤做稍微的调整就好了.至于非递归的三种遍历,中序最为简单,用一个栈就可以完成了,思路是边进栈边收索左孩子,直到左孩子为空的时候才开始进展出栈输出再收索右孩子的操作.而非递归的先序遍历根本可以和中序一样,建立一个队列,在进栈的时候队列也进同样的元素,但是不与栈一起出栈.而是在最后进栈出栈完毕的时候,对队列进展出队列操作即可.4 二叉树对于进展表达式的前缀,中缀和后缀的表示有明显的优势,既方便,又容易理解.其先序,中序和后序分别对应这表达式的前缀,中缀和后缀.5 在建树与进展树的遍历的时候一定要理解其建树与遍历的整个过程.不然就会连为什么这样做都不知道.在遍历树的时候最常用到的就是栈的结构了〔非递归〕. 七:思考与提高1.如何计算二叉链表存储的二叉树中度数为1的结点数?答:int countleaf<bitree t,int count>{if<!<t->lchild> &&<t->rchild>count++;else if <<t->lchild>&&!<t->rchild>>count++;countleaf<t->lchild>;countleaf<t->rchild>;return count;}2.有—棵以二叉链表存储的二叉树,root指向根结点,p指向二叉树中任一结点,如何求从根结点到p所指结点之间的路径?答:void foundp<bitree t>{if<t==p>{Push<s, t->data>;Pop<s, t->data>;}foundp<t->lchild>;foundp<t->rchid>;}。
实验报告一:预习要求预习树和二叉树的存储结构、以递归为基本思想的相应遍历操作。
二:实验目的1、通过实验,掌握二叉树的建立与存储方法。
2、掌握二叉树的结构特性,以及各种存储结构的特点和适用范围。
3、掌握用指针类型描述、访问和处理二叉树的运算。
4、理解huffman编解码的算法三:实验内容以括号表示法输入一棵二叉树,编写算法建立二叉树的二叉链表结构;编写先序、中序、后序、层次遍历二叉树的算法;编写算法计算二叉树的结点数,叶子结点数,以及二叉树的深度。
四:实验原理及试验方法ADT BinaryTree{数据对象:D:D是具有相同特征的数据元素的集合数据结构:R:若D= 空集,则R=空集,称BinaryTree为空二叉树;若D不等于空集,则R={H},H是如下二元关系:(1)在D中存在唯一的称为根的数据元素root,它在关系H下无前驱;(2)若D-{root}不等于空集,则存在D-{root}={D1,Dr},且D1∩Dr=空集;(3)若D1不等于空集,则D1中存在唯一的元素x1,<root,x1>∈H,且存在D1上的关系H1包含于H;若Dr≠空集,则Dr中存在唯一的元素xr,<root,xr>∈H,且存在Dr上的关系Hr包含于H;H={<root,x1>,<root,xr>,H1,Hr};(4) (D1,{H1})是一颗符合本定义的二叉树,称为根的左子树,(Dr,{Hr})是一颗符合本定义的二叉树,称为根的右子树。
基本操作P:CreateBiTree(&T,definition);初始条件:definition给出二叉树的定义。
操作结果:按definition构造二叉树T。
PreOrderTraverse(T);初始条件:二叉树T存在。
操作结果:先序遍历T 。
InOrderTraverse(T);初始条件:二叉树T存在。
操作结果:中序遍历T。
PostOrderTraverse(T);初始条件:二叉树T存在。
树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构,它们在各种算法和应用中都有广泛的应用。
本实验旨在通过实际操作和观察,深入了解树和二叉树的特性和操作。
二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构,由节点和边组成。
每个节点可以有零个或多个子节点,其中一个节点没有父节点的称为根节点。
树的特点包括层次结构、唯一根节点和无环等。
2. 树的构建在本实验中,我们使用Python语言构建了一棵树。
通过定义节点类和树类,我们可以方便地创建树的实例,并添加节点和连接节点之间的边。
3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
我们在实验中实现了这三种遍历方式,并观察了它们的输出结果。
三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树,每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。
2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。
通过定义节点类和二叉树类,我们可以创建二叉树的实例,并实现插入节点、删除节点和查找节点等操作。
3. 二叉树的应用二叉树在实际应用中有很多用途。
例如,二叉搜索树可以用于实现快速查找和排序算法。
AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。
我们在实验中实现了这些应用,并通过实际操作验证了它们的效果。
四、实验结果与讨论通过实验,我们成功构建了树和二叉树的数据结构,并实现了它们的基本操作。
通过观察和分析实验结果,我们发现树和二叉树在各种算法和应用中的重要性和灵活性。
树和二叉树的特性使得它们适用于解决各种问题,例如搜索、排序、图算法等。
同时,我们也发现了一些问题和挑战,例如树的平衡性和节点的插入和删除操作等。
这些问题需要进一步的研究和优化。
五、总结本实验通过实际操作和观察,深入了解了树和二叉树的特性和操作。
二叉树的创建与遍历的实验总结一、实验目的二叉树是一种重要的数据结构,本实验旨在通过编写程序实现二叉树的创建和遍历,加深对二叉树的理解,并掌握二叉树相关算法。
二、实验原理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()函数遍历左子树和右子树,输出当前节点数据。
二叉树的创建及遍历实验要求:数据元素类型ElemType取float。
1)从键盘按照前序遍历的顺序依次输入二叉树的各元素,创建此二叉树。
2)对该二叉树进行层次遍历,并输出遍历后的序列。
(参照图的广度优先搜索)程序:#include"stdio.h"#include"malloc.h"typedef struct node /* 定义节点类型 */{float data;struct node *lchild,*rchild;}BinTNode;BinTNode* createBinTree() /*前序遍历创建二叉树 */{ BinTNode *t;float a;scanf("%f",&a); /*输入结点的数值域*/if(a==0)t=NULL;/*如果输入结点的数值域为0,则生成空结点*/else{t=(BinTNode *)malloc(sizeof(BinTNode));/*生成新结点*/t->data=a;/*生成新结点的数值域为刚才输入的值*/t->lchild=createBinTree();t->rchild=createBinTree();/*生成结点的左子树和右子树*/}return t;}void levelbintree(BinTNode * bt) /* 层次遍历二叉树,并输出节点值 */{BinTNode *queue[50]; /*定义队列*/int front,rear;if(bt==NULL) return;front=-1;rear=0;queue[rear]=bt;while(front!=rear){front++;printf("%f\n",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 Print_BinTree(BinTNode *T,int i ) // i表示结点所在层次,初次调用时i=0 { int j;if(T->rchild)Print_BinTree(T->rchild,i+1); //函数递归来建立层次。
实验二二叉树的建立与遍历一、实验题目二叉树的建立与遍历二、实验流程图图2.1二叉树建立流程图图2.2先序遍历图2.3中序遍历图2.4后序遍历三、实验程序清单二叉树的建立及遍历程序如下:#include <stdlib.h>#include <stdio.h>#include <malloc.h>typedef struct node1{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*/q->data = x; q->lchild = NULL; q->rchild = NULL;s[i] = q; /*q新结点地址存入s指针数组中*/if(i != 1) /*i = 1,对应的结点是根结点*/{j = i / 2; /*求双亲结点的编号j*/if(i % 2 == 0) s[j]->lchild = q; /*q结点编号为偶数则挂在双亲结点j的左边*/else s[j]->rchild = q;} /*q结点编号为奇数则挂在双亲结点j的右边*/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); }}/*先序遍历二叉树*//*void preorder(BTCHINALR *bt) { if(bt!=NULL){ printf("%c ",bt->data); preorder(bt->lchild);preorder(bt->rchild);}}*//*后序遍历二叉树*//*void postorder(BTCHINALR *bt) { if(bt!=NULL){ postorder(bt->lchild);postorder(bt->rchild);printf("%c ",bt->data); }}*//*主函数单个遍历的调用*/int main () //中序遍历调用{ BTCHINALR *bt;bt=createbt();inorder(bt);}四、实验数据结果1、中序遍历结果如下:图2.5 中序遍历2、先序遍历结果如下:图2.6 先序遍历3、后序遍历结果如下:图2.7 后序遍历五、实验体会通过实验二叉树的建立及遍历,更加理解了malloc函数创建内存空间,P=(JD*)malloc(n*sizeof(JD))分配size个连续的内存空间,每输入一个字符就需要创建一个内存空间根据需要进行创建。
二叉树的基本操作实验报告二叉树的基本操作实验报告引言:二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。
二叉树的基本操作包括创建、遍历、插入和删除等。
本实验旨在通过实践来深入了解二叉树的基本操作,并通过实验结果验证其正确性和有效性。
一、创建二叉树创建二叉树是二叉树操作中的第一步。
在本实验中,我们使用了递归算法来创建二叉树。
递归算法是一种重要的算法思想,通过将问题划分为更小的子问题来解决复杂的问题。
在创建二叉树时,我们首先创建根节点,然后递归地创建左子树和右子树。
二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点,然后递归遍历左子树和右子树;中序遍历先递归遍历左子树,然后访问根节点,最后递归遍历右子树;后序遍历先递归遍历左子树和右子树,最后访问根节点。
三、插入节点插入节点是向二叉树中添加新节点的操作。
插入节点的过程需要遵循二叉树的特性,即左子节点的值小于父节点的值,右子节点的值大于父节点的值。
在插入节点时,我们需要找到合适的位置,将新节点插入到正确的位置上。
四、删除节点删除节点是从二叉树中移除节点的操作。
删除节点的过程相对复杂,需要考虑多种情况。
如果要删除的节点是叶子节点,直接删除即可。
如果要删除的节点只有一个子节点,将其子节点连接到父节点上。
如果要删除的节点有两个子节点,我们需要找到其后继节点或前驱节点来替代被删除的节点。
实验结果:通过实验,我们成功地实现了二叉树的基本操作。
创建二叉树的递归算法能够正确地创建出符合要求的二叉树。
遍历二叉树的算法能够按照指定的顺序遍历每个节点。
插入节点和删除节点的操作也能够正确地修改二叉树的结构。
讨论与总结:二叉树的基本操作是数据结构中的重要内容,对于理解和应用其他数据结构具有重要意义。
通过本次实验,我们深入了解了二叉树的创建、遍历、插入和删除等操作,并通过实验验证了其正确性和有效性。
竭诚为您提供优质文档/双击可除二叉树的建立和遍历的实验报告篇一:二叉树遍历实验报告数据结构实验报告报告题目:二叉树的基本操作学生班级:学生姓名:学号:一.实验目的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二叉树类。
数据结构课内实验报告书一、实验题目:二叉树的创建与遍历二、实验目的:通过本次实验,熟练掌握二叉树的存储结构定义及其遍历算法的实现,学会利用栈编写非递归的遍历算法。
三、实验要求:建立一棵用二叉链表方式存储的二叉树,并对其进行遍历(先序、中序和后序),打印输出遍历结果。
要求:从键盘接受扩展先序序列,以二叉链表作为存储结构,建立二叉树,并将遍历结果打印输出。
采用递归和非递归两种方法实现。
四、设计与实现过程(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六、技巧与体会通过实验,锻炼了自己的能力,加深了自己对有关知识的理解。
二叉树的遍历实验报告(二)引言:本实验报告是对二叉树的遍历进行实验,并对实验结果进行分析和总结。
二叉树的遍历是指按照某种顺序遍历二叉树中的节点,分为三种遍历方式:前序遍历、中序遍历和后序遍历。
本实验通过设计并实现相应的算法,对三种遍历方式进行实验,并比较它们在不同情况下的效率和应用场景。
一、前序遍历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. 二叉树的查找
4. 二叉树的删除
实验结果:
1. 建立一颗二叉树,根节点为A,左子树B,右子树C,B的左子树D,右子树E,C的左子树F,右子树G。
结构如下:
A
/ \
B C
/ \ / \
D E F G
2. 对上述二叉树先进行中序遍历:DBEAFCG,再进行前序遍历:ABDECFG,最后进行后序遍历:DEBFGCA。
3. 在上述二叉树中查找元素G,并输出其父节点元素C。
4. 删除上述二叉树中的元素F,再对其进行中序遍历,结果为DBEACG。
结论:
通过这次实验,我们掌握了二叉树的基本操作方法,对于理解和分析算法、编写系统和软件工程都具有重要的意义。
同时,在实践中我们也深刻地认识到了二叉树操作的复杂性和局限性,这需要我们在实际应用中加以考虑和综合利用,才能发挥其最大的价值和作用。
实验二二叉树的建立和遍历一、实验目的1.掌握二叉树的建立算法2.掌握二叉树的前序、中序和后序遍历算法。
二、实验环境操作系统和C语言系统三、预习要求复习二叉树的生成及遍历算法,编写完整的程序。
四、实验内容要求采用二叉链表作为存储结构,完成二叉树的建立,前序、中序和后序遍历的操作,求所有叶子及结点总数的操作等。
具体实现要求:分别利用前序遍历、中序遍历、后序遍历所建二叉树。
五、算法实现#include <stdio.h>#include <stdlib.h>typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;} BiTNode,*BiTree;BiTree CreateBiTree(){char x;BiTree T;scanf("%c",&p);if(p==' ')T=NULL;else{ T=(BiTNode *)malloc(sizeof(BiTNode));T->data=p;T->lchild=CreateBiTree();T->rchild=CreateBiTree(); }return (T);}void PreOrder(BiTree T){if(T!=NULL){ printf("%c",T->data); PreOrder(T->lchild); PreOrder(T->rchild); }}void MidOrder(BiTree T){if(T!=NULL){ MidOrder(T->lchild); printf("%c",T->data); MidOrder(T->rchild); }}void PostOrder(BiTree T){if(T!=NULL){ PostOrder(T->lchild); PostOrder(T->rchild); printf("%c",T->data); }}void main(){BiTree Ta; Ta=CreateBiTree();printf("先序遍历:"); printf("\n"); PreOrder(Ta); printf("\n");printf("中序遍历:"); printf("\n"); MidOrder(Ta); printf("\n");printf("后序遍历:"); printf("\n"); PostOrder(Ta); printf("\n");}六、思考题本实验中使用了递归的方法创建二叉树,通过翻看书本和查阅其他资料,了解到使用非递归方法来创建二叉树,大致方法是使用队列,按照层次次序来创建一棵二叉树,具体是:先将该二叉树扩充为完全二叉树,再按层次次序依次存储到数组单元,即顺序存储。
实验二二叉树的操作
一、实验目的
1、熟悉二叉树结点的结构和对二叉树的基本操作;
2、掌握对二叉树每一种操作的具体实现;
3、学会递归方法和非递归方法实现二叉树的运算某重操作。
二、实验要求
1.认真阅读理解每一种操作算法。
2.编写主程序文件,建立二叉树、遍历二叉树(三种方法之一)。
3.写出自己运行的结果。
画出自己建立的二叉树,给出输入序列、输出结果。
二、实验内容
(1)通过键盘输入的扩充二叉树的层次遍历序列, 建立二叉树(序列:2,5,6,0,0,10,11,0,0,0,0 )。
(设二叉树结点的数据为int型,其中扩充结点用'0'号表示。
)
然后按中序和后序输出此二叉树,(附加:求该树的叶结点个数和度数为2的结点个数。
) 分析程序中变量r1,r2,q的作用?
(2)画出自己的一颗二叉树,给出输入序列;把中序或后序的遍历算法改为非递归算法;给出遍历序列。
三,实验结果
1. 程序实现:
#include"stdio.h"
#include"malloc.h"
typedef struct treenode
{int data;
struct treenode *lchild,*rchild;
}TREENODE,*TREENODEPTR;
#define N 50
void creattree(TREENODEPTR * root)
{int value,r1,r2;
TREENODEPTR t ,q[N];
scanf("%d",&value);
if (value)
{*root=( TREENODEPTR)malloc(sizeof(TREENODEPTR));
(*root)->data=value;
r2=r1=1;
q[r1]=*root;
}
else
{printf("input error\n");return;}
while(r2<=r1)
{t=q[r2];r2++;
scanf("%d",&value);
if (value==0)
t->lchild=NULL;
else
{t->lchild=( TREENODEPTR)malloc(sizeof(TREENODEPTR));
t->lchild->data=value;
r1++;q[r1]=t->lchild;
}
scanf("%d",&value);
if (value==0)
t->rchild=NULL;
else
{ t->rchild=( TREENODEPTR)malloc(sizeof(TREENODEPTR));
t->rchild->data=value;
r1++;q[r1]=t->rchild;
}
}
}
/*非递归中序遍历二叉树*/
void InOrder(TREENODEPTR root)
{
TREENODEPTR q[N];
int top=0;
TREENODEPTR p;
p=root;
do{
while(p!=NULL)
{
if(top>N)
return;
top=top+1;
q[top]=p;
p=p->lchild;
};
if(top!=0)
{
p=q[top];
top=top-1;
printf("%3d",p->data);
p=p->rchild;
}
}while(p!=NULL||top!=0);
}
/*非递归后序遍历二叉树*/
void PostOrder(TREENODEPTR root) {
TREENODEPTR p,r,q[N] ;
int top=0;
r=NULL;
p=root;
while(p!=NULL||top!=0)
{
while(p!=NULL)
{top++;
if(top>=N)
return;
q[top]=p;p=p->lchild;
}
if(top>0)
{p=q[top];
if((p->rchild==NULL)||(p->rchild==r)) {printf("%3d",p->data);
r=p;
top--;
p=NULL;
}
else
p=p->rchild;
}
}
}
main()
{TREENODEPTR root;
root=NULL;
printf("输入的扩充二叉树的层次遍历序列为:\n");
creattree(&root);
printf("非递归中序遍历二叉树:\n");
InOrder(root);
printf("\n");
printf("非递归后序遍历二叉树:\n");
PostOrder(root);
printf("\n");
}
3.变量r1的作用是:栈尾
变量r2的作用是:栈头
变量q 的作用是:设置一个栈,用以保留结点指针。
4.二叉树图形如下所示
1
3
2
10
7
5
11
15。