实验10 二叉树的基本操作
二叉树的基本操作
二叉树的基本操作二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。
二叉树在计算机领域中得到广泛应用，它的基本操作包括插入、删除、查找、遍历等。
1.插入操作：二叉树的插入操作是将一个新的节点添加到已有的二叉树中的过程。
插入操作会按照一定规则将新节点放置在正确的位置上。
插入操作的具体步骤如下：-首先，从根节点开始，比较新节点的值与当前节点的值的大小关系。
-如果新节点的值小于当前节点的值，则将新节点插入到当前节点的左子树中。
-如果新节点的值大于当前节点的值，则将新节点插入到当前节点的右子树中。
-如果当前节点的左子树或右子树为空，则直接将新节点插入到该位置上。
-如果当前节点的左子树和右子树都不为空，则递归地对左子树或右子树进行插入操作。
2.删除操作：二叉树的删除操作是将指定节点从二叉树中删除的过程。
删除操作有以下几种情况需要考虑：-如果待删除节点是叶子节点，则直接将其从二叉树中删除即可。
-如果待删除节点只有一个子节点，则将其子节点替换为待删除节点的位置即可。
-如果待删除节点有两个子节点，则需要找到其左子树或右子树中的最大节点或最小节点，将其值替换为待删除节点的值，然后再删除最大节点或最小节点。
3.查找操作：二叉树的查找操作是在二叉树中查找指定值的节点的过程。
查找操作的具体步骤如下：-从根节点开始，将待查找值与当前节点的值进行比较。
-如果待查找值等于当前节点的值，则返回该节点。
-如果待查找值小于当前节点的值，则在当前节点的左子树中继续查找。
-如果待查找值大于当前节点的值，则在当前节点的右子树中继续查找。
-如果左子树或右子树为空，则说明在二叉树中找不到该值。
4.遍历操作：二叉树的遍历操作是按照一定规则依次访问二叉树中的每个节点。
有三种常用的遍历方式：- 前序遍历（Preorder Traversal）：先访问根节点，然后递归地前序遍历左子树和右子树。
- 中序遍历（Inorder Traversal）：先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。
二叉树的建立与基本操作
二叉树的建立与基本操作二叉树是一种特殊的树形结构，它由节点（node）组成，每个节点最多有两个子节点。
二叉树的基本操作包括建立二叉树、遍历二叉树、查找二叉树节点、插入和删除节点等。
本文将详细介绍二叉树的建立和基本操作，并给出相应的代码示例。
一、建立二叉树建立二叉树有多种方法，包括使用数组、链表和前序、中序、后序遍历等。
下面以使用链表的方式来建立二叉树为例。
1.定义二叉树节点类首先，定义一个二叉树节点的类，包含节点值、左子节点和右子节点三个属性。
```pythonclass Node:def __init__(self, value):self.value = valueself.left = Noneself.right = None```2.建立二叉树使用递归的方法来建立二叉树，先构造根节点，然后递归地构造左子树和右子树。
```pythondef build_binary_tree(lst):if not lst: # 如果 lst 为空，则返回 Nonereturn Nonemid = len(lst) // 2 # 取 lst 的中间元素作为根节点的值root = Node(lst[mid])root.left = build_binary_tree(lst[:mid]) # 递归构造左子树root.right = build_binary_tree(lst[mid+1:]) # 递归构造右子树return root```下面是建立二叉树的示例代码：```pythonlst = [1, 2, 3, 4, 5, 6, 7]root = build_binary_tree(lst)```二、遍历二叉树遍历二叉树是指按照其中一规则访问二叉树的所有节点，常见的遍历方式有前序遍历、中序遍历和后序遍历。
1.前序遍历前序遍历是指先访问根节点，然后访问左子节点，最后访问右子节点。
```pythondef pre_order_traversal(root):if root:print(root.value) # 先访问根节点pre_order_traversal(root.left) # 递归访问左子树pre_order_traversal(root.right) # 递归访问右子树```2.中序遍历中序遍历是指先访问左子节点，然后访问根节点，最后访问右子节点。
二叉树的基本操作
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验十二叉树的基本操作学生姓名吴奇专业班级信管1204 学号31201403实验成绩指导老师（签名）日期一.实验目的和要求1、掌握二叉树的链式存储结构。
2、掌握在二叉链表上的二叉树操作的实现原理与方法。
3、进一步掌握递归算法的设计方法。
二.实验内容1、按照下面二叉树二叉链表的存储表示，编写头文件binary_tree.h，实现二叉链表的定义与基本操作实现函数；编写主函数文件test4_1.cpp，验证头文件中各个操作。
二叉树二叉链表存储表示如下：struct BTreeNode {ElemType data; // 结点值域BTreeNode *lchild , *rchild ; // 定义左右孩子指针} ;基本操作如下：①void InitBTree( BTreeNode *&BT );//初始化二叉树BT②void CreateBTree( BTreeNode *&BT, char *a );//根据字符串a所给出的广义表表示的二叉树建立二叉链表存储结构③int EmptyBTree( BTreeNode *BT);//检查二叉树BT是否为空，空返回1，否则返回0④int DepthBTree( BTreeNode *BT);//求二叉树BT的深度并返回该值⑤int FindBTree( BTreeNode *BT, ElemType x);//查找二叉树BT中值为x的结点，若查找成功返回1，否则返回0⑥void PreOrder( BTreeNode *BT);//先序遍历二叉树BT⑦void InOrder( BTreeNode *BT);//中序遍历二叉树BT⑧void PostOrder( BTreeNode *BT);//后序遍历二叉树BT⑨void PrintBTree( BTreeNode *BT );//输出二叉树BT⑩void ClearBTree( BTreeNode *&BT );//清除二叉树BT2、选做：实现以下说明的操作函数，要求把函数添加到头文件binary_tree.h 中，并在主函数文件test4_1.cpp中添加相应语句进行测试。
二叉树的基本操作实验报告
二叉树的基本操作实验报告学号姓名实验日期 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++二叉树基本操作实验报告
、实验目的选择二叉链式存储结构作为二叉树的存储结构，设计一个程序实现二叉树的基本操作（包括建立、输出、前序遍历、中序遍历、后序遍历、求树高、统计叶子总数等）二、实验开发环境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; }。
二叉树及二叉树的基本操作（基础篇）
⼆叉树及⼆叉树的基本操作（基础篇）⼀、相关概念树是n（ n>=0）个有限个数据的元素集合，它的数据的存储结构形状像⼀颗倒过来的树。
根在上，叶在下：如图所⽰1.⼀个独⽴的节点也可看作⼀棵树，它既为根节点，⼜为叶⼦节点；2.⼀个节点也没有称作空树；3.这是⼀颗典型的树，根节点为A；4.⼀个节点只有唯⼀⽗节点。
节点：结点包含数据和指向其它节点的指针。
根节点：树第⼀个结点称为根节点。
结点的度：结点拥有的⼦节点个数。
叶节点：没有⼦节点的节点(度为0)。
⽗⼦节点：⼀个节点father指向另⼀个节点child，则child为孩⼦节点， father为⽗亲节点。
兄弟节点：具有相同⽗节点的节点互为兄弟节点。
节点的祖先：从根节点开始到该节点所经的所有节点都可以称为该节点的祖先。
⼦孙：以某节点为根的⼦树中任⼀节点都称为该节点的⼦孙。
树的⾼度：树中距离根节点最远节点的路径长度。
如图⽰：5.树的存储结构1 struct TreeNode2 {3 DataType data; //节点值4 TreeNode* _firistchild; //第⼀个孩⼦5 TreeMode* _nextchild; //第⼆个孩⼦6 ...7 }；有时候根据需要还会加⼊⽗节点，结构如下：1 struct TreeNode2 {3 DataType data; //节点值4 TreeNode* _parent;5 TreeNode* _firistchild; //第⼀个孩⼦6 TreeMode* _nextchild; //第⼆个孩⼦7 ...8 }；⼆、⼆叉树1.⼆叉树:⼆叉树是⼀棵特殊的树，⼆叉树每个节点最多有两个孩⼦结点，分别称为左孩⼦和右孩⼦。
如图：2.存储结构1 template <class T>2 struct TreeNode //定义⼆叉树结点3 {5 TreeNode<T>* _left; //指向左⼦树的指针6 TreeNode<T>* _right; //指向右⼦树的指针7 T _data; //节点数据8 TreeNode(const T& n)9 :_left(NULL)10 ,_right(NULL)11 ,_data(n)12 {}13 };有时候根据需要还会加⼊⽗节点，结构如下：1 template <class T>2 struct TreeNode //定义⼆叉树结点3 {4 TreeNode<T>* _parent; //指向⽗节点的指针5 TreeNode<T>* _left; //指向左⼦树的指针6 TreeNode<T>* _right; //指向右⼦树的指针7 T _data; //节点数据8 TreeNode(const T& n)9 :_left(NULL)10 ,_right(NULL)11 ,_data(n)12 {}13 };3.特殊的⼆叉树满⼆叉树:⾼度为N的满⼆叉树有2^N - 1个节点的⼆叉树。
数据结构与算法实验——二叉树基本操作
二叉树基本操作实验报告实验名称二叉树基本操作实验目的1.熟悉二叉树结点的结构和二叉树的基本操作；2.掌握二叉树每种操作的具体实现；3.学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法；4.在二叉树基本操作的基础上掌握对二叉树的一些其它操作的具体实现方法；5.掌握构造哈夫曼树以及哈夫曼编码的方法。
实验内容编制一个演示二叉树创建、遍历、计算等操作的程序。
问题描述用数据结构相关知识，实现二叉树的定义和操作。
该程序包括二叉树结构类型以及对二叉树操作的具体的函数定义（包括：初始化二叉树、清空二叉树、检查二叉树是否为空、遍历二叉树（先序、后序、中序、层次）、求二叉树的深度、求二叉树所有节点数）。
问题分析该实验是基于C语言和数据结构知识基础的对二叉树的基本操作的检验，无需设计复杂的算法，程序语句也相对简单。
因此，我直接按要求定义了对二叉树操作的具体函数，并于主函数中实现对应的功能调用，其中，功能选择靠switch语句实现。
实验步骤1．需求分析本演示程序用VC++编写，完成二叉树的生成、遍历、计算等基本操作。
①输入的形式和输入值的范围：以字符（其中‘#’表示虚节点）的形式输入，以创建二叉树；在输入二叉树节点前，必须先确定该序列能正确创建二叉树。
②输出的形式：在所有三种操作中都显示操作是否正确以及操作后二叉树的内容。
③程序所能达到的功能：完成二叉树的生成、遍历（包括先序、后序、中序、层次四种方式）、计算等基本操作。
④测试数据：创建操作中依次输入a,b,d,#,g,#,#,#,c,e,#,#,f,#,#生成一个二叉树。
2．概要设计1）为了实现上述程序功能，需要定义二叉树的抽象数据类型：ADT BitTree {数据对象：由一个根节点和两个互不相交的左右子树构成数据关系：结点具有相同的数据类型及层次结构基本操作：Void BinTreeInit(BitTree *T)初始条件：无操作结果：初始化一棵二叉树Void BinTreeCreat(BitTree *T)初始条件：二叉树T已存在操作结果：按先序次序创建一棵二叉树2）本程序包含7个函数：①主函数main() ②初始化二叉树函数BinTreeInit() ③建立一棵二叉树函数BinTreeCreat() ④先序遍历函数PreOrderTraverse() ⑤中序遍历函数InOrderTraverse()⑥后序遍历函数PostOrderTraverse()⑦层次遍历函数LevelOrderTraverse()⑧求二叉树深度函数Countlevel()⑨检验空树函数BinTreeEmpty()⑩求节点数函数 Countnode()函数说明#include<stdio.h>#include<stdlib.h>typedef char Datatype;typedef struct NodeType{Datatype data;struct NodeType *lchild;struct NodeType *rchild;}BiTNode;typedef BiTNode * BinTree;//初始化二叉树。
(完整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.学会使用编程语言实现二叉树的基本操作。
三、实验内容本实验主要包括以下内容：1.二叉树的定义和基本概念；2.二叉树的基本操作，包括创建、插入、删除、遍历等；3.使用编程语言实现二叉树的基本操作；4.测试和验证二叉树的基本操作的正确性。
四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构，每个节点至多有两个子节点。
二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。
二叉树的特性有很多，如完全二叉树、平衡二叉树、二叉树等。
2.二叉树的基本操作（1）创建二叉树：可以通过手动输入节点数据来创建二叉树，也可以通过读取文件中的数据来创建二叉树。
（2）插入节点：在指定位置插入一个新节点。
（3）删除节点：删除指定位置的节点。
（4）遍历二叉树：有前序遍历、中序遍历和后序遍历三种遍历方式。
3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。
我们可以定义一个二叉树的结构体，包含节点数据和指向左右子树的指针。
然后根据具体的需求，实现相应的操作函数。
4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后，我们可以编写测试代码来验证操作的正确性。
通过创建二叉树，并进行插入、删除和遍历操作，观察输出结果是否符合预期。
五、实验结果与分析在完成二叉树的基本操作后，我们可以进行测试和验证。
通过输出二叉树的遍历结果，比对预期结果来判断操作是否正确。
同时，我们还可以观察二叉树的结构和特性，如是否满足平衡二叉树或二叉树的条件。
二叉树的基本操作实验报告
二叉树的基本操作实验报告二叉树的基本操作实验报告引言：二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。
二叉树的基本操作包括创建、遍历、插入和删除等。
本实验旨在通过实践来深入了解二叉树的基本操作，并通过实验结果验证其正确性和有效性。
一、创建二叉树创建二叉树是二叉树操作中的第一步。
在本实验中，我们使用了递归算法来创建二叉树。
递归算法是一种重要的算法思想，通过将问题划分为更小的子问题来解决复杂的问题。
在创建二叉树时，我们首先创建根节点，然后递归地创建左子树和右子树。
二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点，然后递归遍历左子树和右子树；中序遍历先递归遍历左子树，然后访问根节点，最后递归遍历右子树；后序遍历先递归遍历左子树和右子树，最后访问根节点。
三、插入节点插入节点是向二叉树中添加新节点的操作。
插入节点的过程需要遵循二叉树的特性，即左子节点的值小于父节点的值，右子节点的值大于父节点的值。
在插入节点时，我们需要找到合适的位置，将新节点插入到正确的位置上。
四、删除节点删除节点是从二叉树中移除节点的操作。
删除节点的过程相对复杂，需要考虑多种情况。
如果要删除的节点是叶子节点，直接删除即可。
如果要删除的节点只有一个子节点，将其子节点连接到父节点上。
如果要删除的节点有两个子节点，我们需要找到其后继节点或前驱节点来替代被删除的节点。
实验结果：通过实验，我们成功地实现了二叉树的基本操作。
创建二叉树的递归算法能够正确地创建出符合要求的二叉树。
遍历二叉树的算法能够按照指定的顺序遍历每个节点。
插入节点和删除节点的操作也能够正确地修改二叉树的结构。
讨论与总结：二叉树的基本操作是数据结构中的重要内容，对于理解和应用其他数据结构具有重要意义。
通过本次实验，我们深入了解了二叉树的创建、遍历、插入和删除等操作，并通过实验验证了其正确性和有效性。
数据结构实验报告(二叉树的基本操作)
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)//存在左子树，将左子树根节点入队列
二叉树的基本操作
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验十二叉树的基本操作学生姓名吴奇专业班级信管1204 学号31201403实验成绩指导老师（签名）日期一.实验目的和要求1、掌握二叉树的链式存储结构。
2、掌握在二叉链表上的二叉树操作的实现原理与方法。
3、进一步掌握递归算法的设计方法。
二.实验内容1、按照下面二叉树二叉链表的存储表示，编写头文件binary_tree.h，实现二叉链表的定义与基本操作实现函数；编写主函数文件test4_1.cpp，验证头文件中各个操作。
二叉树二叉链表存储表示如下：struct BTreeNode {ElemType data; // 结点值域BTreeNode *lchild , *rchild ; // 定义左右孩子指针} ;基本操作如下：①void InitBTree( BTreeNode *&BT );//初始化二叉树BT②void CreateBTree( BTreeNode *&BT, char *a );//根据字符串a所给出的广义表表示的二叉树建立二叉链表存储结构③int EmptyBTree( BTreeNode *BT);//检查二叉树BT是否为空，空返回1，否则返回0④int DepthBTree( BTreeNode *BT);//求二叉树BT的深度并返回该值⑤int FindBTree( BTreeNode *BT, ElemType x);//查找二叉树BT中值为x的结点，若查找成功返回1，否则返回0⑥void PreOrder( BTreeNode *BT);//先序遍历二叉树BT⑦void InOrder( BTreeNode *BT);//中序遍历二叉树BT⑧void PostOrder( BTreeNode *BT);//后序遍历二叉树BT⑨void PrintBTree( BTreeNode *BT );//输出二叉树BT⑩void ClearBTree( BTreeNode *&BT );//清除二叉树BT2、选做：实现以下说明的操作函数，要求把函数添加到头文件binary_tree.h 中，并在主函数文件test4_1.cpp中添加相应语句进行测试。
二叉树的基本操作实验
图（1）
图表1
else if(a==4)
{
printf("层序遍历:");
howmuch(T,2);
}
else if(a==5)
{
printf("总节点数：");
howmuch(T,0);
}
else if(a==6)
{
printf("总叶子数：");
howmuch(T,1);
}
else if(a==7)
{
printf("树的深度：");
二 概要设计
功能实现
1.int CreatBiTree(BiTree &T)用递归的方法先序建立二叉树, 并用链表储存该二叉树
2.int PreTravel(BiTree &T)前序遍历
3.intMidTravel(BiTree &T)中序遍历
4.intPostTravel(BiTree &T)后序遍历
实验三 二叉树的基本运算
一、实验目的
1、使学生熟练掌握二叉树的逻辑结构和存储结构。
2、熟练掌握二叉树的各种遍历算法。
二、实验内容
[问题描述]
建立一棵二叉树，试编程实现二叉树的如下基本操作：
1. 按先序序列构造一棵二叉链表表示的二叉树T；
2. 对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列；
5.int Depth(BiTree &T) //计算树的深度
6.inthowmuch(BiTree T,int h)采用树节点指针数组，用于存放遍历到的元素地址，如果有左孩子，存入地址，j加一 ，否则没操作，通过访问数组输出层次遍历的结果。k计算叶子数，j为总节点。
二叉树的基本操作
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验十二叉树的基本操作学生姓名吴奇专业班级信管1204 学号实验成绩指导老师（签名）日期一.实验目的和要求1、掌握二叉树的链式存储结构。
2、掌握在二叉链表上的二叉树操作的实现原理与方法。
3、进一步掌握递归算法的设计方法。
二.实验内容1、按照下面二叉树二叉链表的存储表示，编写头文件，实现二叉链表的定义与基本操作实现函数；编写主函数文件，验证头文件中各个操作。
二叉树二叉链表存储表示如下：struct BTreeNode {ElemType data; 函数的功能说明及算法思路struct BtreeNode{elemtype data; 实验结果与分析五.心得体会通过这次实验，我掌握了二叉树的基本操作，对非线性储存结构有了一定的了解，相对于之前的线性储存结构来说，非线性储存结构确实是比较抽象、困难的，在接下来的时间里，要好好对非线性储存结构了解一番。
【附录----源程序】struct BtreeNode{elemtype data; //结点值域BtreeNode *lchild; //定义左孩子指针BtreeNode *rchild; //定义右孩子指针};struct lnode{ //定义队列结点结构用于二叉树层遍历BtreeNode *data1;lnode *next;};struct Queue{ //定义队列首尾指针lnode *front;lnode *back;};void initQueue(Queue &Q) //初始化队列{==NULL;}void insertQueue(Queue &Q,BtreeNode *item) //元素入队列{lnode *newptr=new lnode;newptr->data1=item;newptr->next=NULL;if==NULL)==newptr;else=>next=newptr;}BtreeNode *deleteQueue(Queue &Q) //队首元素出队列{BtreeNode *temp=>data1;lnode *p=;=p->next;if==NULL)=NULL;delete p;return temp;}bool emptyQueue(Queue Q) //判断队列是否为空{return ==NULL;}void initBtree(BtreeNode *&BT) //二叉树的初始化{BT=NULL;}void insertBtree(BtreeNode *&BT) //创建二叉树{elemtype ch;ch=getchar();if(ch=='$') //判断是不是结束标志BT=NULL;else{BT=new BtreeNode; //创建结点BT->data=ch; //赋值insertBtree(BT->lchild); //左子叶递归insertBtree(BT->rchild); //右子叶递归}}bool emptyBtree(BtreeNode *BT) //判断二叉树是否为空{return BT==NULL;}int depthBtree(BtreeNode *BT) //求二叉树的深度if(emptyBtree(BT))return 0;else{int dep1=depthBtree(BT->lchild); //左子叶递归int dep2=depthBtree(BT->rchild); //右子叶递归return dep1>dep2dep1+1:dep2+1; //判断哪个子叶的深度最大//树的深度为左右子叶的最大深度加上1 }}void preorder(BtreeNode *BT) //前序遍历{if(!emptyBtree(BT)){cout<<BT->data<<" "; //输出结点值preorder(BT->lchild); //左子叶递归preorder(BT->rchild); //右子叶递归}}void midorder(BtreeNode *BT) //中序遍历{if(!emptyBtree(BT)){midorder(BT->lchild); //左子叶递归cout<<BT->data<<" "; //输出结点值midorder(BT->rchild); //右子叶递归}}void laterorder(BtreeNode *BT) //后序遍历if(!emptyBtree(BT)){laterorder(BT->lchild); //左子叶递归laterorder(BT->rchild); //右子叶递归cout<<BT->data<<" "; //输出结点值}}bool findBtree(BtreeNode *BT,elemtype x) //查找二叉树中结点元素为x值的结点{if(emptyBtree(BT)) //空树，返回falsereturn false;else{if(BT->data==x) //找到，返回truereturn true;else{if(findBtree(BT->lchild,x)) //左子叶递归查找return true;if(findBtree(BT->rchild,x)) //右子叶递归查找return true;return false;}}}void levelorder(BtreeNode *BT) //按层遍历二叉树{Queue queue; //用于存放二叉树结点的队列initQueue(queue);BtreeNode *P;if(!emptyBtree(BT)) //二叉树不为空，根节点入队insertQueue(queue,BT);while(!emptyQueue(queue)){ //当队列不为空时，队首元素出队列P=deleteQueue(queue);cout<<P->data<<" "; //输出出队元素值if(P->lchild!=NULL) //当左右子叶不为空时，递归insertQueue(queue,P->lchild);if(P->rchild!=NULL)insertQueue(queue,P->rchild);}}int Get_Sub_Depth(BtreeNode *BT,elemtype x)//求二叉树中以元素值为x的结点为根的子树的深度{int m,n;if(!emptyBtree(BT)){ //二叉树非空if(BT->data==x) //找到，返回其深度return depthBtree(BT);else{m=Get_Sub_Depth(BT->lchild,x); //左右子叶递归，返回深度n=Get_Sub_Depth(BT->rchild,x);return m>nm:n;}}elsereturn 0;void printBtree(BtreeNode *BT,int n) //打印二叉树{int i;if(emptyBtree(BT)) //二叉树为空，返回return;printBtree(BT->rchild,n+1); //先递归输出右子树for(i=0;i<n;i++)cout<<" "; //前导空格，表示层次cout<<"---";cout<<BT->data; //结点的值cout<<endl;printBtree(BT->lchild,n+1); //再递归输出右子树}void PrintBtree(BtreeNode *BT) //二叉树的广义表打印{if(!emptyBtree(BT)){cout<<BT->data;if(!emptyBtree(BT->lchild)||!emptyBtree(BT->rchild)){ cout<<"(";PrintBtree(BT->lchild);if(!emptyBtree(BT->rchild))cout<<",";PrintBtree(BT->rchild);cout<<")";}}#include<>#include<>#include<>typedef char elemtype;#include""void main(){BtreeNode *Btree;initBtree(Btree);elemtype a,b;cout<<"请严格按照先序顺序输入二叉树中的数据，以“$”为每个结点的结束标志"<<endl;insertBtree(Btree);cout<<"二叉树的深度为："<<depthBtree(Btree)<<endl;cout<<"先序遍历二叉树：";preorder(Btree);cout<<endl;cout<<"中序遍历二叉树：";midorder(Btree);cout<<endl;cout<<"后序遍历二叉树：";laterorder(Btree);cout<<endl;cout<<"层序遍历二叉树：";levelorder(Btree);cout<<endl;cout<<"请输入需查找字符：";cin>>a;if(findBtree(Btree,a))cout<<"查找字符"<<a<<"成功！"<<endl;elsecout<<"查找失败，没有该字符！"<<endl;cout<<"请输入以元素值为x的结点为根的子树的深度的x的值：";cin>>b;if(Get_Sub_Depth(Btree,b)==0)cout<<"未查询到该结点！！"<<endl;elsecout<<"结点元素值为x的深度为："<<Get_Sub_Depth(Btree,b)<<endl;cout<<"二叉树的广义表打印如下图："<<endl;PrintBtree(Btree);cout<<endl;cout<<"二叉树打印如下图："<<endl;printBtree(Btree,depthBtree(Btree));}。
二叉树基本操作
二叉树基本操作二叉树基本操作一、实验目的1．熟悉二叉树结点的结构和对二叉树的基本操作。
2．掌握对二叉树每一种操作的具体实现。
3．学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。
4．在二叉树基本操作的基础上掌握对二叉树的一些其它操作的具体实现方法。
5．掌握构造哈夫曼树以及哈夫曼编码的方法。
二、实验内容（必做1）程序 1该程序的功能是实现二叉树结点的类型定义和对二叉树的基本操作。
该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。
/* 定义 DataType 为char类型 */typedef char DataType;/* 二叉树的结点类型 */typedef struct BitNode{DataType data;struct BitNode *lchild,*rchild;}BitNode,*BitTree;/* 初始化二叉树，即把树根指针置空 */void BinTreeInit(BitTree *BT)/* 按先序次序建立一个二叉树*/void BinTreeCreat(BitTree *BT)/* 检查二叉树是否为空 */int BinTreeEmpty(BitTree *BT)/* 按任一种遍历次序（包括按先序、中序、后序、按层次）输出二叉树中的所有结点 */void BinTraverse(BitTree *BT)/* 求二叉树的深度 */int BinTreeDepth(BitTree BT)/* 求二叉树中所有结点数 */int BinTreeCount(BitTree BT)/* 清除二叉树，使之变为空树 */void BinTreeClear(BitTree *BT)程序2 二叉树采用二叉链表存储，设计按层次遍历二叉树的算法。
设计要求：在程序中构造两个子程序分别为void BinTreeCreat(BitTree *BT) /* 按前序次序建立一个二叉树*/ void layorder(BitTree T) /*按层次遍历二叉树 */程序 3哈夫曼树和哈夫曼编码：从终端输入若干个字符，统计字符出现的频率，将字符出现的频率作为结点的权值，建立哈夫曼树，然后对各字符进行哈夫曼编码。
实验十 二叉树的基本操作
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验十二叉树的基本操作学生姓名专业班级学号实验成绩指导老师（签名）日期一.实验目的和要求1、掌握二叉树的链式存储结构。
2、掌握在二叉链表上的二叉树操作的实现原理与方法。
3、进一步掌握递归算法的设计方法。
二.实验内容1、建立头文件test10.h，在该文件中定义二叉树的链式存储结构，并编写二叉树的各种基本操作实现函数。
同时建立一个验证操作实现的主函数文件test10.cpp，编译并调试程序，直到正确运行。
注意：需要用到栈和队列的有关操作。
说明：二叉树的基本操作可包括：(1) void InitBTree( BTreeNode *&BT ) //初始化二叉树BT(2) void CreateBTree( BTreeNode *&BT, char *a )//根据字符串a所给出的广义表表示的二叉树建立二叉链表存储结构(3) int EmptyBTree( BTreeNode *BT)//检查二叉树BT是否为空，空返回1，否则返回0(4) int DepthBTree( BTreeNode *BT) //求二叉树BT的深度并返回该值(5) int FindBTree( BTreeNode *BT, ElemType x)//查找二叉树BT中值为x的结点，若查找成功返回1，否则返回0(6) void PreOrder( BTreeNode *BT) //先序遍历二叉树BT(7) void InOrder( BTreeNode *BT) //中序遍历二叉树BT(8) void PostOrder( BTreeNode *BT) //后序遍历二叉树BT(9) void LevelOrder( BTreeNode *BT ) //按层次遍历二叉树BT(10) void PrintBTree( BTreeNode *BT ) //输出二叉树BT(11) void ClearBTree( BTreeNode *&BT ) //清除二叉树BT2、以下内容为第二次实验完成：(1) 请编写函数实现中序遍历的非递归算法。
二叉树的基本操作实现（数据结构实验）
⼆叉树的基本操作实现（数据结构实验）实验题⽬：⼆叉树的基本操作实现实验⽬的：掌握⼆叉树的⼆叉链存储结构及表⽰。
掌握⼆叉树的三种遍历算法（递归和⾮递归两类）。
运⽤三种遍历的⽅法求解⼆叉树的有关问题。
实验内容：实现⼆叉树的⼆叉链表存储结构；实现先序、中序和后序遍历⼆叉树；遍历⼆叉树的应⽤:计算叶⼦结点、左右⼦树交换等。
要求：1、⼆叉树基本操作已实现，学习和进⼀步理解。
2 、在求总结点的程序中加⼊求叶⼦结点的功能。
3 、左右⼦树交换,按中序和后序是否也可以？4 、选作：按层遍历⼆叉树。
实验代码：#include<stdio.h>#include<malloc.h>#include<string.h>#include<stdlib.h>#include<iostream>#define MAXTSIZE 1000using namespace std;/*测试数据： abc##de#g##f###*/typedef struct BiTNode{char data; // 结点数据域struct BiTNode *lchild,*rchild; // 左右孩⼦指针}BiTNode,*BiTree;void CreateBiTree(BiTree &T) // 先序遍历建⽴⼆叉链表{char ch;cin>>ch;// scanf("%c",&ch);if(ch=='#')T=NULL;else{T=(BiTNode *)malloc(sizeof(BiTNode));T->data=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}void travel1(BiTree T) // 先序遍历{if(T){printf("%c",T->data);travel1(T->lchild);travel1(T->rchild);}}void travel2(BiTree T) // 中序遍历{if(T){travel2(T->lchild);printf("%c",T->data);travel2(T->rchild);}}void travel3(BiTree T) // 后序遍历{if(T){travel3(T->lchild);travel3(T->rchild);printf("%c",T->data);}}int count(BiTree T) // 计算叶⼦结点的个数{if(T==NULL) return0;int cnt=0;if((!T->lchild)&&(!T->rchild)){cnt++;}int leftcnt=count(T->lchild);int rightcnt=count(T->rchild);cnt+=leftcnt+rightcnt;return cnt;}int Depth(BiTree T) // 计算⼆叉树的深度{if(T==NULL) return0;else{int m=Depth(T->lchild);int n=Depth(T->rchild);return m>n?(m+1):(n+1);}}void exchange(BiTree T,BiTree &NewT) // 交换左右⼦树{if(T==NULL){NewT=NULL;return ;}else{NewT=(BiTNode *)malloc(sizeof(BiTNode));NewT->data=T->data;exchange(T->lchild,NewT->rchild); // 复制原树的左⼦树给新树的右⼦树 exchange(T->rchild,NewT->lchild); // 复制原树的右⼦树给新树的左⼦树 }}int main(){puts("**************************");puts("1. 建⽴⼆叉树");puts("2. 先序遍历⼆叉树");puts("3. 中序遍历⼆叉树");puts("4. 后序遍历⼆叉树");puts("5. 计算叶⼦结点个数");puts("6. 计算⼆叉树的深度");puts("7. 交换⼆叉树的左右⼦树");puts("0. 退出");puts("**************************");BiTree Tree,NewTree;int choose;while(~scanf("%d",&choose),choose){switch(choose){case1:puts("温馨提醒：输⼊请以 '#' 为左/右⼦树空的标志!");CreateBiTree(Tree);break;case2:printf("先序遍历结果为：");travel1(Tree);puts("");break;case3:printf("中序遍历结果为：");travel2(Tree);puts("");break;case4:printf("后序遍历结果为：");travel3(Tree);puts("");break;case5:printf("叶⼦结点个数为：%d\n",count(Tree));break;case6:printf("⼆叉树的深度为：%d\n",Depth(Tree));break;case7:exchange(Tree,NewTree);Tree=NewTree;puts("交换成功！\n");break;}}system("pause");return0;}。
蔡少云数据结构实验报告——二叉树的基本操作
数据结构实验报告学院：管理学院班级： 13电商1班姓名：蔡少云学号： 321300---- 2014年12 月1 日目录一、需求分析………………………………………问题描述…………………………………………基本要求…………………………………………实现说明…………………………………………二、设计目的………………………………………三、概要设计………………………………………基本框架图………………………………………设计想法…………………………………………四、详细设计………………………………………结点类……………………………………二叉树接口…………………………………………二叉树类………………………………………测试类………………………………………五、测试结果………………………………………基本数据…………………………………………操作截图…………………………………………六、用户使用说明…………………………………七、心得体会………………………………………题目：二叉树的基本操作一、需求分析【问题描述】在一棵二叉链表表示的二叉树中，实现以下操作，并说明采用哪种遍历算法，其他遍历算法是否可行。
1.二叉树的先根次序遍历2.输出以p结点为根的子树的所有叶子结点，先根次序遍历算法3.将每个结点的左子树与右子树交换4.由中根和后根次序遍历序列构造二叉树5.二叉树深拷贝，复制一棵二叉树【基本要求】建立结点类，二叉树接口。
实现二叉树的先根次序遍历，中根次序遍历和后根次序遍历。
【实现说明】可以利用利用二叉树的先根次序遍历完成相应功能。
二、设计目的1、达到熟悉掌握java和数据结构的基本知识和技能；2、能够利用所学的基本知识和技能，解决简单的面向对象的设计问题；3、把课本上的知识应用到实际生活中，达到学以致用的目的；4、复习学过的知识，思考新的问题；三、概要设计(1)基本框架图：实现(2)设计想法:结点类属性：data 、left 、right 构造函数 方法：输出方法、判断是否叶子结点方法 二叉树接口 将每个结点的左子树与右子树交换leaf1() 遍历输出叶子结点lrTran(); 先根、中根、后根次序遍历二叉树 判断二叉树是否为空isEmpty() 二叉树深拷贝，复制一棵二叉树抽象 方法二叉树类1、建立结点类BinaryNode；2、建立二叉树接口BinaryTTree<T>3、建立二叉树类，实现二叉树接口BinaryTree<T>4、建立主类，创建二叉树，进行测试。
二叉树的定义及基本操作
二叉树的定义及基本操作一、实验目的、意义（1）熟悉二叉链表表示的二叉树结构及其递归遍历。
（2）掌握建立二叉链表要领，深入理解递归遍历二叉链表的执行路径。
（3）根据具体问题的需要，能够设计出相关算法。
二、实验内容及要求说明1：学生在上机实验时，需要自己设计出所涉及到的函数，同时设计多组输入数据并编写主程序分别调用这些函数，调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
具体要求：（1）定义二叉树的链式存储结构；（2）建立一颗二叉链表表示的二叉树；（3）对其进行前序，中序，后序输出。
三、实验所涉及的知识点C语言算法、循环算法、二叉树结构及其递归遍历、二叉链表的建立，二叉树的前序，中序，后序输出。
四、实验结果及分析（所输入的数据及相应的运行结果，运行结果要有提示信息，运行结果采用截图方式给出。
）五、总结与体会（调试程序的心得与体会，若实验课上未完成调试，要认真找出错误并分析原因等。
）(调试过程及调试中遇到的问题及解决办法，其他算法的存在与实践等。
)调试时，由于对所学知识点概念模糊，二叉树结构及其递归遍历不熟悉，试验出现了很大的困难，课上未完成实验，并且还出现一些语法上的错误，经过反复排错、查阅资料，花了大量时间才解决问题。
六、程序清单(包含注释)#include<iostream.h>#include<stdlib.h>typedef char DataType;typedef struct BitNode{DataType data;struct BitNode *lchild,*rchild;}*BitTree;void BinTreeInit(BitTree &BT)//初始化二叉树，即把树根指针置空{BT=(BitTree)malloc(sizeof(BitNode));BT->data=NULL;cout<<"二叉树初始化成功!";}int BinTreeCreat(BitTree &BT)//按先序次序建立一个二叉树{char ch;cin>>ch;if(ch=='#') BT=NULL;else{if(!(BT=(BitTree)malloc(sizeof(BitNode))))exit(0);BT->data=ch;BinTreeCreat(BT->lchild);BinTreeCreat(BT->rchild);}return 0;// 按先序序列建立一个二叉树已经完成!}void BinTreeEmpty(BitTree &BT)//检查二叉树是否为空{if(BT->data==NULL)cout<<"是空二叉树!";elsecout<<"不是空二叉树!";}void BinTraverse1(BitTree &BT)//先序序列遍历二叉树{if(BT!=NULL){cout<<BT->data;BinTraverse1(BT->lchild);BinTraverse1(BT->rchild);}}void BinTraverse2(BitTree &BT)//中序序列遍历二叉树{if(BT!=NULL){BinTraverse2(BT->lchild);cout<<BT->data;BinTraverse2(BT->rchild);}}void BinTraverse3(BitTree &BT)//后序序列遍历二叉树{if(BT!=NULL){BinTraverse3(BT->lchild);BinTraverse3(BT->rchild);cout<<BT->data;}}int BinTreeDepth(BitTree BT)//求二叉树的深度{int depthval;if(BT){int depthLeft=BinTreeDepth(BT->lchild);int depthRight=BinTreeDepth(BT->rchild);depthval=1+(depthLeft>depthRight?depthLeft:depthRight);}else depthval=0;return depthval;}int BinTreeCount(BitTree BT)//求二叉树中所有结点数{int node;if(BT){int lchild=BinTreeCount(BT->lchild);int rchild=BinTreeCount(BT->rchild);node=lchild+rchild+1;}elsenode=0;return node;}void main(){int i;BitTree BT;cout<<"1、初始化二叉树:"<<"\n2、按先序序列建立二叉树"<<"\n3、判断二叉树是否为空:";cout<<"\n4、序列遍历二叉树"<<"\n5、求二叉树的深度"<<"\n6、求二叉树节点的个数";for(;;){cout<<"输出你所需的操作:";cin>>i;if(i==1)BinTreeInit(BT);else if(i==2){cout<<"输入你要建立的二叉树:";BinTreeCreat(BT);}else if(i==3)BinTreeEmpty(BT);else if(i==4){ BinTraverse1(BT);cout<<"\n";BinTraverse2(BT);cout<<"\n";BinTraverse3(BT);cout<<"\n";}else if(i==5)cout<<"二叉树的深度:"<<BinTreeDepth(BT);else if(i==6)cout<<"二叉树的节点数"<<BinTreeCount(BT);elsereturn ;}}（注：可编辑下载，若有不当之处，请指正，谢谢!）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
浙江大学城市学院实验报告
课程名称数据结构
实验项目名称实验十二叉树的基本操作
学生姓名专业班级学号
实验成绩指导老师（签名）日期
一.实验目的和要求
1、掌握二叉树的链式存储结构。
2、掌握在二叉链表上的二叉树操作的实现原理与方法。
3、进一步掌握递归算法的设计方法。
二.实验内容
1、按照下面二叉树二叉链表的存储表示，编写头文件binary_tree.h，实现二叉链表的定义与基本操作实现函数；编写主函数文件test10.cpp，验证头文件中各个操作。
二叉树二叉链表存储表示如下：
typedef struct BiTNode {
TElemType data ;
struct BiTNode *lchild , *rchild ;
}BiTNode,*BiTree ;
基本操作如下：
①void InitBiTree(BiTree &T )
//初始化二叉树T
②void CreateBiTree(BiTree &T)
//按先序遍历序列建立二叉链表T
③bool BiTreeEmpty (BiTree T);
//检查二叉树T是否为空，空返回1，否则返回0
④int BiTreeDepth(BiTree T);
//求二叉树T的深度并返回该值
⑤void PreOrderTraverse (BiTree T);
//先序遍历二叉树T
⑥void InOrderTraverse (BiTree T);
//中序遍历二叉树T
⑦void PostOrderTraverse (BiTree T);
//后序遍历二叉树T
⑧void DestroyBiTree(BiTree &T)
//销毁二叉树T
2、选做：实现以下说明的操作函数，要求把函数添加到头文件binary_tree.h 中，并在主函数文件test10.cpp中添加相应语句进行测试。
①void LevelOrderTraverse(BiTree T);
//层序遍历二叉树T
②BiTNode *Parent(BiTree T, TElemType e)
//返回二叉树T中元素值为e的双亲结点的地址
3、填写实验报告，实验报告文件取名为report10.doc。
4、上传实验报告文件report10.doc、源程序文件test10.cpp及binary_tree.h。
三. 函数的功能说明及算法思路
（包括每个函数的功能说明，及一些重要函数的算法实现思路）
四. 实验结果与分析
（包括运行结果截图、结果分析等）
五. 心得体会
（记录实验感受、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。
）
【附录----源程序】。