计算机软件实验报告(2)二叉树的建立与遍历
二叉树的建立及其遍历实验报告
数据结构实验报告———二叉树的建立及其遍历一、实验目的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);}三、调试分析在调这个程序是并没有遇到很大的困难,就是在输入一颗二叉树时,遇到了一点麻烦。
二叉树的建立与遍历
template<classEntry>
classBinary_tree {
public:
Binary_tree();
boolempty()const;
voidpreorder(void(*visit)(Entry &));
voidinorder(void(*visit)(Entry &));
voidpostorder(void(*visit)(Entry &));
{
if(sub_root==0)
return0;
intL=recursive_height(sub_root->left);
intR=recursive_height(sub_root->right);
if(L>R)
return1+L;
else
return1+R;
}
template<classEntry>
本科学生课程设计任务书
课程设计题目
二叉树的建立与遍历
学院
软件学院
专业
软件工程
年级
17级
问题描述:
建立一棵二叉树,并对其进行遍历(先序、中序、后序),打印输出遍历结果。
基本要求:
从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立),并采用递归算法对其进行遍历(先序、中序、后序),将遍历结果打印输出。
Binary_node<Entry>::Binary_node(constEntry &x)
{
data=x;
left=0;
right=0;
intsize()const;
二叉树的建立和遍历的实验报告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学时课外实验学时: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二叉树类。
二叉树的建立以及二叉树的遍历
二叉树的建立以及二叉树的遍历网一0925112011 黄志坚试验要求:用一个数组建立起一棵以指针链表为数据结构的二叉树,并对其进行前序遍历,中序遍历,后序遍历. 实验工具:visual studio 2005实验方法:1.首先,应该先定义每个二叉树的节点的属性,由于我们使用的是链表式的二叉树,所以每个节点都应该有一个数据域,以及一个指向孩子的左指针,指向右孩子的右指针.2.接下来当我们定义好二叉树的结构后,就可以建立一颗空二叉树了数据,空二叉树的左孩子为NULL,右孩子也应该为NULL,这也是同样作为本算法判断一颗二叉树是否为空的方法.3.接下来最重要的可能就是往一棵树里面添加元素了,Creattree()函数的接口参数传递了一个树的根节点指针,以及一个数据.这个存放的数据是待会用来放进二叉树的数据.这里的二叉树也叫做排序二叉树,就是比跟节点小的数据放在树的左边,比根节点大的排在右边,这样子对其进无限次比较,知道其要比较的节点为空,那么就将这个元素插入到该位置上,那么,每次插入一个数据,待所有的数据都已经插入完毕的时候,这棵树也就建立完毕了.4.对其进行各种排序,使用递归排序,这里也就不太对赘述了.因为课堂上已经讲的太多了.具体代码:// 二叉树建立及索引.cpp : 定义控制台应用程序的入口点。
//#include"stdafx.h"int _tmain(int argc, _TCHAR* argv[]){return 0;}#include<iostream>#include<sstream>using namespace std;struct Tree//定义树的每个节点的属性{int data;Tree *Lchild,*Rchild;};void inittree(int data,Tree *root) //定义树{root->Lchild=NULL; //树的左孩子和有孩子都应该为空才是正确的root->Rchild=NULL;root->data=data;}void Creattree(int data,Tree *root) //往树里面加入元素{Tree *temp;Tree *temproot;Tree *backup;temp=new Tree;temp->data=data;temp->Lchild=NULL;temp->Rchild=NULL;for (temproot=root;temproot!=NULL;){backup=temproot;if (temproot->data<=data){temproot=temproot->Lchild;}else{temproot=temproot->Rchild;}}if (backup->data<=data){backup->Lchild=temp;}else{backup->Rchild=temp;}}void in(Tree *root) //中序遍历{if (root!=NULL){in(root->Lchild);cout<<"["<<root->data<<"] "; //这里应该是放在中间in(root->Rchild);}}void pre(Tree *root) //先序遍历{if (root!=NULL){cout<<"["<<root->data<<"] "; //放在前面pre(root->Lchild);pre(root->Rchild);}}void post(Tree *root) //后续遍历{if (root!=NULL){post(root->Lchild);post(root->Rchild);cout<<"["<<root->data<<"] "; //放在后面}}void level(Tree *root) //层序遍历{const int MAXSIZE=30; //Tree *q[MAXSIZE]; //定义一个树栈int frount=0;int rear=0; //定义栈顶和栈尾指针,这里的两个元素主要是用来申明树栈的使用情况Tree *p;if(root!=NULL) //当栈顶为空的时候,那么就把头指针入栈{q[frount]=root;rear=1;//对于栈的使用情况的变化}while (frount!=rear) //这里的这个循环控制代表的是,当栈还是不为空的时候,那么就要一直执行下去,直到栈里面的所有的元素都已经弹出完毕{//也就是说,这里的所有要遍历的函数都无一例外的会经过栈,入栈,最后出栈的时候进行输出操作p=q[frount];cout<<"["<<p->data<<"] ";if (p->Rchild!=NULL) //这里会相反过来的原因是因为栈的机制原因,栈是先进后出,所以应该是右边先进去,左边先出来,这样子就达到我们的目的了{q[rear]=p->Rchild;rear++;}if (p->Lchild!=NULL) //同理可得{q[rear]=p->Lchild;rear++;//正常操作++}frount++;//如果有进行正常的就++}}void Nonpreorder(Tree *top) //非递归先序遍历{const int maxsize=30; //定义一个数组最大值Tree *temp[maxsize],*temp2; //定义一个树栈,和一个临时变量temp2=top;//给临时变量赋值int tou=-1;//这时候栈的长度为-1代表栈为空,while (temp2!=NULL||tou>-1) //两个满足其中一个就可以一直执行下去了{if (temp2==NULL){temp2=temp[tou--]; //如果临时变量为空,那么取出栈顶指针.temp2=temp2->Rchild; //并且指向右孩子}else{cout<<"["<<temp2->data<<"] "; //输出每一颗子树的根节点temp[++tou]=temp2; //并且把根节点放入树栈中temp2=temp2->Lchild; //指向左孩子}}}void Noninorder(Tree *top) //非递归中序遍历{const int maxsize=30;Tree *temp[maxsize],*temp2; //同理可得,这里就不再太多赘述了temp2=top;int tou=-1;while (temp2!=NULL||tou>-1){if (temp2==NULL){temp2=temp[tou--];cout<<"["<<temp2->data<<"] ";temp2=temp2->Rchild;}else{temp[++tou]=temp2;temp2=temp2->Lchild;}}}void Nonpostorder(Tree *top) //这里是比较难的非递归后序遍历{Tree *stack[30],*temp; //定义一个树的栈,定义一个临时变量用来存放结点变量int flag[30]; //定义每一个对应的栈的头结点的属性int tou=-1,flags; //栈的头是指向-1的.而且,定义个flags代表每个节点的访问状态,当flags属性为时候,代表左右结点都已经访问完毕了.temp=top;do{if (temp!=NULL) //step1{ //当临时变量不为空的时候,,那么执行下列步骤flags=0; //结点属性为,代表左右结点还没有访问完毕stack[++tou]=temp; //把头结点放入栈中flag[tou]=flags; //把相应属性设定好temp=temp->Lchild; //指向下一个元素}else//当temp==空的时候,有可能是已经到达左结点的尽头了,这时候是应该访问右结点了{flags=flag[tou]; //取得结点访问状态temp=stack[tou--]; //取得栈顶元素if (flags==0) //step2{ //如果是等于.那么代表的是这时候右树还没有访问过flags=1; //标记为已经访问stack[++tou]=temp; //再放进去,虽然知道这好像是进行了重复动作,应该可以改进flag[tou]=flags; //把标记放进状态栈里面temp=temp->Rchild; //元素指向右孩子,这时候右孩子应该是作为一颗子树了,所以就又要访问其左结点}else//tep3{cout<<"["<<temp->data<<"] ";//这时候是已经访问完毕的样子了temp=NULL; //置空下,那么下面会直接跳过step1//为什么这里要置空:因为当你连跟节点都已经访问完毕的时候,所以这时候也就是某个子树的哪个左孩子或者右孩子已经访问完毕,那么应该访问某个子树的右孩子或者其跟节点//反正这时候把其看做一个子树已经是访问完毕,意思就这么简单.}}} while (temp!=NULL||tou>-1); //这里只要满足其中一个条件就能继续下去,一般来说,第二个条件都是满足的,而第一个条件是当执行步骤一或者步骤的时候用来执行的} //条件不满足的时候,是栈已经空的情况下,但是这时候可能最后一个头结点还没有访问完毕,temp是不等于null的,因为一旦等于null,那么也就是头结点已经访问完毕了.bool Findnodes(Tree *root,int temp) //找到某个节点,并且返回是否已经找到{if (root==NULL) //如果节点是空的话,那么返回null{return false; //这一步会经历很多次,因为每次都会找到叶子节点的下一个,也就是null节点}else{if (root->data==temp) //对比,如果找到就输出,这里只会进行一次{cout<<"已经找到该元素."<<endl;return true;}else{if (Findnodes(root->Lchild,temp)==true) //利用递归查找下一个子树{return true;}if (Findnodes(root->Rchild,temp)==true) //同理{return true; //找到的话就返回}return false;}}}bool Emptytree(Tree *root) //判断一棵树是否为空,代码简单,不进行一一赘述了{if (root==NULL){cout<<"这是颗空树."<<endl;return true;}else{cout<<"该树非空."<<endl;return false;}}int Deeptree(Tree *root) //返回一棵树的深度,利用递归进行操作{int ld,rd;if (root==NULL){return 0;//}else{ld=Deeptree(root->Lchild); //这里会进行长达树的深度的次数rd=Deeptree(root->Rchild);if (ld>rd){return ld+1; //返回的值加一,因为这个ld不包含头结点的值}else{return rd+1; //同理}}}int Treecount(Tree *root) //算出所有的树的节点个数{if (root==NULL){return 0;//当找到的是树的空节点即实体节点的后面的时候,那么就返回;防止其进行无限循环}else{return Treecount(root->Lchild)+Treecount(root->Rchild)+1;//返回左孩子的节点个数以及右孩子的节点个数}}int Treechildcount(Tree *root){if(root==NULL) //这一步同样非常重要,因为没有这个会导致指针越界,而产生不可估量的程序崩溃{return 0;}else{if (root->Lchild==NULL&&root->Rchild==NULL)//当左孩子和右孩子都同时为空的时候,那么,就是子节点的意思了{return 1;}else{return (Treechidcount(root->Lchild)+Treechidcount(root->Rchild));//如果不为空,那么就继续下面的循环}}}void main()//主测试函数{int a[]={2,7,6,1,9,4,8,3};Tree *root=new Tree;inittree(a[0],root);for (int i=1;i<8;i++){Creattree(a[i],root);}in(root);cout<<endl;Noninorder(root);cout<<endl;pre(root);cout<<endl;Nonpreorder(root);cout<<endl;post(root);cout<<endl;Nonpostorder(root);cout<<endl;level(root);cout<<endl;Findnodes(root,100);cout<<endl;Emptytree(root);cout<<endl;cout<<"该树深度为"<<Deeptree(root)<<endl;cout<<"该树结点为"<<Treecount(root)<<endl;cout<<"该树孩子结点为"<<Treechildcount(root)<<endl;system("pause");}数据截图:。
二叉树的建立和遍历实验报告
二叉树的建立和遍历实验报告一、引言(100字)二叉树是一种常见的数据结构,它由根节点、左子树和右子树组成,具有递归性质。
本次实验的目的是了解二叉树的建立过程和遍历算法,以及熟悉二叉树的相关操作。
本实验采用C语言进行编写。
二、实验内容(200字)1.二叉树的建立:通过输入节点的值,逐个建立二叉树的节点,并通过指针连接起来。
2.二叉树的遍历:实现二叉树的三种常用遍历算法,即前序遍历、中序遍历和后序遍历。
三、实验过程(400字)1.二叉树的建立:首先,定义二叉树的节点结构,包含节点值和指向左右子树的指针;然后,通过递归的方式,依次输入节点的值,创建二叉树节点,建立好节点之间的连接。
2.二叉树的前序遍历:定义一个函数,实现前序遍历的递归算法,先输出当前节点的值,再递归遍历左子树和右子树。
3.二叉树的中序遍历:同样,定义一个函数,实现中序遍历的递归算法,先递归遍历左子树,再输出当前节点的值,最后递归遍历右子树。
4.二叉树的后序遍历:同样,定义一个函数,实现后序遍历的递归算法,先递归遍历左子树和右子树,再输出当前节点的值。
四、实验结果(300字)通过实验,我成功建立了一个二叉树,并实现了三种遍历算法。
对于建立二叉树来说,只要按照递归的思路,先输入根节点的值,再分别输入左子树和右子树的值,即可依次建立好节点之间的连接。
建立好二叉树后,即可进行遍历操作。
在进行遍历算法的实现时,我首先定义了一个函数来进行递归遍历操作。
在每一次递归调用中,我首先判断当前节点是否为空,若为空则直接返回;若不为空,则按照特定的顺序进行遍历操作。
在前序遍历中,我先输出当前节点的值,再递归遍历左子树和右子树;在中序遍历中,我先递归遍历左子树,再输出当前节点的值,最后递归遍历右子树;在后序遍历中,我先递归遍历左子树和右子树,再输出当前节点的值。
通过运行程序,我成功进行了二叉树的建立和遍历,并得到了正确的结果。
可以看到,通过不同的遍历顺序,可以获得不同的遍历结果,这也是二叉树遍历算法的特性所在。
实验报告 实验二 二叉树的建立和遍历
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. 非递归方法除了递归方法,我们还可以使用非递归方法创建二叉树。
计算机软件实验报告(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四、实验心得体会通过这次实验,锻炼了自己编程的能力,加深了自己对有关知识的理解。
二叉树的创建与遍历的实验总结
二叉树的创建与遍历的实验总结一、实验目的二叉树是一种重要的数据结构,本实验旨在通过编写程序实现二叉树的创建和遍历,加深对二叉树的理解,并掌握二叉树相关算法。
二、实验原理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)存储结构定义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六、技巧与体会通过实验,锻炼了自己的能力,加深了自己对有关知识的理解。
二叉树的创建与遍历实验完整word版二叉树建立与遍历实验报告范文c语言编写
二叉树的创建与遍历实验完整word版二叉树建立与遍历实验报告范文c语言编写级班年月日姓名学号_1.实验题目建立一棵二叉树,并对其进行遍历(先序、中序、后序),打印输出遍历结果。
2.需求分析本程序用VC编写,实现建立一棵二叉树的功能,并对其进行遍历(先序、中序、后序),并且打印输出遍历结果。
①输入的形式和输入值的范围:输入二叉树的先序,当其结点为空时,需要输入#。
(输入的先序仅含字母和#)②输出的形式:输出二叉树的先序、中序、后序。
③程序所能达到的功能:实现建立一棵二叉树的功能,并对其进行遍历(先序、中序、后序),并且打印输出遍历结果。
④测试数据:输入数据:输入ABC##DE#G##F###输出结果:二叉树的先序遍历为:ABCDEGF二叉树的中序遍历为:CBEGDFA二叉树的后序遍历为:CGEFDBA3.概要设计1)为了实现上述程序功能,需要定义二叉链表的抽象数据类型:typedeftructBinaryTreeNode{TElemTypedata;//二叉树结点中的数据域tructBinaryTreeNode某lchild,某rchild;//二叉树结点的左孩子和右孩子指针}BinaryTreeNode,某BiTree;第1页,共9页基本操作:A.voidCreateBinaryTree(BiTree&T)初始条件:无操作结果:建立了二叉树。
B.voidPreOrder(BiTreeT)初始条件:存在一棵二叉树操作结果:先序遍历二叉树,并且输出先序遍历的结果。
C.voidMidOrder(BiTreeT)初始条件:存在一棵二叉树操作结果:中序遍历二叉树,并且输出中序遍历的结果。
D.voidPotOrder(BiTreeT)初始条件:存在一棵二叉树操作结果:后序遍历二叉树,并且输出后序遍历的结果。
程序包含5个函数:1主函数main()○2先序建立二叉树voidCreateBinaryTree(BiTree&T)○3先序遍历二叉树,并且输出先序遍历的结果voidPreOrder(BiTreeT);○4中序遍历二叉树,并且输出中序遍历的结果voidMidOrder(BiTreeT);○5序遍历二叉树,并且输出后序遍历的结果voidPotOrder(BiTreeT);○各函数间关系如下:main()主函数CreateBinaryTreePreOrderMidOrderPotOrder2第页,共9页4.详细设计1)二叉链表的定义typedeftructBinaryTreeNode{定义一个树结点的数据域;定义一个该结点的左孩子指针和右孩子指针;}先序建立二叉树2)voidCreateBinaryTree(BiTree&T)//{;输入一个字符量NULL;if(输入字符=='#')T指针置值为ele{动态申请一个指向二叉树结构体的指针data;把输入字符赋值给新指针的数据域);成员新指针的lchild调用CreateBinaryTree();rchild成员调用CreateBinaryTree(新指针的}}3)voidPreOrder(BiTreeT)//先序遍历二叉树{{输出T的data域;先序遍历左子树;;先序遍历右子树}}页,共3第9页4)voidMidOrder(BiTreeT)//中序遍历二叉树{if(T指针不为NULL){中序遍历左子树;输出T的data域;;中序遍历右子树}}5)voidPotOrder(BiTreeT)//中序遍历二叉树{;后序遍历左子树;后序遍历右子树;data域T输出的}}.调试分析5,程序运行了一段时间没,&ch)中的%c写成%d%c在编写程序过程中,我将canf(””有结果,经过检查,发现了这个错误。
【二叉树的建立和遍历实验报告】二叉树的遍历实验心得
【二叉树的建立和遍历实验报告】二叉树的遍历实验心得[题目] 建立二叉树并求指定结点路径、深度、叶子个数和左右子树交换。
[问题描述]要求能够按先序遍历次序输入二叉树中结点的值来构造二叉树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、掌握用指针类型描述、访问和处理二叉树的运算。
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. 当栈不为空时,执行以下操作: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. 从实际使用场景上看,前序遍历适合用于打印二叉树的结构、以及复制整棵树等;中序遍历适合用于查找二叉搜索树中的某个值;后序遍历适合用于计算二叉树中节点的高度或深度等。
二叉树的建立与遍历
重庆高校本科同学课程设计任务书数据结构:给出所使用的基本抽象数据类型,所定义的详细问题的数据类型, 以及新定义的抽象数据类型。
void recursive_insert(Binary_node<Entry> * &sub_root,const Entry &x);void recursive_postorder(Binary_node<Entry> *sub_root, void (*visit)(Entry &));void recursive_preorder(Binary_node<Entry> 水SUb_root,VOid (*visit)(Entry &));void recursive_inorder(Binary_node<Entry> *sub_roo LVoid (*visit)(Entry &));void recursive_clear(Binary_node<Entry> * &sub_root);Binary-node<Entry> * recursive_copy(Binary_node<Entry> *sub_root);};cpp2.cpp#include"cppl.cpp"#include<iostream>using namespace std;template <class Entry>int Binary-tree<Entry> :: height() const∕* Post: The height of the binary tree is returned. */(return recursive_height(root);1template <class Entry>int Binary_tree<Entry>::recursive_height(Binary_node<Entry> *sub_root) const ∕* Post: The height of the subtree rooted at sub_root is returned. */ (if(sub_root==0)return O;int L=recursive_height(sub_root->left);int R=recursive_height(sub_root->right);if(L>R)return 1+L;elsereturn 1+R;}template<class Entry>Binary-node<Entry>::B inary_node(const Entry &x)(data=x;Ieft=O;right=O;template <class Entry>void Binary_tree<Entry>::insert(const Entry &x)∕* Post: The Entry x is added to the binary tree. */(recursive_insert(root, x);1template <class Entry>void Binary_tree<Entry> ::recursive_insert(Binary_node<Entry> * &sub_root,const Entry &x) ∕* Pre: sub_root is either NULL or points to a subtree of the Binary_tree.Post: The Entry x has been inserted into the subtree in such a way that the properties of a binary search tree have been presen,ed.Uses: The functions recursive_insert, recursive_height */(if (sub_root==0)sub_root=new Binary-node<Entry>(x);elseif (recursive_height(sub_root->right)<recursive_height(sub_root->left))recursive_insert(sub_root->right, x);elserecursive_insert(sub_root->left, x);1template <class Entry>Binary_tree<Entry>::Binary_tree()∕*Post: An empty binary tree has been created.*/(root=0;template <class Entry>bool BinarjMree<Entry>ιιempty() const∕*Post: A result of true is returned if the binary tree is empty. Otherwise, false is returned.*/(return root==0;template <class Entry>void Binar)Mree<Entry>"recursive-clear(Binary-node<Entry> * &sub_root) ∕* Post: The subtree rooted at sub_root is cleared. */(Binary-node<Entry> *temp = sub_root;if (sub root ==0) return;Binary_tree<Entry> new_copy(original); clear();root = new_copy.root;new_copy.root = 0;return *this;1cpp3.cpptypedefchar type;#include"cpp2.cpp"#include<iostream>using namespace std;void visitvisit(type &x);int main() (COUt<v"输°?入“?数°y据Y 个?数°y"v<endl;Binary_tree<type> mytree;int n;cin>>n;COUt<<endl<v"以。
二叉树的创建和遍历
⼆叉树的创建和遍历⼆叉树创建: 1.创建树的结点TreeNode,包含结点的编号no,结点的名字name,左⼦树left,右⼦树right, 2.创建树,创建树只需要创建有⼀个根节点(TreeNode root)就ok⼆叉树遍历: 1,先序遍历:先输出根节点,再递归左⼦树,然后递归右⼦树 2,中序遍历:先递归左⼦树,然后输⼊根节点,再递归右⼦树 3,后序遍历:先递归左⼦树,再递归右⼦树,然后输出根节点⼆叉树的查找: 前序查找:1,先判断当前结点是否等于需要查找的 2,如果相等,直接返回当前结点 3,如果不等,则判断当前结点的左⼦节点是否为空,如果不为空,递归查询左⼦结点。
4,如果左⼦结点递归查找找到了结点,则就返回该结点,如果没有,则继续判断,直到左⼦节点找到值或者遇上空结点,然后判断右⼦节点是否为空,再递归查找 中序和后续思路也是⼀样实验: 创建如下的⼆叉树并遍历代码package Tree;public class BinaryTreeDemo {public static void main(String[] args) {BinaryTree binaryTree = new BinaryTree();//创建结点TreeNode root = new TreeNode(1,"宋江");TreeNode treeNode2 = new TreeNode(2,"林冲");TreeNode treeNode3 = new TreeNode(3,"吴⽤");TreeNode treeNode4 = new TreeNode(4,"关胜");TreeNode treeNode5 = new TreeNode(5,"卢俊义");//创建树结构root.setLeft(treeNode2);root.setRight(treeNode3);treeNode3.setRight(treeNode5);treeNode3.setLeft(treeNode4);//挂上树binaryTree.setTree(root);System.out.println("------------------");System.out.println("前序遍历");binaryTree.preOrder();System.out.println("------------------");System.out.println("中序遍历");binaryTree.midOrder();System.out.println("------------------");System.out.println("后序遍历");binaryTree.endOrder();//⼆叉树查找先序binaryTree.queryByNodeNo(2);//中序binaryTree.queryNodeByMid(3);//后序binaryTree.queryNodeByEnd(3);}}//创建树class BinaryTree{private TreeNode root;public void setTree(TreeNode root) {this.root = root;}public TreeNode getRoot() {return root;}//前序遍历public void preOrder(){if (this.root != null){this.root.preOrder();}else {System.out.println("空树");}}//中序遍历public void midOrder(){if (this.root != null){this.root.midOrder();}else {System.out.println("空树");}}//后序遍历public void endOrder(){if (this.root != null){this.root.endOrder();}else {System.out.println("空树");}}//⼆叉树查找-前序public void queryByNodeNo(int nodeNo){if (this.root != null){TreeNode treeNode = this.root.queryByNodeNo(nodeNo);System.out.println("查找到的树结点为 "+treeNode);}else {System.out.println("空树");}}//中序查找public void queryNodeByMid(int nodeNo){if (this.root != null){TreeNode treeNode = this.root.queryNodeByMid(nodeNo); System.out.println("中序遍历结果 "+treeNode);}else {System.out.println("空树");}}//后序查找public void queryNodeByEnd(int nodeNo){if (this.root != null){TreeNode treeNode = this.root.queryNodeByEnd(nodeNo); System.out.println("后序遍历结果 "+treeNode);}else {System.out.println("空树");}}}//创建树结点class TreeNode {private int no;//结点编号private String name;//结点名称private TreeNode left;//左结点指针private TreeNode right;//右结点指针public TreeNode(int no, String name) {this.no = no; = name;}public int getNo() {return no;}public void setNo(int no) {this.no = no;}public String getName() {return name;}public void setName(String name) { = name;}public TreeNode getLeft() {return left;}public void setLeft(TreeNode left) {this.left = left;}public TreeNode getRight() {return right;}public void setRight(TreeNode right) {this.right = right;}@Overridepublic String toString() {return "TreeNode{" +"no=" + no +", name='" + name + '\'' +'}';}//前序遍历public void preOrder() {//输出root结点System.out.println(this);if (this.left != null) {this.left.preOrder();//递归左⼦结点}if (this.right != null) {this.right.preOrder();}}//中序遍历public void midOrder() {//先遍历左⼦树if (this.left != null) {this.left.midOrder();}//输出根结点System.out.println(this);if (this.right != null) {this.right.midOrder();}}//后续遍历public void endOrder() {if (this.left != null) {this.left.endOrder();}if (this.right != null) {this.right.endOrder();}//输出根结点System.out.println(this);}//⼆叉树前序查找public TreeNode queryByNodeNo(int nodeNo) {//判断当前结点和需要查找的是否相等if (this.no == nodeNo) {return this;}//定义⼀个结点对象来接收查找的结果TreeNode result = null;if (this.left != null){//递归左⼦树result = this.left.queryByNodeNo(nodeNo);}//如果结点不为空,证明找到了,如果为空,证明找到了左⼦树的最后⼀个结点,没有结果if (result != null){return result;}if (this.right != null){//递归右⼦树result = this.right.queryByNodeNo(nodeNo);}return result;}//中序遍历public TreeNode queryNodeByMid(int nodeNo){TreeNode result = null;//判断左⼦节点是否为空if (this.left != null){//不为空,递归result = this.left.queryNodeByMid(nodeNo);}if (result != null){return result;}//判断⽗节点if (this.no == nodeNo){return this;}//判断右⼦节点if (this.right != null){//递归result = this.right.queryNodeByMid(nodeNo);}return result;}//后序遍历public TreeNode queryNodeByEnd(int nodeNo){TreeNode result = null;if (this.left != null){result = this.left.queryNodeByMid(nodeNo);}if (result != null){return result;}if (this.right != null){result = this.right.queryNodeByMid(nodeNo); }if (result != null){return result;}if (this.no == nodeNo){return this;}return this;}}满⼆叉树完全⼆叉树。
二叉树遍历实验报告
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、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
二叉树的建立与遍历
一、实验目的
进一步理解二叉树的逻辑结构和存储结构,掌握二叉树的建立与遍历算法。
二、实验内容
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,l
i,x = 2,k
i,x = 3,y
i,x = 4,b
i,x =5,s
i,x = 7,c
i,x =11,v
i,x = 15,r
i,x = 0,$
先序遍历二叉树(递归按y键,): y
l 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,l
i,x = 2,k
i,x = 3,y
i,x = 4,b
i,x =5,s
i,x = 7,c
i,x =11,v
i,x = 15,r
i,x = 0,$
先序遍历二叉树(递归按y键,): y
l k b s v y c r
四、实验心得体会
通过这次实验,锻炼了自己编程的能力,加深了自己对有关知识的理解。
同时也认识到要加强动手实践能力,光有知识是不够的,这次实验使我更好的将理论和知识结合在一起。
在编写程序中尽量做到独立完成,主动完成自己的任务。