二叉树实验报告及代码

合集下载

二叉树的建立与遍历实验报告(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,程序运行了一段时间没有结果,经过检查,发现了这个错误。

(完整版)C++二叉树基本操作实验报告

(完整版)C++二叉树基本操作实验报告

一、实验目的选择二叉链式存储结构作为二叉树的存储结构,设计一个程序实现二叉树的基本操作(包括建立、输出、前序遍历、中序遍历、后序遍历、求树高、统计叶子总数等)二、实验开发环境Windows 8.1 中文版Microsoft Visual Studio 6.0三、实验内容程序的菜单功能项如下:1------建立一棵二叉树2------前序遍历递归算法3------前序遍历非递归算法4------中序遍历递归算法5------中序遍历非递归算法6------后序遍历递归算法7------后序遍历非递归算法8------求树高9------求叶子总数10-----输出二叉树11-----退出四、实验分析1、建立一棵二叉树2、输入二叉树各节点数据cout<<"请按正确顺序输入二叉树的数据:";cin.getline(t,1000); //先把输入的数据输入到一个t数组3、递归前序遍历void BL1(ECS_data *t){if(NULL!=t){cout<<t->data<<",";BL1(t->l);BL1(t->r);}}4、非递归前序遍历void preOrder2(ECS_data *t){stack<ECS_data*> s;ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){cout<<p->data<<" ";s.push(p);p=p->l;}if(!s.empty()){p=s.top();s.pop();p=p->r;}}}5、递归中序遍历void BL2(ECS_data *t){if(NULL!=t){BL2(t->l);cout<<t->data<<",";BL2(t->r);}}6、非递归中序遍历void inOrder2(ECS_data *t) //非递归中序遍历{stack<ECS_data*> s;ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){s.push(p);p=p->l;}if(!s.empty()){p=s.top();cout<<p->data<<" ";s.pop();p=p->r;}}}7、递归后序遍历void BL3(ECS_data *t){if(NULL!=t){BL3(t->l);BL3(t->r);cout<<t->data<<",";}}8、非递归后序遍历void postOrder3(ECS_data *t){stack<ECS_data*> s;ECS_data *cur; //当前结点ECS_data *pre=NULL; //前一次访问的结点s.push(t);while(!s.empty()){cur=s.top();if((cur->l==NULL&&cur->r==NULL)||(pre!=NULL&&(pre==cur->l||pre==cur->r))){cout<<cur->data<<" "; //如果当前结点没有孩子结点或者孩子节点都已被访问过s.pop();pre=cur;}else{if(cur->r!=NULL)s.push(cur->r);if(cur->l!=NULL)s.push(cur->l);}}}9、求树高int Height (ECS_data *t){if(t==NULL) return 0;else{int m = Height ( t->l );int n = Height(t->r);return (m > n) ? (m+1) : (n+1);}}10、求叶子总数int CountLeaf(ECS_data *t){static int LeafNum=0;//叶子初始数目为0,使用静态变量if(t)//树非空{if(t->l==NULL&&t->r==NULL)//为叶子结点LeafNum++;//叶子数目加1else//不为叶子结点{CountLeaf(t->l);//递归统计左子树叶子数目CountLeaf(t->r);//递归统计右子树叶子数目}}return LeafNum;}五、运行结果附:完整程序源代码://二叉树链式存储的实现#include<iostream>#include<cstring>#include <stack>using namespace std;struct ECS_data //先定义好一个数据的结构{char data;ECS_data *l;ECS_data *r;};class ECS{private://int level; //树高int n; //表示有多少个节点数int n1; //表示的是数组的总长度值,(包括#),因为后面要进行删除判断ECS_data *temp[1000];public:ECS_data *root;ECS() //初始化{ECS_data *p;char t[1000];int i;int front=0,rear=1; //front表示有多少个节点,rear表示当前插入的点的父母cout<<"请按正确顺序输入二叉树的数据:";cin.getline(t,1000); //先把输入的数据输入到一个t数组//cout<<t<<" "<<endl;int n1=strlen(t); //测量数据的长度n=0;for(i=0;i<n1;i++){if(t[i]!='#'){p=NULL;if(t[i]!=',') //满足条件并开辟内存{n++;p=new ECS_data;p->data=t[i];p->l=NULL;p->r=NULL;}front++;temp[front]=p;if(1 == front){root=p;}else{if((p!=NULL)&&(0==front%2)){temp[rear]->l=p;//刚开始把这里写成了==}if((p!=NULL)&&(1==front%2)){temp[rear]->r=p;}if(1==front%2)rear++; //就当前的数据找这个数据的父母}}}}~ECS() //释放内存{int i;for(i=1;i<=n;i++)if(temp[i]!=NULL)delete temp[i];}void JS() //记录节点的个数{int s;s=n;cout<<"该二叉树的节点数为:"<<s<<endl;}void BL1(ECS_data *t)//递归前序遍历{if(NULL!=t){cout<<t->data<<",";BL1(t->l);BL1(t->r);}}void preOrder2(ECS_data *t) //非递归前序遍历{stack<ECS_data*> s;ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){cout<<p->data<<" ";s.push(p);p=p->l;}if(!s.empty()){p=s.top();s.pop();p=p->r;}}}void BL2(ECS_data *t)//递归中序遍历{if(NULL!=t){BL2(t->l);cout<<t->data<<",";BL2(t->r);}}void inOrder2(ECS_data *t) //非递归中序遍历{stack<ECS_data*> s;ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){s.push(p);p=p->l;}if(!s.empty()){p=s.top();cout<<p->data<<" ";s.pop();p=p->r;}}}void BL3(ECS_data *t)//递归后序遍历{if(NULL!=t){BL3(t->l);BL3(t->r);cout<<t->data<<",";}}void postOrder3(ECS_data *t) //非递归后序遍历{stack<ECS_data*> s;ECS_data *cur; //当前结点ECS_data *pre=NULL; //前一次访问的结点s.push(t);while(!s.empty()){cur=s.top();if((cur->l==NULL&&cur->r==NULL)||(pre!=NULL&&(pre==cur->l||pre==cur->r))){cout<<cur->data<<" "; //如果当前结点没有孩子结点或者孩子节点都已被访问过s.pop();pre=cur;}else{if(cur->r!=NULL)s.push(cur->r);if(cur->l!=NULL)s.push(cur->l);}}}int Height (ECS_data *t) //求树高{if(t==NULL) return 0;else{int m = Height ( t->l );int n = Height(t->r);return (m > n) ? (m+1) : (n+1);}}int CountLeaf(ECS_data *t) //求叶子总数{static int LeafNum=0;//叶子初始数目为0,使用静态变量if(t)//树非空{if(t->l==NULL&&t->r==NULL)//为叶子结点LeafNum++;//叶子数目加1else//不为叶子结点{CountLeaf(t->l);//递归统计左子树叶子数目CountLeaf(t->r);//递归统计右子树叶子数目}}return LeafNum;}};int main(){ECS a;a.JS();cout<<"递归前序遍历:";a.BL1(a.root);cout<<endl;cout<<"非递归前序遍历:";a.preOrder2(a.root);cout<<endl;cout<<"递归中序遍历:";a.BL2(a.root);cout<<endl;cout<<"非递归中序遍历:";a.inOrder2(a.root);cout<<endl;cout<<"递归后序遍历:";a.BL3(a.root);cout<<endl;cout<<"非递归后序遍历:";a.postOrder3(a.root);cout<<endl;cout<<"树高为:"<<a.Height(a.root)<<endl;cout<<"叶子总数为:"<<a.CountLeaf(a.root)<<endl;return 0;}。

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

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

二叉树的基本操作实验报告学号姓名实验日期 2012-12-26实验室计算机软件技术实验指导教师设备编号 401实验内容二叉树的基本操作一实验题目实现二叉树的基本操作的代码实现二实验目的1、掌握二叉树的基本特性2、掌握二叉树的先序、中序、后序的递归遍历算法3、通过求二叉树的深度、度为2的结点数和叶子结点数等算法三实习要求(1)认真阅读书上给出的算法(2)编写程序并独立调试四、给出二叉树的抽象数据类型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,且存在上的关系Hr ?H;H={<root,x1>,<root,xr>,H1,Hr};// (4)(D1,{H1})是一棵符合本定义的二叉树,称为根的左子树;(Dr,{Hr})是一棵符合本定义的二叉树,称为根的右子树。

//基本操作:CreateBiTree( &T, definition ) // 初始条件:definition给出二叉树T的定义。

// 操作结果:按definiton构造二叉树T。

BiTreeDepth( T )// 初始条件:二叉树T存在。

// 操作结果:返回T的深度。

PreOrderTraverse( T, visit() ) // 初始条件:二叉树T存在,Visit是对结点操作的应用函数。

二叉树应用源代码和实验报告

二叉树应用源代码和实验报告

实验十一二叉树的应用姓名:高翠莹学号:09 专业班级:数媒151一、实验项目名称二叉树的应用二、实验目的1.通过实验理解二叉树的逻辑结构;2.通过实验掌握二叉树的二叉链表存储结构;3.通过实验掌握二叉树的应用。

三、实验基本原理1、数据结构typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;2、算法思想这次实验主要是对二叉树的一些应用:(1)在二叉树中查找值为value的结点:即寻找每一个节点的data,若与value相同则返回;(2)统计出二叉树中叶子结点的数目:如果一个左孩子和右孩子都为空,则返回1,然后递归访问左子树和右子树,统计出所有的叶子结点;(3)统计出二叉树中非叶子结点的数目:用所有结点个数减去叶子结点个数即可;(4)统计出二叉树中所有结点的数目:递归调用,返回左子树结点个数加右结点个数,再加1;(5)求二叉树的高度递归求左子树高度h1和右子树高度h2,如果h1>h2,则返回h1+1,否则返回h2+1;3、算法描述见代码四、主要仪器设备及耗材1、硬件环境2、开发平台Dev C++五、实验步骤1.分析题目,确定数据结构类型,设计正确的算法;2.编写代码;3.运行及调试程序;4.修改程序,提高其健壮性。

六、实验数据及处理结果1、程序清单#include<iostream>#include<cstdlib>using namespace std;typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;算二叉树中所有结点的数目"<<endl;cout<<"2.计算二叉树中所有叶子结点的数目"<<endl;cout<<"3.计算二叉树中所有非叶子结点的数目"<<endl;cout<<"4.查找二叉树中值为value的结点"<<endl;cout<<"5.求二叉树中的高度"<<endl;cout<<"0.退出"<<endl;}int main(){cout<<"***************二叉树的应用*************"<<endl;cout<<"一、创建二叉树"<<endl;BiTree T;cout<<"按先序次序输入二叉树中结点的值(一个字符),‘#’表示空树"<<endl;CreateBiTree(T);cout<<"先序遍历这课树: "<<endl;PreOrder(T);cout<<endl;cout<<"二、具体操作"<<endl;Tips();int op;char x;cin>>op;while(op){switch(op){case 1:cout<<"树的所有节点个数为: ";cout<<countBTreeNode(T);break;case 2:cout<<"所有叶子结点个数为: ";cout<<Calleaf(T);break;case 3:int count;cout<<"非叶子结点的个数为: "<<countBTreeNode(T)-Calleaf(T)<<endl;break;case 4:cout<<"请输入value的值:";cin>>x;cout<<"值为"<<x<<"的结点为: ";locate(T,x);break;case 5:cout<<"树的高度为: ";cout<<BTreeHigh(T);break;}Tips(); cin>>op;}}2、运行结果(1)创建(2)操作求所有结点个数:求所有叶子结点个数:求所有非叶子结点个数:求值为value的结点:求二叉树的高度:七、思考讨论题或体会或对改进实验的建议这次实验之后,我更加了解树的逻辑结构,它有很强的递归属性,所以只要理解了递归的本质,就不难理解本次实验的操作,因为在操作时基本上都用到了递归方法,可以用少量的代码就能实现功能。

二叉树操作设计和实现实验报告

二叉树操作设计和实现实验报告

二叉树操作设计和实现实验报告一、目的:掌握二叉树的定义、性质及存储方式,各种遍历算法。

二、要求:采用二叉树链表作为存储结构,完成二叉树的建立,先序、中序和后序以及按层次遍历的操作,求所有叶子及结点总数的操作。

三、实验内容:1、分析、理解程序程序的功能是采用二叉树链表存储结构,完成二叉树的建立,先序、中序和后序以及按层次遍历的操作。

如输入二叉树ABD###CE##F##,链表示意图如下:2、添加中序和后序遍历算法//========LNR 中序遍历===============void Inorder(BinTree T){if(T){Inorder(T->lchild);printf("%c",T->data);Inorder(T->rchild);}}//==========LRN 后序遍历============void Postorder(BinTree T){if(T){Postorder(T->lchild);Postorder(T->rchild);printf("%c",T->data);}}3、调试程序,设计一棵二叉树,输入完全二叉树的先序序列,用#代表虚结点(空指针),如ABD###CE##F##,建立二叉树,求出先序、中序和后序以及按层次遍历序列,求所有叶子及结点总数。

(1)输入完全二叉树的先序序列ABD###CE##F##,程序运行结果如下:(2)先序序列:(3)中序序列:(4)后序序列:(5)所有叶子及结点总数:(6)按层次遍历序列:四、源程序代码#include"stdio.h"#include"string.h"#include"stdlib.h"#define Max 20 //结点的最大个数typedef struct node{char data;struct node *lchild,*rchild;}BinTNode; //自定义二叉树的结点类型typedef BinTNode *BinTree; //定义二叉树的指针int NodeNum,leaf; //NodeNum为结点数,leaf为叶子数//==========基于先序遍历算法创建二叉树==============//=====要求输入先序序列,其中加入虚结点"#"以示空指针的位置========== BinTree CreatBinTree(void){BinTree T;char ch;if((ch=getchar())=='#')return(NULL); //读入#,返回空指针else{T=(BinTNode *)malloc(sizeof(BinTNode)); //生成结点T->data=ch;T->lchild=CreatBinTree(); //构造左子树T->rchild=CreatBinTree(); //构造右子树return(T);}}//========NLR 先序遍历=============void Preorder(BinTree T){if(T) {printf("%c",T->data); //访问结点Preorder(T->lchild); //先序遍历左子树Preorder(T->rchild); //先序遍历右子树}}//========LNR 中序遍历===============void Inorder(BinTree T){if(T){Inorder(T->lchild);printf("%c",T->data);Inorder(T->rchild);}}//==========LRN 后序遍历============void Postorder(BinTree T){if(T){Postorder(T->lchild);Postorder(T->rchild);printf("%c",T->data);}}//=====采用后序遍历求二叉树的深度、结点数及叶子数的递归算法======== int TreeDepth(BinTree T){int hl,hr,max;if(T){hl=TreeDepth(T->lchild); //求左深度hr=TreeDepth(T->rchild); //求右深度max=hl>hr? hl:hr; //取左右深度的最大值NodeNum=NodeNum+1; //求结点数if(hl==0&&hr==0) leaf=leaf+1; //若左右深度为0,即为叶子。

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

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

数据结构实验报告1. 实验目的和内容:掌握二叉树基本操作的实现方法2. 程序分析2.1存储结构链式存储2.程序流程2.3关键算法分析算法一:Create(BiNode<T>* &R,T data[],int i,int n)【1】算法功能:创建二叉树【2】算法基本思想:利用顺序存储结构为输入,采用先建立根结点,再建立左右孩子的方法来递归建立二叉链表的二叉树【3】算法空间时间复杂度分析:O(n)【4】代码逻辑:如果位置小于数组的长度则{ 创建根结点将数组的值赋给刚才创建的结点的数据域创建左子树,如果当前结点位置为i,则左孩子位置为2i创建右子树,如果当前结点位置为i,则右孩子位置为2i+1}否则R为空算法二:CopyTree(BiNode<T>*sR,BiNode<T>* &dR))【1】算法功能:复制构造函数【2】算法基本思想:按照先创建根结点,再递归创建左右子树的方法来实现。

【3】算法空间时间复杂度分析:O(n)【4】代码逻辑:如果源二叉树根结点不为空则{创建根结点调用函数自身,创建左子树调用函数自身,创建右子树}将该函数放在复制构造函数中调用,就可以实现复制构造函数算法三:PreOrder(BiNode<T>*R)【1】算法功能:二叉树的前序遍历【2】算法基本思想:这个代码用的是优化算法,提前让当前结点出栈。

【3】算法空间时间复杂度分析:O(n)【4】代码逻辑(伪代码)如果当前结点为非空,则{访问当前结点当前结点入栈将当前结点的左孩子作为当前结点}如果为空{则栈顶结点出栈则将该结点的右孩子作为当前结点}反复执行这两个过程,直到结点为空并且栈空算法四:InOrder(BiNode<T>*R)【1】算法功能:二叉树的中序遍历【2】算法基本思想:递归【3】算法空间时间复杂度分析:未知【4】代码逻辑:如果R为非空:则调用函数自身遍历左孩子访问该结点再调用自身访问该结点的右孩子算法五:LevelOrder(BiNode<T>*R)【1】算法功能:二叉树的层序遍历【2】算法基本思想:【3】算法空间时间复杂度分析:O(n)【4】代码逻辑(伪代码):如果队列不空{对头元素出队访问该元素若该结点的左孩子为非空,则左孩子入队;若该结点的右孩子为非空,则右孩子入队;}算法六:Count(BiNode<T>*R)【1】算法功能:计算结点的个数【2】算法基本思想:递归【3】算法空间时间复杂度分析:未知【4】代码逻辑:如果R不为空的话{调用函数自身计算左孩子的结点数调用函数自身计算右孩子的结点数}template<class T>int BiTree<T>::Count(BiNode<T>*R){if(R==NULL)return 0;else{int m=Count(R->lchild);int n=Count(R->rchild);return m+n+1;}}算法七:Release(BiNode<T>*R)【1】算法功能:释放动态内存【2】算法基本思想:左右子树全部释放完毕后再释放该结点【3】算法空间时间复杂度分析:未知【4】代码逻辑:调用函数自身,释放左子树调用函数自身,释放右子树释放根结点释放二叉树template<class T>void BiTree<T>::Release(BiNode<T>*R) {if(R!=NULL){Release(R->lchild);Release(R->rchild);delete R;}}template<class T>BiTree<T>::~BiTree(){Release(root);}int main(){BiTree<int> BTree(a,10);BiTree<int>Tree(BTree);BTree.PreOrder(BTree.root);cout<<endl;Tree.PreOrder(Tree.root);cout<<endl;BTree.InOrder(BTree.root);cout<<endl;Tree.InOrder(Tree.root);cout<<endl;BTree.PostOrder(BTree.root);cout<<endl;Tree.PostOrder(Tree.root);cout<<endl;BTree.LevelOrder(BTree.root);cout<<endl;Tree.LevelOrder(Tree.root);cout<<endl;int m=BTree.Count(BTree.root);cout<<m<<endl;return 0;}3.测试数据:int a[10]={1,2,3,4,5};1 2 4 5 31 2 4 5 34 25 1 34 5 2 3 11 2 3 4 554.总结:4.1:这次实验大多用了递归的算法,比较好理解。

数据结构二叉树实验报告

数据结构二叉树实验报告

数据结构二叉树实验报告1. 引言二叉树是一种常见的数据结构,由节点(Node)和链接(Link)构成。

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

二叉树在计算机科学中被广泛应用,例如在搜索算法中,二叉树可以用来快速查找和插入数据。

本实验旨在通过编写二叉树的基本操作来深入理解二叉树的特性和实现方式。

2. 实验内容2.1 二叉树的定义二叉树可以用以下方式定义:class TreeNode:def__init__(self, val):self.val = valself.left =Noneself.right =None每个节点包含一个值和两个指针,分别指向左子节点和右子节点。

根据需求,可以为节点添加其他属性。

2.2 二叉树的基本操作本实验主要涉及以下二叉树的基本操作:•创建二叉树:根据给定的节点值构建二叉树。

•遍历二叉树:将二叉树的节点按照特定顺序访问。

•查找节点:在二叉树中查找特定值的节点。

•插入节点:向二叉树中插入新节点。

•删除节点:从二叉树中删除特定值的节点。

以上操作将在下面章节详细讨论。

3. 实验步骤3.1 创建二叉树二叉树可以通过递归的方式构建。

以创建一个简单的二叉树为例:def create_binary_tree():root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left.left = TreeNode(4)root.left.right = TreeNode(5)return root以上代码创建了一个二叉树,根节点的值为1,左子节点值为2,右子节点值为3,左子节点的左子节点值为4,左子节点的右子节点值为5。

3.2 遍历二叉树二叉树的遍历方式有多种,包括前序遍历、中序遍历和后序遍历。

以下是三种遍历方式的代码实现:•前序遍历:def preorder_traversal(root):if root:print(root.val)preorder_traversal(root.left)preorder_traversal(root.right)•中序遍历:def inorder_traversal(root):if root:inorder_traversal(root.left)print(root.val)inorder_traversal(root.right)•后序遍历:def postorder_traversal(root):if root:postorder_traversal(root.left)postorder_traversal(root.right)print(root.val)3.3 查找节点在二叉树中查找特定值的节点可以使用递归的方式实现。

数据结构二叉树程序及实验报告参考模板

数据结构二叉树程序及实验报告参考模板

实验三树1.实验目的通过本实验,使学生加深对二叉树的基本概念的理解;掌握掌握二叉排序树的插入和生成;掌握二叉树遍历操作及应用。

2.实验内容创建一个二叉树,并进行先序遍历、中序遍历、后序遍历、层次遍历,打印二叉树的叶子结构,并统计叶子结点个数和总结点个数。

3.实验要求(1)设计一个程序实现上述过程。

(2)采用二叉链表存储结构。

4、实验步骤#include "stdio.h"#include "malloc.h"#define ELEMTYPE chartypedef struct BiTNode { ELEMTYPE data;struct BiTNode*lchild,*rchild; } BiTNode;BiTNode *bulid() /*建树*/{ BiTNode *q;BiTNode *s[20];int i,j; char x;printf("请按顺序输入二叉树的结点以输入0和*号结束\n");printf("请输入你要输入的为第几个结点i=\n");scanf("%d",&i); printf("请输入你要输入该结点的数为x=");getchar();scanf("%c",&x);while(i!=0&&x!='*'){q=(BiTNode*)malloc(sizeof(BiTNode));q->data=x; q->rchild=NULL;q->lchild=NULL; s[i]=q; if(i!=1){ j=i/2; if(i%2==0) s[j]->lchild=q; else s[j]->rchild=q; }printf("请输入你要输入的为第几个结点x=\n");scanf("%d",&i); printf("请输入你要输入该结点的数x=");getchar(); scanf("%c",&x);}return s[1]; }void preoder(BiTNode *bt) /*先序遍历*/{ if(bt!=NULL){ printf("%c\n",(bt->data)); preoder(bt->lchild); preoder(bt->rchild); }}void InOrder(BiTNode *bt) /*中序遍历*/{ if(bt!=NULL) { InOrder(bt->lchild); printf("%c\n",bt->data); InOrder(bt->rchild); }}void postOrder(BiTNode *bt) /*后序遍历*/{ if(bt!=NULL) { postOrder(bt->lchild); postOrder(bt->rchild); printf("%c\n",bt->data); }}Int main(){int a;BiTNode *bt; bt=bulid();k1:printf("需要先序遍历输出请输入1,中序遍历请输入2,后序遍历请输入3,结束输入0:"); scanf("%d",&a);switch(a){ case(1): preoder(bt); goto k1; case(2): InOrder(bt); goto k1; case(3): postOrder(bt); goto k1; case(0): break; }5、实验结果友情提示:范文可能无法思考和涵盖全面,供参考!最好找专业人士起草或审核后使用,感谢您的下载!。

数据结构实验报告6二叉树的操作

数据结构实验报告6二叉树的操作
S.pop();
if(!S.empty())
{
p=S.top();
S.pop();
cout<<p->data<<" ";
S.push(p->rchild);
}}
}
void PreOrder_Nonrecursive(BiTree T)
{
stack<BiTree> S;
BiTree p;
S.push(T);
#include <queue>
#include <stack>
#include <malloc.h>
#defineSIZE 100
using namespace std;
typedef struct BiTNode
{char data;
struct BiTNode *lchild,*rchild;
break;
default:flag=0;printf("程序运行结束,按任意键退出!\n");
}}
}
void CreateBiTree(BiTree &T)
{
char ch;
scanf("%c",&ch);
if(ch==' ') T=NULL;
else
{ T=(BiTNode *)malloc(sizeof(BiTNode));
PreOrder_Nonrecursive(T);
printf("\n");
}
else printf("二叉树为空!\n");
break;

数据结构实验报告-树(二叉树)

数据结构实验报告-树(二叉树)

实验5:树(二叉树)(采用二叉链表存储)一、实验项目名称二叉树及其应用二、实验目的熟悉二叉树的存储结构的特性以及二叉树的基本操作。

三、实验基本原理之前我们都是学习的线性结构,这次我们就开始学习非线性结构——树。

线性结构中结点间具有唯一前驱、唯一后继关系,而非线性结构中结点的前驱、后继的关系并不具有唯一性。

在树结构中,节点间关系是前驱唯一而后继不唯一,即结点之间是一对多的关系。

直观地看,树结构是具有分支关系的结构(其分叉、分层的特征类似于自然界中的树)。

四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和预定义2.创建二叉树3.前序遍历4.中序遍历5.后序遍历6.总结点数7.叶子节点数8.树的深度9.树根到叶子的最长路径10.交换所有节点的左右子女11.顺序存储12.显示顺序存储13.测试函数和主函数对二叉树的每一个操作写测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。

实验完整代码:#include <bits/stdc++.h>using namespace std;#define MAX_TREE_SIZE 100typedef char ElemType;ElemType SqBiTree[MAX_TREE_SIZE];struct BiTNode{ElemType data;BiTNode *l,*r;}*T;void createBiTree(BiTNode *&T){ElemType e;e = getchar();if(e == '\n')return;else if(e == ' ')T = NULL;else{if(!(T = (BiTNode *)malloc(sizeof (BiTNode)))){cout << "内存分配错误!" << endl;exit(0);}T->data = e;createBiTree(T->l);createBiTree(T->r);}}void createBiTree2(BiTNode *T,int u) {if(T){SqBiTree[u] = T->data;createBiTree2(T->l,2 * u + 1);createBiTree2(T->r,2 * u + 2); }}void outputBiTree2(int n){int cnt = 0;for(int i = 0;cnt <= n;i++){cout << SqBiTree[i];if(SqBiTree[i] != ' ')cnt ++;}cout << endl;}void preOrderTraverse(BiTNode *T) {if(T){cout << T->data;preOrderTraverse(T->l);preOrderTraverse(T->r);}}void inOrderTraverse(BiTNode *T) {if(T){inOrderTraverse(T->l);cout << T->data;inOrderTraverse(T->r);}}void beOrderTraverse(BiTNode *T){if(T){beOrderTraverse(T->l);beOrderTraverse(T->r);cout << T->data;}}int sumOfVer(BiTNode *T){if(!T)return 0;return sumOfVer(T->l) + sumOfVer(T->r) + 1;}int sumOfLeaf(BiTNode *T){if(!T)return 0;if(T->l == NULL && T->r == NULL)return 1;return sumOfLeaf(T->l) + sumOfLeaf(T->r);}int depth(BiTNode *T){if(!T)return 0;return max(depth(T->l),depth(T->r)) + 1;}bool LongestPath(int dist,int dist2,vector<ElemType> &ne,BiTNode *T) {if(!T)return false;if(dist2 == dist)return true;if(LongestPath(dist,dist2 + 1,ne,T->l)){ne.push_back(T->l->data);return true;}else if(LongestPath(dist,dist2 + 1,ne,T->r)){ne.push_back(T->r->data);return true;}return false;}void swapVer(BiTNode *&T){if(T){swapVer(T->l);swapVer(T->r);BiTNode *tmp = T->l;T->l = T->r;T->r = tmp;}}//以下是测试程序void test1(){getchar();cout << "请以先序次序输入二叉树结点的值,空结点用空格表示:" << endl; createBiTree(T);cout << "二叉树创建成功!" << endl;}void test2(){cout << "二叉树的前序遍历为:" << endl;preOrderTraverse(T);cout << endl;}void test3(){cout << "二叉树的中序遍历为:" << endl;inOrderTraverse(T);cout << endl;}void test4(){cout << "二叉树的后序遍历为:" << endl;beOrderTraverse(T);cout << endl;}void test5(){cout << "二叉树的总结点数为:" << sumOfVer(T) << endl;}void test6(){cout << "二叉树的叶子结点数为:" << sumOfLeaf(T) << endl; }void test7(){cout << "二叉树的深度为:" << depth(T) << endl;}void test8(){int dist = depth(T);vector<ElemType> ne;cout << "树根到叶子的最长路径:" << endl;LongestPath(dist,1,ne,T);ne.push_back(T->data);reverse(ne.begin(),ne.end());cout << ne[0];for(int i = 1;i < ne.size();i++)cout << "->" << ne[i];cout << endl;}void test9(){swapVer(T);cout << "操作成功!" << endl;}void test10(){memset(SqBiTree,' ',sizeof SqBiTree);createBiTree2(T,0);cout << "操作成功!" << endl;}void test11(){int n = sumOfVer(T);outputBiTree2(n);}int main(){int op = 0;while(op != 12){cout << "-----------------menu--------------------" << endl;cout << "--------------1:创建二叉树--------------" << endl;cout << "--------------2:前序遍历----------------" << endl;cout << "--------------3:中序遍历----------------" << endl;cout << "--------------4:后序遍历----------------" << endl;cout << "--------------5:总结点数----------------" << endl;cout << "--------------6:叶子节点数--------------" << endl;cout << "--------------7:树的深度----------------" << endl;cout << "--------------8:树根到叶子的最长路径----" << endl;cout << "--------------9:交换所有节点左右子女----" << endl;cout << "--------------10:顺序存储---------------" << endl;cout << "--------------11:显示顺序存储-----------" << endl;cout << "--------------12:退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl;if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1();break;case 2:test2();break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:cout << "测试结束!" << endl;break;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果测试用例:1.创建二叉树(二叉链表形式)2.前序遍历3.中序遍历4.后序遍历5.总结点数6.叶子结点数7.树的深度8.树根到叶子的最长路径9.交换所有左右子女10.顺序存储七、思考讨论题或体会或对改进实验的建议通过这次实验,我掌握了二叉树的顺序存储和链式存储,体会了二叉树的存储结构的特性,掌握了二叉树的树上相关操作。

数据结构之二叉树编程实验报告

数据结构之二叉树编程实验报告

实验报告:二叉树题目:建立一棵二叉树,数据以字符串形式从键盘输入,在此二叉树上完成:(1)前序、中序、后序遍历(2)求出叶子数(3)求树高(4)左右子树交换,输出交换后的前序、中序遍历序列分析:建树:输入的字符串序列为带有空节点的前序遍历序列(空节点用*表示)。

①:前序,中序,后序遍历:递归遍历②:求叶子数:当一个节点的左右孩子都是NULL时,此节点即为叶子节点。

③:求树高当前节点的树高等于其左右孩子树高大的加1。

④:左右子树交换:对于每个节点,将其左右孩子交换,再递归对其左右子树交换。

测试结果:附:源码#include <iostream>#include <stdlib.h>using namespace std;struct Bintree{char data;Bintree* lchild;Bintree* rchild;};Bintree *head;int sp;/* 已知一棵二叉树的前序序列,建立这棵树*/ void CreateTree(Bintree *&p,char a[]){Bintree *temp;if(a[sp]!=0){if(a[sp]=='*'){p=NULL;sp++;return ;}p=new Bintree;p->data=a[sp++];CreateTree(p->lchild,a);CreateTree(p->rchild,a);}else p=NULL;}/* 求一棵树的高度*/int Depth(Bintree *&t){int lh , rh ;if( t == NULL ){return 0 ;}else{lh = Depth( t->lchild ) ;rh = Depth( t->rchild ) ;return ( lh > rh ? lh : rh ) + 1 ;}}/* 将二叉树的左右子树互换*/ void Exchange1(Bintree *&t){Bintree *temp;if(t){Exchange1(t->lchild);Exchange1(t->rchild);temp=t->lchild;t->lchild=t->rchild;t->rchild=temp;}}/* 按照前序递归遍历二叉树*/ void Preorder1(Bintree *&t){if(t!=NULL){printf("%c",t->data);Preorder1(t->lchild);Preorder1(t->rchild);}}/* 按照中序递归遍历二叉树*/ void Inorder1(Bintree *&t){if(t!=NULL){Inorder1(t->lchild);printf("%c",t->data);Inorder1(t->rchild);}}/* 按照后序递归遍历二叉树*/void Posorder1(Bintree *&t){if(t!=NULL){Posorder1(t->lchild);Posorder1(t->rchild);printf("%c",t->data);}}/* 递归法求叶子结点个数*/int Leaves_Num1(Bintree *&t){if(t){if(t->lchild==NULL&&t->rchild==NULL){return 1;}return Leaves_Num1(t->lchild)+Leaves_Num1(t->rchild);}return 0;}/*******************************************/int main (){char a[100];memset(a,0,sizeof(a));cout<<"输入带有空节点的前序遍历序列(空节点用*表示)"<<endl;cin>>a;sp=0;CreateTree(head,a);cout<<"前序遍历:"<<endl;Preorder1(head);cout<<endl;cout<<"中序遍历:"<<endl;Inorder1(head);cout<<endl;cout<<"后序遍历:"<<endl;Posorder1(head);cout<<endl;cout<<"叶子数:"<<Leaves_Num1(head)<<endl;cout<<"树高:"<<Depth(head)<<endl;cout<<"左右子树交换后"<<endl;Exchange1(head);cout<<"前序遍历:"<<endl;Preorder1(head);cout<<endl;cout<<"中序遍历:"<<endl;Inorder1(head);cout<<endl;cout<<"后序遍历:"<<endl;Posorder1(head);cout<<endl;return 0;}。

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. 遍历二叉树遍历二叉树有三种方式:前序遍历、中序遍历和后序遍历。

二叉树实验报告

二叉树实验报告

实验题目:实验九——二叉树实验算法设计(3)问题分析:1、题目要求:编写算法交换二叉树中所有结点的左右子树2、设计思路:首先定义一个二叉树的数据类型,使用先序遍历建立该二叉树,遍历二叉树,设计左右子树交换的函数,再次遍历交换之后的二叉树,与先前二叉树进行比较。

遍历算法与交换算法使用递归设计更加简洁。

3、测试数据:A、输入:1 2 4 0 0 5 0 0 3 0 0交换前中序遍历:4 2 5 1 3交换后中序遍历:3 1 5 2 4交换前:交换后:B、输入:3 7 11 0 0 18 17 0 0 19 0 0 6 13 0 0 16 0 0交换前中序遍历:11 7 17 18 19 3 13 6 16交换后中序遍历:16 6 13 3 19 18 17 7 11概要设计:1、为了实现上述功能:①构造一个空的二叉树;②应用先序遍历输入,建立二叉树;③中序遍历二叉树;④调用左右子树交换函数;⑤中序遍历交换过后的二叉树。

2、本程序包括4个函数:①主函数main()②先序遍历二叉树建立函数creat_bt()③中序遍历二叉树函数inorder()④左右子树交换函数 exchange()各函数间关系如下:详细设计:1、结点类型typedef struct binode //定义二叉树{int data; //数据域struct binode *lchild,*rchild; //左孩子、右孩子}binode,*bitree;2、各函数操作① 先序遍历建二叉树函数bitree creat_bt(){输入结点数据;判断是否为0{若是,为空;不是,递归;}返回二叉树;}② 左右子树交换函数void exchange(bitree t){判断结点是否为空{否,交换左右子树;递归;}}③ 中序遍历函数void inorder(bitree bt){判断是否为空{递归左子树;输出;递归右子树;}}main () creat_bt () inorder () exchange ()源代码:#include<stdio.h>#include<malloc.h>typedef struct binode //定义二叉树{int data; //数据域struct binode *lchild,*rchild; //左孩子、右孩子}binode,*bitree;bitree creat_bt() //按先序遍历建二叉树{bitree t;int x;scanf("%d",&x);if(x==0) t=NULL; //0表示空结点else{t=(bitree)malloc(sizeof(b inode));t->data=x;t->lchild=creat_bt(); //递归t->rchild=creat_bt();}return t;}void exchange(bitree t) //左、右子树交换{bitree p;if(t!=NULL) //不是空树{p=t->lchild;t->lchild=t->rchild; t->rchild=p; //左右交换exchange(t->lchild); //递归exchange(t->rchild);}}void inorder(bitree bt) //递归的中序遍历{if(bt){inorder(bt->lchild);printf("%d ",bt->data);inorder(bt->rchild);}}void main(){bitree root; printf("先序遍历建立二叉树,输入元素(0表示空):\n"); root=creat_bt();printf("交换前的中序序列是:");inorder(root);exchange(root);printf("\n交换后的中序序列是:");inorder(root);printf("\n");}测试结果:调试分析:1、函数多以递归设计,虽然大大减轻了代码上的复杂度,是思路更加明了,但也更加容易出错,尤其要注意递归函数出口的设计,否则程序难以执行。

二叉树实验报告

二叉树实验报告

实验四二叉树实验报告一、实验要求实现二叉树的中序递归遍历、中序非递归遍历、层次遍历等二、程序功能说明实现二叉树的中序递归遍历、中序非递归遍历、层次遍历等三、概要设计typedef struct BiNode{char Data;struct BiNode* lChild;struct BiNode* rChild;}BiNode,*pBiNode;typedef struct SNode{pBiNode elem;struct SNode *next;}SNode;struct link{struct BiNode *p;struct link *next;};四、详细设计#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int status;typedef struct BiNode//二叉链表{char Data;struct BiNode* lChild;struct BiNode* rChild;}BiNode,*pBiNode;typedef struct SNode/*链栈的结点类型*/{pBiNode elem; /*栈中的元素是指向二叉链表结点的指针*/struct SNode *next;}SNode;struct link //队列链表{struct BiNode *p;struct link *next;};status CreateTree(BiNode** pTree);status InOrderTraval(BiNode* pTree);//中序递归status st_InOrderTraverse(BiNode* pTree);//中序非递归遍历void TreeLink(BiNode* pTree); //队列实现层次遍历status Visit(char Data);void Display(BiNode* pTree,int Level);BiNode *pRoot=NULL;status CreateTree(BiNode** pTree) /*Input Example: abd##e##cf##g##*/ {char ch;scanf("%c",&ch);if(ch=='#'){(*pTree)=NULL;}else{if(!((*pTree)=(BiNode*)malloc(sizeof(BiNode)))){exit(OVERFLOW);}(*pTree)->Data=ch;CreateTree(&((*pTree)->lChild));CreateTree(&((*pTree)->rChild));}return OK;}status InOrderTraval(BiNode* pTree)//中序递归{if(pTree){if(InOrderTraval(pTree->lChild)){if(Visit(pTree->Data)){if(InOrderTraval(pTree->rChild)){return OK;}}return ERROR;}return ERROR;}else{return OK;}}status st_InOrderTraverse(BiNode* pTree)//中序非递归遍历{BiNode *p;SNode *q,*Stop=NULL; /*用不带头结点的单链表作为栈的存储结构*/ p=pTree;while(p!=NULL||Stop!=NULL) /*不是空树*/if(p!=NULL){q=(SNode*)malloc(sizeof(SNode));if(q==NULL)return ERROR;q->next=Stop;q->elem=p;Stop=q; /*根结点指针入栈*/p=p->lChild; /*进入根的左子树*/}else{q=Stop;Stop=Stop->next; /*栈顶元素出栈*/printf("%c ",q->elem->Data);/*访问根结点*/p=q->elem->rChild; /*进入根的右子树*/free(q); /*释放原栈顶元素的结点空间*/}}return OK;}void TreeLink(BiNode* pTree) //队列实现层次遍历{struct link *head,*rear,*temp;head=(struct link *)malloc(sizeof(struct link));head->p=pTree;head->next=NULL;rear=head;if(head->p->lChild!=NULL){temp=(struct link *)malloc(sizeof(struct link));temp->p=head->p->lChild;temp->next=NULL;rear->next=temp;rear=temp;}if(head->p->rChild!=NULL){temp=(struct link *)malloc(sizeof(struct link));temp->p=head->p->rChild;temp->next=NULL;rear->next=temp;rear=temp;}temp=head;printf("%c ",head->p->Data);head=head->next;free(temp);}while(head!=NULL);}status Visit(char Data){printf("%c ",Data);}void Display(BiNode* pTree,int Level)//显示整个树{int i;if(pTree==NULL) return;Display(pTree->rChild,Level+1);for(i=0;i<Level-1;i++){printf(" ");}if(Level>=1){printf("--");}printf("%c\n",pTree->Data);Display(pTree->lChild,Level+1);}void CmdList() //显示命令列表{printf("\n_____________________________________________\n");printf(" 请选择操作: \n");printf(" 1.中序递归遍历\n"); //中序递归遍历printf(" 2.中序非递归遍历\n"); //中序非递归遍历printf(" 3.层次遍历\n"); //层次遍历printf(" 0.退出程序\n"); //退出printf("\n______________________________________________\n");}void init(){printf("请输入二叉树各元素:(例如 abd##e##cf##g##)\n"); //例如abd##e##cf##g##CreateTree(&pRoot);Display(pRoot,0);CmdList();}void ReadCommand(char &c){do {c=getchar();}while(c!='0'&&c!='1'&&c!='2'&&c!='3'&&c!='4'&&c!='5'&&c!='6'&&c!='7'&&c!='8'&&c!='9' );}void Interpret(char &c){switch(c){case '1':{printf("\n中序递归遍历:\n");InOrderTraval(pRoot);CmdList();break;}case '2':{printf("\n中序非递归遍历:\n");st_InOrderTraverse(pRoot);CmdList();break;}case '3':{printf("\n层次遍历:\n");TreeLink(pRoot);CmdList();break;}case '0': printf("程序结束,按任意键退出!\n"); }}void main() //主函数{char cmd;init();do{ReadCommand(cmd);Interpret(cmd);}while (cmd!='0'&&cmd!='0'); }五、调试说明和测试结果1、输入二叉树元数2、执行中序递归遍历3、中序非递归遍历4、层次遍历5、退出程序。

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

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

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

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

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

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

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

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

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

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

二叉树实验代码

二叉树实验代码

实验目的:1.掌握二叉树的链式存储结构的定义及实现方法。

2.掌握二叉树的先序、中序和后序遍历方法。

3.掌握二叉树的结点个数和树的深度的计算方法。

实验内容:1.建立一棵含有n个结点的二叉树,采用二叉链表存储。

2.分别用前序、中序和后序遍历该二叉树,输出访问到的结点。

3.计算该二叉树的结点个数和二叉树的深度,输出计算结果。

//参考代码#include<iostream.h>#include<fstream.h>#include<stdlib.h>template <class T>struct BinTreeNode {//二叉树结点类定义T data; //数据域BinTreeNode<T> *leftChild, *rightChild;//左子女、右子女链域BinTreeNode ():leftChild(NULL),rightChild(NULL){}//构造函数BinTreeNode (T x, BinTreeNode<T> *l = NULL, BinTreeNode<T> *r = NULL) { data = x; leftChild = l; rightChild = r; }};template <class T>class BinaryTree { //二叉树类定义public:BinaryTree (T value) : RefValue(value), root(NULL) //构造函数{CreateBinTree (cin,root);}BinaryTree (BinaryTree<T>& s);//复制构造函数~BinaryTree () { destroy(root); } //析构函数bool IsEmpty () { return root == NULL;}//判二叉树空否int Height () { return Height(root); } //求树高度int Size (){ return Size(root); } //求结点数BinTreeNode<T> *getRoot () const { return root; }//取根void preOrder (void (*visit) (BinTreeNode<T> *p)) //前序遍历{ preOrder (root, visit); }void inOrder (void (*visit) (BinTreeNode<T> *p)) //中序遍历{ inOrder (root, visit); }void postOrder (void (*visit) (BinTreeNode<T> *p)) //后序遍历{ postOrder (root, visit); }protected:BinTreeNode<T> *root; //二叉树的根指针T RefValue; //数据输入停止标志void CreateBinTree (istream& in,BinTreeNode<T> *& subTree); //从文件读入建树void destroy (BinTreeNode<T> * subTree);void preOrder (BinTreeNode<T>* subTree, void (*visit) (BinTreeNode<T> *p)); //前序遍历void inOrder (BinTreeNode<T>* subTree, void (*visit) (BinTreeNode<T> *p)); //中序遍历void postOrder (BinTreeNode<T>* subTree, void (*visit) (BinTreeNode<T> *p)); //后序遍历int Size (BinTreeNode<T> *subTree) const; //返回结点数int Height ( BinTreeNode<T> * subTree);//返回树高度//其他函数略};template<class T>void BinaryTree<T>::destroy (BinTreeNode<T> * subTree) {//删除根为subTree的子树if (subTree != NULL) {destroy (subTree->leftChild); //删除左子树destroy (subTree->rightChild); //删除右子树delete subTree; //删除根结点}}template<class T>void BinaryTree<T>::CreateBinTree (istream& in, BinTreeNode<T> *& subTree) { T item;if ( !in.eof () ){ //未读完, 读入并建树in >> item; //读入根结点的值if (item != RefValue){subTree = new BinTreeNode<T>(item);//建立根结点if (subTree == NULL){cerr << "存储分配错!"<< endl; exit (1);}CreateBinTree (in, subTree->leftChild);//递归建立左子树CreateBinTree (in, subTree->rightChild);//递归建立右子树}else subTree = NULL; //封闭指向空子树的指针}}template <class T>//前序void BinaryTree<T>::preOrder (BinTreeNode<T> * subTree, void (*visit) (BinTreeNode<T> *p)) {if (subTree!= NULL) {visit (subTree); //访问根结点preOrder (subTree->leftChild, visit); //遍历左子树preOrder (subTree->rightChild, visit); //遍历右子树}}template <class T>//中序void BinaryTree<T>::inOrder (BinTreeNode<T> * subTree, void (*visit) (BinTreeNode<T> *p)) {if (subTree != NULL) {inOrder (subTree->leftChild, visit); //遍历左子树visit (subTree); //访问根结点inOrder (subTree->rightChild, visit); //遍历右子树}}template <class T>//后序void BinaryTree<T>::postOrder (BinTreeNode<T> * subTree, void (*visit) (BinTreeNode<T> *p)) {if (subTree != NULL ) {postOrder (subTree->leftChild, visit);//遍历左子树postOrder (subTree->rightChild, visit); //遍历右子树visit (subTree); //访问根结点}}template <class T>int BinaryTree<T>::Size (BinTreeNode<T> * subTree) const {if (subTree == NULL) return 0; //空树else return 1+Size (subTree->leftChild)+ Size (subTree->rightChild);}template <class T>int BinaryTree<T>::Height ( BinTreeNode<T> * subTree){ if (subTree == NULL) return 0; //空树高度为0else {int i = Height (subTree->leftChild);int j = Height (subTree->rightChild);return (i < j) ? j+1 : i+1; }}void print(BinTreeNode<char> *p){cout<<p->data;}void main(){BinaryTree<char> T('#');cout<<"前序遍历结果为:";T.preOrder(print);cout<<endl<<"中序遍历结果为:";T.inOrder(print);cout<<endl<<"后序遍历结果为:";T.postOrder(print);cout<<endl;int i=T.Height();cout<<endl<<"树的高度是:"<<i;i=T.Size();cout<<endl<<"树的结点个数是:"<<i<<endl;}测试数据:输入:ab##cd##e##输出:说明:输入中的#号是分支结束的标志。

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、按中序遍历结果从小到大的顺序建立一棵含有n个结点的二叉树,采用二叉链表存储;2、中序、前序、后序改二叉链表;3、输入一个数据,访问任一结点进行查找,如果有则返回“查找成功。

”,没有则返回“查找不成功。

”4、设计一个析构函数,释放结点空间。

实验代码:#include<iostream.h>class node{private:int data;class node *left;class node *right;void Release(class node *a);public:void create(int a);void inorder(class node *q);void preorder(class node *m);void postorder(class node *n);void seek(class node *l,int k);~node();};typedef class node treenode;//重定义二叉树结点类型。

typedef treenode *zz;//重新定义指针。

zz root,p;void node::create(int x){zz s;int flag=0;//结点成功插入后flag=1。

s=new treenode;s->data=x;s->left=NULL;s->right=NULL;if(root==NULL)root=s;else{p=root;while(!flag)if(x<p->data)if(p->left==NULL){p->left=s;flag=1;}elsep=p->left;elseif(p->right==NULL){ p->right=s;flag=1; }elsep=p->right;}}void node::inorder(zz q){if(q!=NULL){inorder(q->left);cout<<q->data<<" ";inorder(q->right);}}void node::preorder(zz m){if (m==NULL)return;else{cout<<m->data<<" ";preorder(m->left);preorder(m->right);}}void node::postorder(zz n){if (n==NULL)return;else{postorder(n->left);postorder(n->right);cout<<n->data<<" ";}}void node::seek(class node *l,int k){if(l==NULL)cout<<"查找失败,不存在该数据。

实验二 二叉树实验报告

实验二 二叉树实验报告

七、实验反思:
本次实验中使用链式结构直观的构造了二叉树数据结构,同时,构造了一维 的队列和栈对二叉树的搜索和遍历进行辅助存储。其中实现二叉树时,以特殊符 号标记结束节点,方便输入和建立二叉树,使得使用唯一确定的先序序列即可表
达二叉树。递归建立二叉树时,需要注意返回二叉树子树的根节点地址给上级节 点左右子节点记录。实现队时,使用单向链表,在堆动态分配存储空间,空间效 率更高。基于面向对象思想,设计了二叉树类,具体实现了初始化,先序遍历, 按层遍历,交换左右节点的接口,可扩展性较强。
int m; tnode *l,*r; l=t->left; r=t->right; m=t->data; if(m) {
if(l->data) firstTrav(l); cout<<m<<' '; if(r->data) firstTrav(r); } } };
int main() {
int i,j,n; tnode *rt; biTree bt; rt=bt.getRoot(); //使用 rt 指针记录指向二叉树的根节点 //使用 firstCreate 函数以先序序列建立二叉树,0 表示结束节点 rt=bt.firstCreate(rt,0); //先序打印所有节点 cout<<"先序打印二叉树:\n"; bt.firstTrav(rt); cout<<endl; //使用 lvlRead()方法按层打印所有节点 cout<<"按层打印二叉树:\n"; bt.lvlRead(rt); cout<<endl; //使用 leafRead()方法打印所有叶节点 cout<<"打印二叉树所有叶子节点:\n"; bt.leafRead(rt); cout<<endl; //使用 leafRead()方法交换所有左右节点 bt.allReverse(rt); cout<<"二叉树交换后先序打印:\n"; bt.firstTrav(rt); //先序打印所有节点

数据结构二叉树实验报告(附代码)

数据结构二叉树实验报告(附代码)

一、【实验构思(Conceive)】(10%)(本部分应包括:描述实验实现的基本思路,包括所用到的离散数学、工程数学、程序设计、算法等相关知识)首先构造二叉树的存储结构,用data存储当前节点的值,分别用*lchild,*rchild 表示该节点的左右孩子。

然后应用BiTree Create函数,根据用户的输入构造二叉树,当输入#时表示没有孩子。

采用递归的思想构造Preorder,Inorder,Postorder函数,分别实现二叉树的先序,中序,和后序的遍历。

然后编写了Sumleaf,Depth函数,来求叶子节点的数目和二叉树的深度。

二、【实验设计(Design)】(20%)(本部分应包括:抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明,主程序模块与各子程序模块间的调用关系)二叉树的存储结构:typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;子程序模块:BiTree Create(BiTree T){char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild);}return T;}void Preorder(BiTree T){if(T){printf("%c",T->data);Preorder(T->lchild);Preorder(T->rchild);}}int Sumleaf(BiTree T){int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild)) sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}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); }}int Depth(BiTree T){int dep=0,depl,depr;if(!T)dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}主程序模块:int main(){BiTree T = 0;int sum,dep;printf("请输入你需要建立的二叉树\n");printf("例如输入序列ABC##DE#G##F###(其中的#表示空)\n并且输入过程中不要加回车\n输入完之后可以按回车退出\n");T=Create(T);printf("先序遍历的结果是:\n");Preorder(T);printf("\n");printf("中序遍历的结果是:\n");Inorder(T);printf("\n");printf("后序遍历的结果是:\n");Postorder(T);printf("\n");printf("统计的叶子数:\n");sum=Sumleaf(T);printf("%d",sum);printf("\n统计树的深度:\n");dep=Depth(T);printf("\n%d\n",dep);}三、【实现描述(Implement)】(30%)(本部分应包括:抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系,关键的程序流程图等,给出关键算法的时间复杂度分析。

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

重庆交通大学综合性设计性实验报告姓名姚远学号 631106060113 班级:计信息一班实验项目名称:二叉树实验项目性质:设计性实验实验所属课程:数据结构实验室(中心): 407机房指导教师:鲁云平实验完成时间: 2013 年 5 月 10 日一、实验目的1. 建立二叉树2. 计算结点所在的层次3.统计结点数量和叶结点数量4.计算二叉树的高度5.计算结点的度6.找结点的双亲和子女7.二叉树的遍历8.二叉树的输出等等二、实验内容及要求1.二叉树的结点结构,二叉树的存储结构由学生自由选择和设定2.实验完成后上交打印的实验报告,报告内容与前面所给定的实验模板相同3.将实验报告电子版和源代码在网络教学平台提交三、实验设备及软件VISUAL C++软件四、设计方案㈠题目(老师给定或学生自定)二叉树的应用㈡设计的主要思路在计算机科学中,二叉树是每个结点最多有两个子树的有序树。

通常子树的根被称作“左子树”(left subtree)和“右子树”(right subtree)。

二叉树常被用作二叉查找树和二叉堆或是二叉排序树。

二叉树的每个结点至多只有二棵子树(不存在出度大于2的结点),二叉树的子树有左右之分,次序不能颠倒。

二叉树的第i层至多有2的i -1次方个结点;深度为k的二叉树至多有2^(k) -1个结点;对任何一棵二叉树T,如果其终端结点数(即叶子结点数)为n0,出度为2的结点数为n2,则n0 =n2 + 1。

㈢主要功能实现二叉树的各项操作。

五、主要代码#include<iostream.h>#include<stdio.h>#include<stdlib.h>typedef struct BinTreeNode //二叉树结点类定义{char data;//数据域BinTreeNode *leftChild, *rightChild; //左子女、右子女链域}*BTree;BinTreeNode *p,*q,*f;int NodeNum,Leaf;int NodeDu,nodeloc=1;void CreateBinTree(BTree &T);void preOrder(BTree T);void inOrder(BTree T);void postOrder(BTree T);int TreeNodes(BTree T);int LeafNodes(BTree T);int TreeNodedu(BTree T,char ch);void NodeLoc(BTree T,char c,int nodeloc);int Height(BTree T);BTree Parent(BTree T,char c);BTree NodeRC(BTree T,char c);BTree NodeLC(BTree T,char c);void CreateBinTree(BTree &T){char item;cin>>item;if ( item!='#' ){T=(BTree )malloc(sizeof(BinTreeNode));T->data=item;if (T == NULL){cerr << "存储分配错误!" << endl;exit (1);}CreateBinTree (T->leftChild);//递归建立左子树CreateBinTree (T->rightChild); //递归建立右子树}elseT= NULL;};void inOrder(BTree T){if (T != NULL){inOrder (T->leftChild); //遍历左子树cout<<T->data<<" ";inOrder (T->rightChild); //遍历右子树}};void preOrder(BTree T){if (T != NULL){cout<<T->data<<" ";preOrder (T->leftChild); //遍历左子树preOrder (T->rightChild); //遍历右子树}};void postOrder(BTree T){if (T != NULL ){postOrder(T->leftChild);//遍历左子树postOrder(T->rightChild);//遍历右子树cout<<T->data<<" ";}};int TreeNodes(BTree T) //利用二叉树后序遍历算法计算二叉树的结点个数{int hl,hr;if(T != NULL){hl=TreeNodes(T->leftChild);hr=TreeNodes(T->rightChild);NodeNum=NodeNum+1;return NodeNum;}};int LeafNodes(BTree T) //利用二叉树后序遍历算法计算二叉树的叶结点个数{if(T != NULL){LeafNodes(T->leftChild);LeafNodes(T->rightChild);if(T->leftChild==NULL&&T->rightChild==NULL)Leaf=Leaf+1;}return Leaf;};int TreeNodedu(BTree T,char ch){if(T==NULL)return NULL;else{if(T->data == ch&&T->leftChild!=NULL&&T->rightChild==NULL) NodeDu=1;else if(T->data == ch&&T->rightChild!=NULL&&T->leftChild==NULL)NodeDu=1;else if(T->data == ch&&T->leftChild!=NULL&&T->rightChild!=NULL)NodeDu=2;else if(T->data == ch&&T->leftChild==NULL&&T->rightChild==NULL)NodeDu=0;TreeNodedu(T->leftChild,ch);TreeNodedu(T->rightChild,ch);return NodeDu;}}void NodeLoc(BTree T,char c,int nodeloc){if(T != NULL){if(T->data == c)cout<<nodeloc<<endl;NodeLoc(T->leftChild,c,nodeloc+1);NodeLoc(T->rightChild,c,nodeloc+1);}};int Height(BTree T) //利用二叉树后序遍历算法计算二叉树的高度{int hl,hr,hm;if(T == NULL)return 0;//空树高度为0else{hl = Height (T->leftChild);hr = Height (T->rightChild);hm=hl>hr?hl:hr;return (hm+1);}BTree Parent(BTree T,char c){BTree p;if (T==NULL) return NULL;if((T->leftChild!=NULL&&T->leftChild->data==c)||(T->rightChild!=NULL&&T->righ tChild->data==c))return T;//找到, 返回父结点地址else{if ((p=Parent(T->leftChild, c))!=NULL)return p; //递归在左子树中搜索elsereturn Parent(T->rightChild, c); //递归在左子树中搜索}return NULL;};BTree NodeLC(BTree T,char c){if(T==NULL)return NULL;else if(T->data == c){if (T->leftChild){return T->leftChild ;}}else{if(NodeLC(T->leftChild,c)!=NULL)return NodeLC(T->leftChild,c);else if(NodeLC(T->rightChild,c)!=NULL) return NodeLC(T->rightChild,c);elsereturn NULL;}}BTree NodeRC(BTree T,char c){if(T==NULL)return NULL;else if(T->data == c){if (T->rightChild){return T->rightChild ;}}else{if(NodeRC(T->leftChild,c)!=NULL)return NodeRC(T->leftChild,c);else if(NodeRC(T->rightChild,c)!=NULL) return NodeRC(T->rightChild,c);elsereturn NULL;}}void main(){BTree T;int nodes,leafnodes,height,nodedu;cout<<"创建二叉树,请输入完全二叉树的先序序列,用'#'代表虚结点:"<<endl;CreateBinTree(T);int i;do{cout<<"****************1:输出前序遍历结果************************"<<endl;cout<<"****************2:输出中序遍历结果************************"<<endl;cout<<"****************3:输出后序遍历结果************************"<<endl;cout<<"****************4:输出二叉树的高度************************"<<endl;cout<<"****************5:输出二叉树的结点数**********************"<<endl;cout<<"****************6:输出二叉树的叶结点数********************"<<endl;cout<<"****************7:输出二叉树任意结点的度数****************"<<endl;cout<<"****************8:输出二叉树任意结点所在层次**************"<<endl;cout<<"****************9:输出二叉树任意结点的双亲结点值**********"<<endl;cout<<"****************10:输出二叉树任意结点的子女结点值*********"<<endl;cout<<"****************11:退出程序*******************************"<<endl;cout<<"请输入要执行的功能代码的编号(1-10):"<<endl;cin>>i;cout<<endl;switch(i){case 1:cout<<"前序遍历结果为:"<<endl;preOrder(T);break;case 2:cout<<"中序遍历结果为:"<<endl;inOrder(T);break;case 3:cout<<"后序遍历结果为:"<<endl;postOrder(T);break;case 4:height=Height(T);cout<<"二叉树的高度为:"<<height<<endl;break;case 5:nodes=TreeNodes(T);cout<<"二叉树的结点数为:"<<nodes<<endl;break;case 6:leafnodes=LeafNodes(T);cout<<"二叉树的叶结点数为:"<<leafnodes<<endl;break;case 7:char ch1;cout<<"请输入该结点的值:";cin>>ch1;nodedu=TreeNodedu(T,ch1);cout<<"该结点的度数为:"<<nodedu<<endl;break;case 8:char ch4;cout<<"请输入该结点的值:";cin>>ch4;cout<<"该结点所在二叉树的层次为:";NodeLoc(T,ch4,1);break;case 9:char ch2;cout<<"请输入该结点的值:";cin>>ch2;f=Parent(T,ch2);if(f!=NULL)cout<<"该结点双亲结点值为:"<<f->data<<endl;elsecout<<"该结点没有父结点。

相关文档
最新文档