您的位置：360文档中心› 实验：二叉树基本操作的编程实现实验报告

实验：二叉树基本操作的编程实现实验报告

合集下载

实验五 二叉树基本操作的编程实现实验报告

实验五 二叉树基本操作的编程实现实验报告

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY Array
数据结构
实验五二叉树基本操作的编程实现
【实验目的】
内容：二叉树基本操作的编程实现
要求：
二叉树基本操作的编程实现（2学时，验证型），掌握二叉树的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找等操作，存储结构主要采用顺序或链接结构。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】
验证性实验（学时数：2H）
【实验内容】
以下的选题都可以作为本次实验的推荐题目
1.建立二叉树，并以前序遍历的方式将结点内容输出。

2.将一个表示二叉树的数组结构转换成链表结构。

3.将表达式二叉树方式存入数组，以递归方式建立表达式之二叉树状结构，再分别输出前序、中序
及后序遍历结果，并计算出表达式之结果。

【注意事项】
1.开发语言：使用C。

2.可以自己增加其他功能。

【实验分析、说明过程】
【思考问题】
【实验小结】 (总结本次实验的重难点及心得、体会、收获)
【附录-实验代码】。

(完整版)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;}。

实验报告：二叉树

实验报告：二叉树

实验报告：二叉树第一篇：实验报告：二叉树实验报告二叉树一实验目的1、进一步掌握指针变量，动态变量的含义；2、掌握二叉树的结构特性以及各种存储结构的特点及适用范围。

3、掌握用指针类型描述、访问和处理二叉树的运算。

4、熟悉各种存储结构的特征以及如何应用树结构解决具体问题。

二实验原理树形结构是一种应用十分广泛和重要的非线性数据结构，是一种以分支关系定义的层次结构。

在这种结构中，每个数据元素至多只有一个前驱，但可以有多个后继；数据元素之间的关系是一对多的层次关系。

树形结构主要用于描述客观世界中具有层次结构的数据关系，它在客观世界中大量存在。

遍历二叉树的实质是将非线性结构转为线性结构。

三使用仪器，材料计算机 2 Wndows xp 3 VC6.0四实验步骤【问题描述】建立一个二叉树，请分别按前序，中序和后序遍历该二叉树。

【基本要求】从键盘接受输入（按前序顺序），以二叉链表作为存储结构，建立二叉树（以前序来建立），并采用递归算法对其进行前序，中序和后序遍历，将结果输出。

【实现提示】按前序次序输入二叉树中结点的值（一个整数），0表示空树，叶子结点的特征是其左右孩子指针为空。

五实验过程原始记录基本数据结构描述； 2 函数间的调用关系；用类C语言描述各个子函数的算法；附录：源程序。

六试验结果分析将实验结果分析、实验中遇到的问题和解决问题的方法以及关于本实验项目的心得体会，写在实验报告上。

第二篇：数据结构-二叉树的遍历实验报告实验报告课程名：数据结构（C语言版）实验名：二叉树的遍历姓名：班级：学号：时间：2014.11.03一实验目的与要求1.掌握二叉树的存储方法2.掌握二叉树的三种遍历方法3.实现二叉树的三种遍历方法中的一种二实验内容• 接受用户输入一株二叉树• 输出这株二叉树的前根, 中根, 后根遍历中任意一种的顺序三实验结果与分析//*********************************************************** //头文件#include #include //*********************************************************** //宏定义#define OK 1 #define ERROR 0 #define OVERFLOW 0//*********************************************************** typedef struct BiTNode { //二叉树二叉链表存储结构char data;struct BiTNode *lChild,*rChild;}BiTNode,*BiTree;//******************************** *************************** int CreateBiTree(BiTree &T){ //按先序次序输入二叉中树结点的值，空格表示空树//构造二叉链表表示的二叉树T char ch;fflush(stdin);scanf(“%c”,&ch);if(ch==' ')T=NULL;else{ if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))return(OVERFLOW);T->data=ch;Creat eBiTree(T->lChild);CreateBiTree(T->rChild);} return(OK);} //********************************************************* void PreOrderTraverse(BiTree T){ //采用二叉链表存储结构，先序遍历二叉树的递归算法if(T){ printf(“%c”,T->data);PreOrderTraverse(T->lChild);PreOrd erTraverse(T->rChild);} } /***********************************************************/ void InOrderTraverse(BiTree T){ //采用二叉链表存储结构，中序遍历二叉树的递归算法if(T){ InOrderTraverse(T->lChild);printf(“%c”,T->data);InOrderT raverse(T->rChild);} }//*********************************************************** void PostOrderTraverse(BiTree T){ //采用二叉链表存储结构，后序遍历二叉树的递归算法if(T){ PostOrderTraverse(T->lChild);PostOrderTraverse(T->rChild) ;printf(“%c”,T->data);} }//*********************************************************** void main(){ //主函数分别实现建立并输出先、中、后序遍历二叉树printf(“please input your tree follow the PreOrder:n”);BiTNode *Tree;CreateBiTree(Tree);printf(“n先序遍历二叉树:”);PreOrderTraverse(Tree);printf(“n中序遍历二叉树:”);InOrderTraverse(Tree);printf(“n后序遍历二叉树:”);PostOrderTraverse(Tree);}图1:二叉树的遍历运行结果第三篇：数据结构二叉树操作验证实验报告班级：计算机11-2 学号：40 姓名：朱报龙成绩：_________实验七二叉树操作验证一、实验目的⑴ 掌握二叉树的逻辑结构；⑵ 掌握二叉树的二叉链表存储结构；⑶ 掌握基于二叉链表存储的二叉树的遍历操作的实现。

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

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

二叉树的基本操作实验报告学号姓名实验日期 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是对结点操作的应用函数。

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

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

、实验目的选择二叉链式存储结构作为二叉树的存储结构，设计一个程序实现二叉树的基本操作（包括建立、输出、前序遍历、中序遍历、后序遍历、求树高、统计叶子总数等）二、实验开发环境Windows 8.1 中文版Microsoft Visual Studio 6.0三、实验内容程序的菜单功能项如下：1 -- 建立一棵二叉树2 -- 前序遍历递归算法3 -- 前序遍历非递归算法4 -- 中序遍历递归算法5 -- 中序遍历非递归算法6 ---- 后序遍历递归算法7 ---- 后序遍历非递归算法8 ---- 求树高9 -- 求叶子总数10 - 输出二叉树11 - 退出四、实验分析1、建立一棵二叉树2、输入二叉树各节点数据coutvv"请按正确顺序输入二叉树的数据："；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=O;//叶子初始数目为0,使用静态变量if(t)// 树非空{if(t->l==NULL&&t->r==NULL)// 为叶子结点LeafNum++;// 叶子数目加 1 else//不为叶子结点{Cou ntLeaf(t->l);//递归统计左子树叶子数目 Cou ntLeaf(t->r);//递归统计右子树叶子数目 }}return LeafNum; }五、运行结果附：完整程序源代码: 〃二叉树链式存储的实现#in cludeviostream> #in clude<cstri ng>#in elude <stack> using n ames pace std; struct ECS_data //先定义好一个数据的结构 {char data;ECS_data *l; ECS_data *r; };" //树高//表示有多少个节点数〃表示的是数组的总长度值，(包括#)，因为后面要class ECS {P rivate://in t 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 表示当前插 coutvv"请按正确顺序输入二叉树的数据："; cin.getline(t,1000); //cout<<t<<" "<<endl;int n1=strlen(t); n=0; for(i=0;i<n1;i++) {if(t[i]!='#') {//先把输入的数据输入到一个 t 数组 //测量数据的长度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;coutvv"该二叉树的节点数为："vvsvvendl; }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;//释放内存//记录节点的个数if(NUL匚丛)宀BL2(e_)-coufAvdafaAfr BL2(g-voidino ‘de ‘2(Ecslda応J )二卅融丘甘甸壷逗宀sfackAECSIdafa*vs 八 ECSIdafa *P H Cwhi-e(p一 hnul匚-一 s.empfyo) 宀wh=e(p一"NULL)宀s.push(p)八PHP —vrif (一s.empfyo)宀PHSlopucoufAAP —vdafaAAs.popwPHP*voidBL3(Ecsldafa *U 1融&训引筍已宀if(NUL匚丛)宀BL3(e_)- BL3(g- coufAAf —vdafaAdrvoidposfo ‘de ‘3(Ecsldafa *0&可甸壷逗 宀sfackAECSIdafa*vs 八ECSIdafa*cucm 遡璋、的ECSIdafa*p‘eHNUF二遡—舟曲亘兼叫、的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);// 递归统计左子树叶子数目Cou ntLeaf(t->r);//递归统计右子树叶子数目}}return LeafNum; }};int main(){ECS a;a.JS();coutvv"递归前序遍历："；a.BL1(a.root);cout<<endl；coutvv"非递归前序遍历:";a.preOrder2(a.root)；coutvvendl;coutvv"递归中序遍历:";a.BL2(a.root);coutvvendl;coutvv"非递归中序遍历:";a.inOrder2(a.root);coutvvendl;coutvv"递归后序遍历:";a.BL3(a.root);coutvvendl;coutvv"非递归后序遍历:";a.postOrder3(a.root);coutvvendl;coutvv"树高为："vva.Height(a.root)vvendl;coutvv"叶子总数为:"vva.CountLeaf(a.root)vvendl; return 0; }。

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

C 二叉树基本操作实验报告
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; //前一次访问的结点
(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)
CountLeaf(t->l);//递归统计左子树叶子数目 CountLeaf(t->r);//递归统计右子树叶子数目 } } return LeafNum; }
五、运行结果
附：完整程序源代码：
//二叉树链式存储的实现
#include<iostream> #include<cstring> #include <stack> using namespace std;

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

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

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

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

三、实验内容：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，即为叶子。

实验五 数据结构 二叉树基本操作实验报告(汽院)

实验五 数据结构 二叉树基本操作实验报告(汽院)
数据结构（
班级：
教师批阅处：
一、实验名称
二叉树基本操作的编程实现
二、实验目的
二叉树基本操作的编程实现，掌握二叉树的建立、遍历、插入、删除等基本操作的编程实现，存储结构主要采用链接结构。
三、实验内容
本次实验的内容有三种模式，我选择了第三种模式：用c进行程序的改进和提高，把下面的程序源码进行输入和改写，调试，直到成功。
1、补充三种递归遍历的方法
先根遍历：若二叉树不为空，先访问根节点，然后访问根节点的左子树，最后访问根节点的右子树。
中根遍历：若二叉树不为空，先访问根节点的左子树，然后访问根节点，最后访问根节点的右子树。
后跟遍历：若二叉树不为空，先访问根节点的左子树，然后访问根节点的右子树，最后访问根节点。
三种遍历的效果截图如下：
{
if(pnow!=NULL)
{
if (top<Maxsize-1)
{
top++;
stack[top].link=pnow;
stack[top].flag=1;
pnow=pnow->lchild;
}
else
{ return overflow; }
}
else
{
pnow=stack[top].link;
cout<<",";
else
cout<<")";
pnow=NULL;
}
}
}
cout<<endl;
return success;
}
3、补充层次遍历的方法
若二叉树不为空，从根节点开始从上至下逐层访问，同一层中从左到右逐个结点访问。效果截图如下：

二叉树的各种基本运算的实现实验报告

二叉树的各种基本运算的实现实验报告

二叉树的各种基本运算的实现实验报告
一、实验目的
实验目的为了深入学习二叉树的各种基本运算，通过操作实现二叉树的建立、存储、查找、删除、遍历等各种基本运算操作。

二、实验内容
1、构造一个二叉树。

我们首先用一定的节点来构建一棵二叉树，包括节点的左子节点和右子节点。

2、实现查找二叉树中的节点。

在查找二叉树中的节点时，我们根据二叉树的特点，从根节点开始查找，根据要查找的节点的值与根节点的值的大小的关系，来决定接下来查找的方向，直到找到要查找的节点为止。

3、实现删除二叉树中的节点。

在删除二叉树节点时，我们要做的是找到要删除节点的父节点，然后让父节点的链接指向要删除节点的子节点，有可能要删除节点有一个子节点，有可能有两个极点，有可能没有子节点，我们要根据每种情况进行处理，来保持二叉树的结构不变。

4、对二叉树进行遍历操作。

二叉树的遍历有多种方法，本实验使用的是先序遍历。

首先从根节点出发，根据先序遍历的顺序，先访问左子树，然后再访问右子树，最后访问根节点。

三、实验步骤
1、构建二叉树：
我们用一个数组代表要构建的二叉树，第一项为根节点，第二项和第三项是根节点的子节点。

(完整word版)《二叉树基本操作实验报告》

(完整word版)《二叉树基本操作实验报告》

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算学院：化学与材料科学学院专业班级：09级材料科学与工程系PB0920603姓名：李维谷学号：PB09206285邮箱：liwg@指导教师：贾伯琪实验时间：2010年10月17日一、需要分析问题描述：实现二叉树（包括二叉排序树）的建立，并实现先序、中序、后序和按层次遍历，计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目，以及二叉树常用运算。

问题分析：二叉树树型结构是一类重要的非线性数据结构，对它的熟练掌握是学习数据结构的基本要求。

由于二叉树的定义本身就是一种递归定义，所以二叉树的一些基本操作也可采用递归调用的方法。

处理本问题，我觉得应该：1、建立二叉树；2、通过递归方法来遍历（先序、中序和后序）二叉树；3、通过队列应用来实现对二叉树的层次遍历；4、借用递归方法对二叉树进行一些基本操作，如：求叶子数、树的深度宽度等；5、运用广义表对二叉树进行广义表形式的打印。

算法规定：输入形式：为了方便操作，规定二叉树的元素类型都为字符型，允许各种字符类型的输入，没有元素的结点以空格输入表示，并且本实验是以先序顺序输入的。

输出形式：通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印，再以广义表形式进行打印。

对二叉树的一些运算结果以整型输出。

程序功能：实现对二叉树的先序、中序和后序遍历，层次遍历。

计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。

对二叉树的某个元素进行查找，对二叉树的某个结点进行删除。

测试数据：输入一：ABC□□DE□G□□F□□□（以□表示空格）,查找5,删除E预测结果：先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A（B（C,D（E（,G）,F）））叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5，成功，查找的元素为E删除E 后，以广义表形式打印A （B （C,D （,F ）））输 入 二：ABD □□EH □□□CF □G □□□ （以□表示空格）,查找10,删除B 预测结果：先序遍历 ABDEHCFG中序遍历 DBHEAGFC 后序遍历 DHEBGFCA层次遍历 ABCDEFHG广义表打印 A （B(D,E(H)),C(F(,G))）叶子数 3 深度 4 宽度 3 非空子孙数 7 度为2的数目 2 度为1的数目3 查找10，失败。

二叉树实验报告

二叉树实验报告

二叉树实验报告1. 引言二叉树是一种常用的数据结构，广泛应用于计算机科学和信息技术领域。

本实验旨在通过对二叉树的理解和实现，加深对数据结构与算法的认识和应用能力。

本报告将介绍二叉树的定义、基本操作以及实验过程中的设计和实现。

2. 二叉树的定义二叉树是一个有序树，其每个节点最多有两个子节点。

树的左子节点和右子节点被称为二叉树的左子树和右子树。

3. 二叉树的基本操作3.1 二叉树的创建在实验中，我们通过定义一个二叉树的节点结构来创建一个二叉树。

节点结构包含一个数据域和左右指针，用于指向左右子节点。

创建二叉树的过程可以通过递归或者迭代的方式来完成。

3.2 二叉树的插入和删除二叉树的插入操作是将新节点插入到树中的合适位置。

插入时需要考虑保持二叉树的有序性。

删除操作是将指定节点从树中删除，并保持二叉树的有序性。

在实验中，我们可以使用递归或者循环的方式实现这些操作。

3.3 二叉树的遍历二叉树的遍历是指按照某种次序访问二叉树的所有节点。

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

前序遍历先访问根节点，然后按照左孩子-右孩子的顺序递归遍历左右子树。

中序遍历按照左孩子-根节点-右孩子的顺序递归遍历左右子树。

后序遍历按照左孩子-右孩子-根节点的顺序递归遍历左右子树。

3.4 二叉树的查找查找操作是指在二叉树中查找指定的值。

可以通过递归或者循环的方式实现二叉树的查找操作。

基本思路是从根节点开始，通过比较节点的值和目标值的大小关系，逐步向左子树或者右子树进行查找，直到找到目标节点或者遍历到叶子节点。

4. 实验设计和实现在本实验中，我们设计并实现了一个基于Python语言的二叉树类。

具体实现包括二叉树的创建、插入、删除、遍历和查找操作。

在实验过程中，我们运用了递归和迭代的方法实现了这些操作，并进行了测试和验证。

4.1 二叉树类的设计我们将二叉树的节点设计为一个类，其中包括数据域和左右子节点的指针。

另外，我们设计了一个二叉树类，包含了二叉树的基本操作方法。

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

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

二叉树的基本操作与实现实验报告二叉树是一种重要的数据结构，在计算机科学领域中被广泛应用。

本实验将介绍二叉树的基本操作与实现，并给出相应的实验报告。

一、引言二叉树是一种特殊的树状结构，每个节点至多有两个子节点。

二叉树有许多重要的特性，如平衡二叉树、二叉树等，应用广泛。

在本实验中，我们将介绍二叉树的基本操作和实现。

二、实验目的1.掌握二叉树的基本概念和特性；2.熟悉二叉树的基本操作，包括创建、插入、删除、遍历等；3.学会使用编程语言实现二叉树的基本操作。

三、实验内容本实验主要包括以下内容：1.二叉树的定义和基本概念；2.二叉树的基本操作，包括创建、插入、删除、遍历等；3.使用编程语言实现二叉树的基本操作；4.测试和验证二叉树的基本操作的正确性。

四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构，每个节点至多有两个子节点。

二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。

二叉树的特性有很多，如完全二叉树、平衡二叉树、二叉树等。

2.二叉树的基本操作（1）创建二叉树：可以通过手动输入节点数据来创建二叉树，也可以通过读取文件中的数据来创建二叉树。

（2）插入节点：在指定位置插入一个新节点。

（3）删除节点：删除指定位置的节点。

（4）遍历二叉树：有前序遍历、中序遍历和后序遍历三种遍历方式。

3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。

我们可以定义一个二叉树的结构体，包含节点数据和指向左右子树的指针。

然后根据具体的需求，实现相应的操作函数。

4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后，我们可以编写测试代码来验证操作的正确性。

通过创建二叉树，并进行插入、删除和遍历操作，观察输出结果是否符合预期。

五、实验结果与分析在完成二叉树的基本操作后，我们可以进行测试和验证。

通过输出二叉树的遍历结果，比对预期结果来判断操作是否正确。

同时，我们还可以观察二叉树的结构和特性，如是否满足平衡二叉树或二叉树的条件。

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

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

二叉树的基本操作实验报告二叉树的基本操作实验报告引言：二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。

二叉树的基本操作包括创建、遍历、插入和删除等。

本实验旨在通过实践来深入了解二叉树的基本操作，并通过实验结果验证其正确性和有效性。

一、创建二叉树创建二叉树是二叉树操作中的第一步。

在本实验中，我们使用了递归算法来创建二叉树。

递归算法是一种重要的算法思想，通过将问题划分为更小的子问题来解决复杂的问题。

在创建二叉树时，我们首先创建根节点，然后递归地创建左子树和右子树。

二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。

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

前序遍历先访问根节点，然后递归遍历左子树和右子树；中序遍历先递归遍历左子树，然后访问根节点，最后递归遍历右子树；后序遍历先递归遍历左子树和右子树，最后访问根节点。

三、插入节点插入节点是向二叉树中添加新节点的操作。

插入节点的过程需要遵循二叉树的特性，即左子节点的值小于父节点的值，右子节点的值大于父节点的值。

在插入节点时，我们需要找到合适的位置，将新节点插入到正确的位置上。

四、删除节点删除节点是从二叉树中移除节点的操作。

删除节点的过程相对复杂，需要考虑多种情况。

如果要删除的节点是叶子节点，直接删除即可。

如果要删除的节点只有一个子节点，将其子节点连接到父节点上。

如果要删除的节点有两个子节点，我们需要找到其后继节点或前驱节点来替代被删除的节点。

实验结果：通过实验，我们成功地实现了二叉树的基本操作。

创建二叉树的递归算法能够正确地创建出符合要求的二叉树。

遍历二叉树的算法能够按照指定的顺序遍历每个节点。

插入节点和删除节点的操作也能够正确地修改二叉树的结构。

讨论与总结：二叉树的基本操作是数据结构中的重要内容，对于理解和应用其他数据结构具有重要意义。

通过本次实验，我们深入了解了二叉树的创建、遍历、插入和删除等操作，并通过实验验证了其正确性和有效性。

数据结构实验报告(二叉树的基本操作)

数据结构实验报告(二叉树的基本操作)
else if((root->LChild==NULL)&&(root->RChild==NULL)) LeafNum=1;
else LeafNum=LeafCount(root->LChild)+LeafCount(root->RChild);
//叶子数为左右子树数目之和
return LeafNum;
printf("\n菜单选择\n\n");
printf(" 1.树状输出二叉树2.先序遍历二叉树\n");
printf(" 3.中序遍历二叉树4.后序遍历二叉树\n");
printf(" 5.输出叶子结点6.输出叶子结点的个数\n");
printf(" 7.输出二叉树的深度8.退出\n");
printf("\n----------------------------------------------------------------------\n");
{
printf("\n\n");
j=j+1; k=0;
while(k<nlocate)
{
printf(" ");
k++;
}
}
while(k<(nlocate-1))
{
printf(" ");
k++;
}
printf("%c",bt->data );
q.front=q.front+1;
if(bt->LChild !=NULL)//存在左子树，将左子树根节点入队列

二叉树操作实验报告

二叉树操作实验报告

二叉树操作实验报告一、实验背景二叉树是一种常用的数据结构，它由节点和连接节点的边组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。

在二叉树的操作中，常用的操作包括创建二叉树、插入节点、删除节点、查找节点、遍历等。

本次实验旨在通过对二叉树的操作，加强对二叉树数据结构的理解，并熟练掌握其操作方法。

二、实验目的1．掌握二叉树的创建方法，能够编写代码创建一个二叉树；2．了解二叉树的插入节点操作，掌握节点的插入方法；3．掌握二叉树的删除节点操作，了解节点删除的细节和方法；4．熟练掌握二叉树的查找节点操作；5．掌握二叉树的遍历方法，能够实现对二叉树的前序、中序、后序、层次遍历。

三、实验原理1．二叉树的创建方法：通过递归的方式，先创建根节点，再依次创建左子树和右子树；2．二叉树的插入节点操作：从根节点开始，根据节点值的大小关系，将待插入节点放到适当的位置；3．二叉树的删除节点操作：首先查找待删除的节点，然后根据其子节点的情况，进行相应的删除处理；4．二叉树的查找节点操作：从根节点开始遍历，根据节点值的大小关系，在左子树或右子树中继续查找，直到找到目标节点或遍历到叶子节点；5．二叉树的遍历方法：前序遍历先访问根节点，再遍历左子树和右子树；中序遍历先遍历左子树，再访问根节点和右子树；后序遍历先遍历左子树和右子树，再访问根节点；层次遍历按层次逐个访问节点。

四、实验过程1．创建二叉树：首先，定义二叉树的节点类，包含节点值和左右子节点；然后，通过递归的方式创建根节点、左子树和右子树。

2．插入节点：要插入一个节点，首先需要找到插入位置。

如果待插入节点大于当前节点的值，则插入到右子树中，否则插入到左子树中。

如果节点为空，则表示找到了插入位置。

3．删除节点：删除节点有以下几种情况：(1) 待删除节点为叶子节点：直接删除即可；(2) 待删除节点只有一个子节点：用子节点替换待删除节点的位置；(3) 待删除节点有两个子节点：找到待删除节点的后继节点（右子树的最左下角节点），用后继节点替换待删除节点的位置。

数据结构实验报告二叉树

数据结构实验报告二叉树

数据结构实验报告二叉树二叉树是一种重要的数据结构，广泛应用于计算机科学和算法设计中。

在本次实验中，我们通过实际编程实践，深入理解了二叉树的基本概念、性质和操作。

一、二叉树的定义和基本性质二叉树是一种特殊的树结构，每个节点最多有两个子节点。

它具有以下基本性质：1. 根节点：二叉树的顶部节点称为根节点，它没有父节点。

2. 子节点：每个节点最多有两个子节点，分别称为左子节点和右子节点。

3. 叶节点：没有子节点的节点称为叶节点。

4. 深度：从根节点到某个节点的路径长度称为该节点的深度。

5. 高度：从某个节点到其叶节点的最长路径长度称为该节点的高度。

6. 层次遍历：按照从上到下、从左到右的顺序遍历二叉树的节点。

二、二叉树的实现在本次实验中，我们使用C++语言实现了二叉树的基本操作，包括创建二叉树、插入节点、删除节点、查找节点等。

通过这些操作，我们可以方便地对二叉树进行增删改查。

三、二叉树的遍历二叉树的遍历是指按照某种顺序访问二叉树的所有节点。

常用的遍历方式有三种：前序遍历、中序遍历和后序遍历。

1. 前序遍历：先访问根节点，然后依次递归遍历左子树和右子树。

2. 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。

3. 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。

四、二叉树的应用二叉树在计算机科学和算法设计中有广泛的应用。

以下是一些常见的应用场景：1. 二叉搜索树：二叉搜索树是一种特殊的二叉树，它的左子树的值都小于根节点的值，右子树的值都大于根节点的值。

它可以高效地支持插入、删除和查找操作，常用于有序数据的存储和检索。

2. 堆：堆是一种特殊的二叉树，它的每个节点的值都大于（或小于）其子节点的值。

堆常用于实现优先队列等数据结构。

3. 表达式树：表达式树是一种用二叉树表示数学表达式的方法。

通过对表达式树的遍历，可以实现对数学表达式的计算。

4. 平衡树：平衡树是一种特殊的二叉树，它的左右子树的高度差不超过1。

二叉树实现及应用实验报告

二叉树实现及应用实验报告

二叉树实现及应用实验报告实验名称：二叉树实现及应用实验目的：1. 实现二叉树的创建、插入和删除操作。

2. 学习二叉树的遍历方法，并能够应用于实际问题。

3. 掌握二叉树在数据结构和算法中的一些常用应用。

实验内容：1. 实现二叉树的创建、插入和删除操作，包括二叉树的构造函数、插入函数和删除函数。

2. 学习二叉树的三种遍历方法：前序遍历、中序遍历和后序遍历，并应用于实际问题。

3. 掌握二叉树的一些常用应用，如二叉搜索树、平衡二叉树和哈夫曼树等。

实验步骤：1. 创建二叉树的结构体，包括树节点和树的根节点。

2. 实现二叉树的构造函数，用于创建二叉树的根节点。

3. 实现二叉树的插入函数，用于将元素插入到二叉树中的合适位置。

4. 实现二叉树的删除函数，用于删除二叉树中的指定元素。

5. 学习并实现二叉树的前序遍历、中序遍历和后序遍历函数。

6. 运用二叉树的遍历方法解决实际问题，如查找二叉树中的最大值和最小值。

7. 学习并应用二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构。

实验结果：1. 成功创建、插入和删除二叉树中的元素，实现了二叉树的基本操作。

2. 正确实现了二叉树的前序遍历、中序遍历和后序遍历，并能够正确输出遍历结果。

3. 通过二叉树的遍历方法成功解决了实际问题，如查找二叉树中的最大值和最小值。

4. 学习并熟练应用了二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构，丰富了对二叉树的理解。

实验分析：1. 二叉树是一种重要的数据结构，具有较好的数据存储和查找性能，广泛应用于计算机科学和算法领域。

2. 通过实验，我们深入了解了二叉树的创建、插入和删除操作，以及前序遍历、中序遍历和后序遍历的原理和应用。

3. 实际问题往往可以转化为二叉树的遍历问题进行求解，通过实验，我们成功应用了二叉树的遍历方法解决了实际问题。

4. 熟练掌握二叉搜索树、平衡二叉树和哈夫曼树的原理和应用，对于提高我们在数据结构和算法方面的设计能力具有重要意义。

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

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

宁波工程学院电信学院计算机教研室实验报告一、实验目的1、熟悉二叉树树的基本操作。

2、掌握二叉树的实现以及实际应用。

3、加深二叉树的理解，逐步培养解决实际问题的编程能力。

二、实验环境1台WINDOWS环境的PC机，装有Visual C++ 6.0。

三、实验内容【问题描述】现需要编写一套二叉树的操作函数，以便用户能够方便的利用这些函数来实现自己的应用。

其中操作函数包括：1>创建二叉树CreateBTNode(*b,*str)：根据二叉树括号表示法的字符串*str生成对应的链式存储结构。

2>输出二叉树DispBTNode(*b)：以括号表示法输出一棵二叉树。

3>查找结点FindNode(*b,x)：在二叉树b中寻找data域值为x的结点,并返回指向该结点的指针。

4>求高度BTNodeDepth(*b)：求二叉树b的高度。

若二叉树为空,则其高度为0；否则,其高度等于左子树与右子树中的最大高度加l。

5>求二叉树的结点个数NodesCount(BTNode *b)6>先序遍历的递归算法：void PreOrder(BTNode *b)7>中序遍历的递归算法：void InOrder(BTNode *b)8>后序遍历递归算法：void PostOrder(BTNode *b)9>层次遍历算法void LevelOrder(BTNode *b)【基本要求】实现以上9个函数。

主函数中实现以下功能：创建下图中的树b输出二叉树b找到’H’节点，输出其左右孩子值输出b的高度输出b的节点个数输出b的四种遍历顺序上图转化为二叉树括号表示法为A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))程序:#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data; /*数据元素*/struct node *lchild; /*指向左孩子*/struct node *rchild; /*指向右孩子*/} BTNode;void CreateBTNode(BTNode *&b,char *str);//创建BTNode *FindNode(BTNode *b,ElemType x);//查找节点int BTNodeHeight(BTNode *b);//求高度void DispBTNode(BTNode *b);//输出int NodesCount(BTNode *b);//二叉树的结点个数void PreOrder(BTNode *b);//先序遍历递归void InOrder(BTNode *b);//中序遍历递归void PostOrder(BTNode *b);//后序遍历递归void LevelOrder(BTNode *b);//层次遍历//创建void CreateBTNode(BTNode *&b,char *str){BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL;ch=str[j];while(ch!='\0'){switch(ch){case '(':top++;St[top]=p;k=1;break;case ')':top--;break;case ',':k=2;break;default:p=(BTNode *)malloc(sizeof(BTNode));p->data=ch;p->lchild=p->rchild=NULL;if(b==NULL)b=p;else{switch(k){case 1:St[top]->lchild=p;break;case 2:St[top]->rchild=p;break;}}}j++;ch=str[j];}}//输出void DispBTNode(BTNode *b){if(b!=NULL){printf("%c",b->data);if(b->lchild!=NULL||b->rchild!=NULL){printf("(");DispBTNode(b->lchild);if(b->rchild!=NULL)printf(",");DispBTNode(b->rchild);printf(")");}}}//查找节点BTNode *FindNode(BTNode *b,ElemType x){BTNode *p;if(b==NULL)return b;else if(b->data==x)return b;else{p=FindNode(b->lchild,x);if(p!=NULL)return p;elsereturn FindNode(b->rchild,x);}}//求高度int BTNodeHeight(BTNode *b){int lchildh,rchildh;if(b==NULL)return (0);else{lchildh=BTNodeHeight(b->lchild);rchildh=BTNodeHeight(b->rchild);return(lchildh>rchildh)?(lchildh+1):(rchildh+1);}}//二叉树的结点个数int NodesCount(BTNode *b){if(b==NULL)return 0;elsereturn NodesCount(b->lchild)+NodesCount(b->rchild)+1;}//先序遍历递归void PreOrder(BTNode *b){if(b!=NULL){printf("%c",b->data);PreOrder(b->lchild);PreOrder(b->rchild);}}//中序遍历递归void InOrder(BTNode *b){if(b!=NULL){InOrder(b->lchild);printf("%c",b->data);InOrder(b->rchild);}}//后序遍历递归void PostOrder(BTNode *b){if(b!=NULL){PostOrder(b->lchild);PostOrder(b->rchild);printf("%c",b->data);}}//层次遍历void LevelOrder(BTNode *b){BTNode *p;BTNode *qu[MaxSize];int front,rear;front=rear=-1;rear++;qu[rear]=b;while(front!=rear){front=(front+1)%MaxSize;p=qu[front];printf("%c",p->data);if(p->lchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->lchild;}if(p->rchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->rchild;}}}void main(){BTNode *b,*p,*lp,*rp;char str[]="A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";//根据树形图改写成的//二叉树括号表示法的字符串*str//char str[100];scanf("%s",&str);//自行输入括号表示的二叉树CreateBTNode(b,str); //创建树bprintf("\n");printf("输出二叉树:");//输出二叉树bDispBTNode(b);printf("\n");printf("'H'结点:");//找到'H'节点，输出其左右孩子值p=FindNode(b,'H');printf("\n");if (p!=NULL){printf("左孩子节点的值");printf("%c",p->lchild->data);printf("\n");printf("右孩子节点的值");printf("%c",p->rchild->data);printf("\n");//此处输出p的左右孩子节点的值}printf("\n");printf("二叉树b的深度:%d\n",BTNodeHeight(b));//输出b的高度printf("二叉树b的结点个数:%d\n",NodesCount(b));//输出b的节点个数printf("\n");printf(" 先序遍历序列:\n");//输出b的四种遍历顺序printf(" 算法:");PreOrder(b);printf("\n");printf(" 中序遍历序列:\n");printf(" 算法:");InOrder(b);printf("\n");printf(" 后序遍历序列:\n");printf(" 算法:");PostOrder(b);printf("\n");printf(" 层次遍历序列:\n");printf(" 算法:");LevelOrder(b); printf("\n");}四、实验心得与小结通过实验，我熟悉二叉树树的基本操作，掌握二叉树的实现以及实际应用。

二叉树基本操作--实验报告材料

二叉树基本操作--实验报告材料

实验三二叉树的基本操作学院:物理与电子学院班级:电信1105班姓名:刘岩学号:1404110729一、实验目的1、熟悉二叉树的基本操作，掌握二叉树的实现以及实际应用。

3、加深对于二叉树的理解，逐步培养解决实际问题的编程能力。

二、实验环境1台WINDOWS环境的PC机，装有Visual C++ 6.0。

三、实验内容1、问题描述现需要编写一套二叉树的操作函数，以便用户能够方便的利用这些函数来实现自己的应用。

其中操作函数包括：1>创建二叉树CreateBTNode(*b,*str)：根据二叉树括号表示法的字符串*str生成对应的链式存储结构。

2>输出二叉树DispBTNode(*b)：以括号表示法输出一棵二叉树。

3>查找结点FindNode(*b,x)：在二叉树b中寻找data域值为x的结点,并返回指向该结点的指针。

4>求高度BTNodeDepth(*b)：求二叉树b的高度。

若二叉树为空,则其高度为0；否则,其高度等于左子树与右子树中的最大高度加l。

5>求二叉树的结点个数NodesCount(BTNode *b)6>先序遍历的递归算法：void PreOrder(BTNode *b)7>中序遍历的递归算法：void InOrder(BTNode *b)8>后序遍历递归算法：void PostOrder(BTNode *b)9>层次遍历算法void LevelOrder(BTNode *b)2、基本要求实现以上9个函数。

主函数中实现以下功能：创建下图中的树b输出二叉树b找到’H’节点，输出其左右孩子值输出b的高度输出b的节点个数输出b的四种遍历顺序3、程序编写上图转化为二叉树括号表示法为A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))程序:#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data; /*数据元素*/struct node *lchild; /*指向左孩子*/struct node *rchild; /*指向右孩子*/} BTNode;void CreateBTNode(BTNode *&b,char *str);//创建BTNode *FindNode(BTNode *b,ElemType x);//查找节点int BTNodeHeight(BTNode *b);//求高度void DispBTNode(BTNode *b);//输出int NodesCount(BTNode *b);//二叉树的结点个数void PreOrder(BTNode *b);//先序遍历递归void InOrder(BTNode *b);//中序遍历递归void PostOrder(BTNode *b);//后序遍历递归void LevelOrder(BTNode *b);//层次遍历//创建void CreateBTNode(BTNode *&b,char *str){BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL;ch=str[j];while(ch!='\0'){switch(ch){case '(':top++;St[top]=p;k=1;break;case ')':top--;break;case ',':k=2;break;default:p=(BTNode *)malloc(sizeof(BTNode));p->data=ch;p->lchild=p->rchild=NULL;if(b==NULL)b=p;else{switch(k){case 1:St[top]->lchild=p;break;case 2:St[top]->rchild=p;break;}}}j++;ch=str[j];}}//输出void DispBTNode(BTNode *b){if(b!=NULL){printf("%c",b->data);if(b->lchild!=NULL||b->rchild!=NULL){printf("(");DispBTNode(b->lchild);if(b->rchild!=NULL)printf(",");DispBTNode(b->rchild);printf(")");}}}//查找节点BTNode *FindNode(BTNode *b,ElemType x){BTNode *p;if(b==NULL)return b;else if(b->data==x)return b;else{p=FindNode(b->lchild,x);if(p!=NULL)return p;elsereturn FindNode(b->rchild,x);}}//求高度int BTNodeHeight(BTNode *b){int lchildh,rchildh;if(b==NULL)return (0);else{lchildh=BTNodeHeight(b->lchild);rchildh=BTNodeHeight(b->rchild);return(lchildh>rchildh)?(lchildh+1):(rchildh+1);}}//二叉树的结点个数int NodesCount(BTNode *b){if(b==NULL)return 0;elsereturn NodesCount(b->lchild)+NodesCount(b->rchild)+1;}//先序遍历递归void PreOrder(BTNode *b){if(b!=NULL){printf("%c",b->data);PreOrder(b->lchild);PreOrder(b->rchild);}}//中序遍历递归void InOrder(BTNode *b){if(b!=NULL){InOrder(b->lchild);printf("%c",b->data);InOrder(b->rchild);}}//后序遍历递归void PostOrder(BTNode *b){if(b!=NULL){PostOrder(b->lchild);PostOrder(b->rchild);printf("%c",b->data);}}//层次遍历void LevelOrder(BTNode *b){BTNode *p;BTNode *qu[MaxSize];int front,rear;front=rear=-1;rear++;qu[rear]=b;while(front!=rear){front=(front+1)%MaxSize;p=qu[front];printf("%c",p->data);if(p->lchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->lchild;}if(p->rchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->rchild;}}}void main(){BTNode *b,*p,*lp,*rp;char str[]="A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";//根据树形图改写成的//二叉树括号表示法的字符串*str//char str[100];scanf("%s",&str);//自行输入括号表示的二叉树CreateBTNode(b,str); //创建树bprintf("\n");printf("输出二叉树:");//输出二叉树bDispBTNode(b);printf("\n");printf("'H'结点:");//找到'H'节点，输出其左右孩子值p=FindNode(b,'H');printf("\n");if (p!=NULL){printf("左孩子节点的值");printf("%c",p->lchild->data);printf("\n");printf("右孩子节点的值");printf("%c",p->rchild->data);printf("\n");//此处输出p的左右孩子节点的值}printf("\n");printf("二叉树b的深度:%d\n",BTNodeHeight(b));//输出b的高度printf("二叉树b的结点个数:%d\n",NodesCount(b));//输出b的节点个数printf("\n");printf(" 先序遍历序列:\n");//输出b的四种遍历顺序printf(" 算法:");PreOrder(b);printf("\n");printf(" 中序遍历序列:\n");printf(" 算法:");InOrder(b);printf("\n");printf(" 后序遍历序列:\n");printf(" 算法:");PostOrder(b);printf("\n");printf(" 层次遍历序列:\n");printf(" 算法:");LevelOrder(b); printf("\n");}四、实验心得与小结通过本次实验，我熟悉二叉树的基本知识内容，对课本的知识有了更加深刻的理解与掌握掌握。

二叉树的各种基本操作实验报告范文

二叉树的各种基本操作实验报告范文

二叉树的各种基本操作实验报告范文a.输入完全二叉树的先序序列,用#代表虚结点(空指针),如ABD###CE##F##建立二叉树,实现先序、中序和后序以及按层次遍历序列。

b.求所有叶子及结点总数。

掌握二叉树的存储实现;掌握二叉树的遍历思想;掌握二叉树的常见算法的程序实现。

实目项型验项二叉树的操作目类综合型完成时间2022-11-2实验目的及要求掌握二叉树的存储实现;掌握二叉树的遍历思想;掌握二叉树的常见算法的程序实现。

(实验步骤【实验过程】实验步骤、绘图、记录、数据、分析、结果)实验过程】实验步骤、绘图、记录、数据、分析、结果)(实验内容：实验内容：a.输入完全二叉树的先序序列，用#代表虚结点(空指针)如ABD###CE##F##建，立二叉树，实现先序、中序和后序以及按层次遍历序列。

b.求所有叶子及结点总数。

实验步骤：实验步骤：#include<tdio.h>#include<tdlib.h>#defineMA某10#defineSTACK_INIT_SIZE40//存储空间初始分配量#defineSTACKINCREMENT10//存储空间分配增量typedeftructBiTNode{chardata;tructBiTNode某lchild;tructBiTNode某rchild;}BiTNode,某BiTree;//将BiTree定义为指向二叉链表结点结构的指针类型BiTNode某bt;typedeftruct{BiTree某bae;inttop;inttackize;}SqStack;typedeftruct{BiTree某bae;a.输入完全二叉树的先序序列,用#代表虚结点(空指针),如ABD###CE##F##建立二叉树,实现先序、中序和后序以及按层次遍历序列。

b.求所有叶子及结点总数。

掌握二叉树的存储实现;掌握二叉树的遍历思想;掌握二叉树的常见算法的程序实现。

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

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY Array
数据结构
实验五二叉树基本操作的编程实现
【实验目的】
内容：二叉树基本操作的编程实现
要求：
二叉树基本操作的编程实现（2学时，验证型），掌握二叉树的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找等操作，存储结构主要采用顺序或链接结构。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】
验证性实验（学时数：2H）
【实验内容】
以下的选题都可以作为本次实验的推荐题目
1.建立二叉树，并以前序遍历的方式将结点内容输出。

2.将一个表示二叉树的数组结构转换成链表结构。

3.将表达式二叉树方式存入数组，以递归方式建立表达式之二叉树状结构，再分别输出前序、中序
及后序遍历结果，并计算出表达式之结果。

【注意事项】
1.开发语言：使用C。

2.可以自己增加其他功能。

【实验分析、说明过程】
【思考问题】
【实验小结】 (总结本次实验的重难点及心得、体会、收获)
【附录-实验代码】。

相关文档
最新文档