实验三 二叉树操作的实现 代码及运行结果图
二叉查找树实现代码及运行结果
temp=SearchBST(T,keyword,NULL,p);//查找
if(!temp) printf("%d isn't existed!\n",keyword); //没有找到
else printf("%d has been found!\n",keyword); //成功找到
}
else return 0; //树中已存在关键字为e的数据元素
}
int DeleteBST(BiTree &T,int key)
{//若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点
//并返回1,否则返回0
int tmp1,tmp2;
tmp1=tmp2=0;
if(!T) return 0; //不存在关键字等于key的数据元素
//则指针p指向该数据元素，并返回1,否则指针指向查找路径上访问的最后一
//个结点并返回0,指针f指向T的双亲，其初始调用值为NULL
int tmp1,tmp2;
tmp1=tmp2=0;
if(!T) {p=f;return 0;} //查找不成功
else if(key==T->data) {p=T;return 1;} //查找成功
scanf("%d",&n);
printf("Please input every node:\n");
for(int i=0;i<n;i++)//输入树的结点个数
scanf("%d",&A[i]);
实验三--二叉树的基本运算
实验三二叉树的基本运算一、实验目的1、使学生熟练掌握二叉树的逻辑结构和存储结构。
2、熟练掌握二叉树的各种遍历算法。
二、实验内容1、问题描述建立一棵二叉树，试编程实现二叉树的如下基本操作：(1). 按先序序列构造一棵二叉链表表示的二叉树T；(2). 对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列；(3). 求二叉树的深度/结点数目/叶结点数目；(选做)(4). 将二叉树每个结点的左右子树交换位置。
（选做）2、基本要求从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立）。
3、测试数据如输入：abc00de0g00f000（其中ф表示空格字符）则输出结果为：先序：a->b->c->d->e->g->f中序：a->b->c->d->e->g->f后序：a->b->c->d->e->g->f三、程序代码#include<malloc.h>#include<iostream.h>#define OK 1#define ERROR -1typedef char TElemType;int i;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int CreateBiTree(BiTree&T) //创建二叉树{char a;cin>>a;if(a=='0') T=NULL;else{if(!(T=(BiTNode*)malloc(sizeof(BiTNode)))) {return ERROR;}T->data=a;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return OK;}int PreOrderTraverse(BiTree&T) //先序遍历二叉树{if(T){//cout<<"此为先序遍历"<<endl;cout<<T->data<<"->";if(PreOrderTraverse(T->lchild))if(PreOrderTraverse(T->rchild))return OK;return ERROR;}else return OK;}int InOrderTraverse(BiTree&T) //中序遍历二叉树{if(T){//cout<<"此为中序遍历"<<endl;if(InOrderTraverse(T->lchild)){cout<<T->data<<"->";if(InOrderTraverse(T->rchild))return OK;}return ERROR;}else return OK;}int PostOrderTraverse(BiTree&T) //后序遍历二叉树{if(T){//cout<<"此为后序遍历"<<endl;if (PostOrderTraverse(T->lchild))if(PostOrderTraverse(T->rchild)){cout<<T->data<<"->";i++;return (OK);}return (ERROR);}elsereturn (OK);}int CountDepth(BiTree&T) //计算二叉树的深度{if(T==NULL){return 0;}else{int depl=CountDepth(T->lchild);int depr=CountDepth(T->lchild);if(depl>depr){return depl+1;}else{return depr+1;}}}void main() //主函数{BiTree T;cout<<"请输入二叉树节点的值以创建树"<<endl;CreateBiTree(T);cout<<"此为先序遍历";PreOrderTraverse(T);cout<<"end"<<endl;cout<<"此为中序遍历";InOrderTraverse(T);cout<<"end"<<endl;cout<<"此为后序遍历";PostOrderTraverse(T);cout<<"end"<<endl<<"此树节点数是"<<i<<endl<<"此树深度是"<<CountDepth(T)<<endl;}四、调试结果及运行界面：五、实验心得通过这次程序上机实验让我认识到了以前还不太了解的二叉树的性质和作用，这次实验的的确确的加深了我对它的理解。
实验报告：二叉树
实验报告：二叉树第一篇：实验报告：二叉树实验报告二叉树一实验目的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 姓名：朱报龙成绩：_________实验七二叉树操作验证一、实验目的⑴ 掌握二叉树的逻辑结构；⑵ 掌握二叉树的二叉链表存储结构；⑶ 掌握基于二叉链表存储的二叉树的遍历操作的实现。
二叉排序树实现及结果截屏
二叉排序树实现及结果截屏一：需求分析基本要求以字符('\0')为输入结束标志,输入数列L，生成一棵二叉排序树T；对二叉排序树T作中序遍历，输出结果；输入元素x,查找二叉排序树T,若存在含x的结点,则删除该结点,并作中序遍历(执行操作2)；否则输出信息“没有该结点x”；数据类型要实现二叉排序数，必须先定义数据类型，本设计的输入数据为整型，输出的数据也为整型。
题目功能详细说明要生成一棵二叉排序数T，元素类型为ElemType在二叉排序树中查找其关键字等于给定值的结点是否存在在二叉排序树中插入一个新结点，中序遍历所建二叉排序树，将得到一个按关键字有序的元素序列二叉排序树的查找，可多次查找，并输出查找的结果4．最后对输出结构进行分析二．概要设计1.二叉树是另一种树型结构，他的特点是每个结点至多只有两棵子树，并且，二叉树的子树有左右之分，其次序不能任意颠倒。
2.二叉树的存储结构//-----------二叉树的顺序存储表示--------------#define MAX-TREE-SIZE 100 //二叉树的最大结点数Typedef TELem type sqbitree[MAX-TREE-SIZE];//0号单元存储根结点sqBiTree bt3.在不同的存储结构中,实现二叉树的操作方法也不同,如找结点X的双亲PARENT(T,E),在三叉链表中很容易实现,而在二叉链表中则需从根指针出发巡查.4.if(!t) {*p=f;return (0);} /*查找不成功*/else if(key==t->data) {*p=t;return (1);} /*查找成功*/else if(key<t->data)searchBST(t->lchild,key,t,p); /*在左子树中继续查找*/else searchBST(t->rchild,key,t,p); /*在右子树中继续查找*/5calculateASL(node *t,int *s,int *j,int i) /*计算平均查找长度*/{if(*t){i++; /*i记录当前结点的在当前树中的深度*/*s=*s+i; /*s记录已遍历过的点的深度之和*/if(calculateASL(&(*t)->lchild,s,j,i))/*计算左子树的ASL*/三.详细程序#include<stdio.h># include<stdlib.h>typedef struct Tnode{int data; /*输入的数据*/if(inorderTraverse(&(*t)->rchild)); /*中序遍历根的右子树*/}return(1) ;}calculateASL(node *t,int *s,int *j,int i) /*计算平均查找长度*/{if(*t){i++; /*i记录当前结点的在当前树中的深度*/*s=*s+i; /*s记录已遍历过的点的深度之和*/if(calculateASL(&(*t)->lchild,s,j,i))/*计算左子树的ASL*/{(*j)++; /*j记录树中结点的数目*/if(calculateASL(&(*t)->rchild,s,j,i)) /*计算右子树的ASL*/{i--; return(1);}}else return(1);}}node Delete(node t,int key) /*删除函数*/ {node p=t,q=NULL,s,f;while(p!=NULL) /*查找要删除的点*/{if(p->data==key) break;q=p;if(p->data>key) p=p->lchild;else p=p->rchild;}if(p==NULL) return t; /*查找失败*/if(p->lchild==NULL) /*p指向当前要删除的结点*/{if(q==NULL) t=p->rchild; /*q指向要删结点的父母*/else if(q->lchild==p) q->lchild=p->rchild; /*p为q的左孩子*/elseq->rchild=p->rchild;/*p为q的右孩子*/free(p);}else{ /*p的左孩子不为空*/f=p;s=p->lchild;while(s->rchild) /*左拐后向右走到底*/{f=s;s=s->rchild;}if(f==p) f->lchild=s->lchild; /*重接f的左子树*/else f->rchild=s->lchild; /*重接f 的右子树*/p->data=s->data;free (s);}return t;}int balanceBST(node t,int *i) /*判断是否为平衡二叉树的函数*/{int dep1,dep2;if(!t) return(0);else {dep1=balanceBST(t->lchild,i);dep2=balanceBST(t->rchild,i);}if((dep1-dep2)>1||(dep1-dep2)<-1)*i=dep1-dep2;/*用i值记录是否存在不平衡现象*/if(dep1>dep2) return(dep1+1);else return(dep2+1);}void main(){node T=NULL;int num;int s=0,j=0,i=0;int ch=0;node p=NULL;printf("请输入一组数据并以零结束:");do{scanf("%d",&num);if(!num) printf("完成输入\n");else insertBST(&T,num);}while(num);printf("\n\n---菜单---\n"); /*主程序菜单*/printf("\n 0: 退出" );printf("\n 1: 遍历二叉树");printf("\n 2: 二叉树的平均计算长度");printf("\n 3: 删除");printf("\n 4: 判断是否是平衡树");while(ch==ch){printf("\n 选择继续操作:");scanf("%d",&ch);switch(ch){case 0: exit(0); /*0－－退出*/case 1: printf(" 中序遍历结果是:\n ");inorderTraverse(&T); /*1－－中序遍历*/break;case 2: s=0;j=0;i=0;calculateASL(&T,&s,&j,i); /*2－－计算平均查找长度*/printf("ASL=%d/%d",s,j);break;case 3: printf(" 选择所要删除的结点:");scanf("%d",&num); /*3－－删除某个结点*/if(searchBST(T,num,NULL,&p)){T=Delete(T,num);printf(" 删除成功!\n ");inorderTraverse(&T);}else printf(" 没有该结点!",num);break;case 4: i=0;balanceBST(T,&i);/*判断是否为平衡二插树*/if(i==0) printf(" 是平衡树!");else printf(" 不是平衡树!");break;default: printf("输入错误，选择继续操作!\n");break; /*输入无效字符*/}}}四.结果输出调试分析：本次实习作业采用分层次的设计方法，程序之间调用关系较为单一简单，每个函数值实现一种功能，这种做法使思路清晰，调试较为简单；在写程序过程中，我也遇到了许多细节方面的问题，有的是因为遗忘，还有的是因为没有弄清楚概念，通过查阅书籍，这些问题都得到了较好的解决。
数据结构实验报告二叉树
数据结构实验报告二叉树《数据结构与算法》实验报告专业班级姓名学号实验项目实验三二叉树。
实验目的1、掌握用递归方法实现二叉树的遍历。
2、加深对二叉树的理解，逐步培养解决实际问题的编程能力。
题目：(1)编写二叉树的遍历操作函数。
①先序遍历，递归方法re_preOrder(TREE *tree)②中序遍历，递归方法re_midOrder(TREE *tree)③后序遍历，递归方法re_postOrder(TREE *tree)(2)调用上述函数实现先序、中序和后序遍历二叉树操作。
算法设计分析（一）数据结构的定义要求用c语言编写一个演示程序，首先建立一个二叉树，让用户输入一个二叉树，实现该二叉树的便利操作。
二叉树型存储结构定义为：typedef struct TNode{ char data;//字符型数据struct TNode *lchild,*rchild;//左右孩子指针}TNode,* Tree;（二）总体设计程序由主函数、二叉树建立函数、先序遍历函数、中序遍历函数、后序遍历函数五个函数组成。
其功能描述如下：（1）主函数：统筹调用各个函数以实现相应功能。
int main()（2）二叉树建立函数：根据用户意愿运用先序遍历建立一个二叉树。
int CreateBiTree(Tree &T)（3）先序遍历函数：将所建立的二叉树先序遍历输出。
void PreOrder(Tree T)（4）中序遍历函数：将所建立的二叉树中序遍历输出。
void InOrder(Tree T)（5）后序遍历函数：将所建立的二叉树后序遍历输出。
void PostOrder(Tree T)（三）各函数的详细设计：（1）建立一个二叉树，按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树。
对T动态分配存储空间，生成根节点，构造左、右子树（2）编写先序遍历函数，依次访问根节点、左子结点、右子节点（3）编写中序遍历函数，依次访问左子结点、根节点、右子节点（4）编写后序遍历函数，依次访问左子结点、右子节点、根节点（5）编写主函数，调用各个函数，以实现二叉树遍历的基本操作。
二叉树操作设计和实现实验报告
二叉树操作设计和实现实验报告一、目的：掌握二叉树的定义、性质及存储方式，各种遍历算法。
二、要求：采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作。
三、实验内容：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，即为叶子。
数据结构实验3：二叉树的操作
TextFile中。
(4) P：打印代码文件(Print)。
将文件CodeFile以紧凑格式显示在终端上，每行50个代码。
同时将此字符形式的编码文件写入文件CodePrin中。
(5) T：打印哈夫曼树(Tree printing)。
将已在内存中的哈夫曼树以直观的方式显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。
3) 实现提示：(1) 文件CodeFile的基类型可以设为字节型。
(2) 用户界面可以设计为“菜单”方式：显示上述功能符号，再加上“Q”，表示退出运行Quit。
请用户键入一个选择功能符。
此功能执行完毕后再显示此菜单，直至某次用户选择了“E”为止。
(3) 在程序的一次执行过程中，第一次执行I、D或C命令之后，哈夫曼树已经在内存了，不必再读入。
每次执行中不一定执行I命令，因为文件hfmTree可能早已建好。
三、实验过程与实验结果实验3-01：以二叉链表为存储结构，实现二叉树的创建、遍历数据结构定义：typedef struct BiTNode{char data;BiTNode *lchild, *rchild;}BiTNode;typedef BiTNode *BiTree;算法设计思路简介：本实验需要实现以下操作：二叉树的初始化、前中后序遍历等基本操作1.利用递归实现前后序遍历，思路简洁，仅需要调整递归体的执行顺序即可实现。
2.利用非递归实现中序遍历，需要利用栈操作，按照中序遍历规则将节点依次入栈后出栈实现。
算法描述：图1 中序遍历（非递归）实现算法的实现和测试结果（参考OJ）实验3-02：编写算法交换二叉树中所有结点的左、右子树数据结构定义：typedef struct BiTNode{char data;BiTNode *lchild, *rchild;}BiTNode;typedef BiTNode *BiTree;算法设计思路简介：本实验需要实现以下操作：二叉树的初始化、前中后序遍历等基本操作1.利用递归实现前后序遍历，思路简洁，仅需要调整递归体的执行顺序即可实现。
数据结构二叉树的基本操作代码
数据结构二叉树的基本操作代码x#include<iostream>using namespace std;//二叉树的结构struct TreeNode{int data;//节点的值TreeNode *left;//指向左子树TreeNode *right;//指向右子树};//插入节点void insert(TreeNode *&tree, int val){if(tree == NULL){tree = new TreeNode;tree->data = val;tree->left = tree->right = NULL;}else if(val<=tree->data)//小于根节点的值则插入到左子树 insert(tree->left, val);else if(val>tree->data)//大于根节点的值则插入到右子树 insert(tree->right,val);}//查找节点TreeNode* find(TreeNode *tree,int val){if (tree == NULL)//树为空，无法查找return NULL;else if (val == tree->data)//值和节点的值相等，返回该节点return tree;else if (val < tree->data)//值小于节点的值，查找左子树 return find(tree->left,val);else if (val > tree->data)//值大于节点的值，查找右子树 return find(tree->right,val);elsereturn NULL;//无法查找}//遍历二叉树//先序遍历void preOrder(TreeNode *tree){if(tree != NULL){cout<< tree->data <<'t'; //先访问根节点preOrder(tree->left); //再遍历左子树 preOrder(tree->right); //最后遍历右子树 }}//中序遍历void inOrder(TreeNode *tree){if(tree != NULL){inOrder(tree->left); //先遍历左子树 cout<< tree->data <<'t'; //再访问根节点inOrder(tree->right); //最后遍历右子树 }}//后序遍历void postOrder(TreeNode *tree){if(tree != NULL){postOrder(tree->left); //先遍历左子树 postOrder(tree->right); //再遍历右子树 cout<< tree->data <<'t'; //最后访问根节点 }}//查找最大值TreeNode* findMax(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->right == NULL)return tree;elsereturn findMax(tree->right);}//查找最小值TreeNode* findMin(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->left == NULL)return tree;elsereturn findMin(tree->left);}//删除节点void remove(TreeNode *&tree, int val){if(tree == NULL)return;else if(val < tree->data)remove(tree->left, val);else if(val > tree->data)remove(tree->right, val);else//找到要删除的节点{if(tree->left != NULL && tree->right != NULL)//左右子树均不为空{TreeNode *temp = tree;TreeNode *max = findMax(tree->left);//查找左子树的最大结点tree->data = max->data;//将最大结点的值替换到要删除的节点remove(temp->left, max->data);//将最大结点删掉}else//只有一边的子节点不为空或者左右节点都为空{TreeNode *temp = tree;if(tree->left == NULL)//如果左节点为空，就将右节点提升 tree = tree->right;else if(tree->right == NULL)//如果右节点为空，就将左节点提升tree = tree->left;delete temp;//删掉要删除的节点}}}int main(){TreeNode *tree = NULL; //声明一个空树int arr[10] = {12, 3, 4, 6, 7, 9, 10, 5, 2, 8};for(int i=0; i<10; i++){insert(tree, arr[i]);//把数组元素插入到树当中}cout<<'先序遍历：';preOrder(tree);cout<<endl;cout<<'中序遍历：';inOrder(tree);cout<<endl;cout<<'后序遍历：';postOrder(tree);cout<<endl;cout<<'查找节点数据：4';TreeNode *findNode = find(tree, 4);if(findNode != NULL)//如果节点存在cout<<'找到了，节点的值是：'<<findNode->data;else//如果节点不存在cout<<'没有找到';cout<<endl;cout<<'查找树的最大值：'<<findMax(tree)->data<<endl; cout<<'查找树的最小值：'<<findMin(tree)->data<<endl; cout<<'删除节点：。
实验三 二叉树基本运算以及遍历
实验三二叉树基本运算以及遍历一实验目的：了解树的逻辑和存储特点，掌握二叉树的建立，以及前中后序遍历的理论思想和运算方法。
二实验内容：建立一棵二叉树，添加树中结点的元素，对该二叉树进行前、中、后序遍历，并打印遍历结果三实验原理：二叉树（Binary Tree）是个有限元素的集合，该集合或者为空、或者由一个称为根(root)的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。
当集合为空时，称该二叉树为空二叉树。
在二叉树中，一个元素也称作一个结点。
二叉树是有序的，即若将其左、右子树颠倒，就成为另一棵不同的二叉树。
即使树中结点只有一棵子树，也要区分它是左子树还是右子树。
即用链来指示着元素的与rchild分别存放指向左孩子和右孩子的指针，当左孩子或右孩子不存在时，相应指针域值为空。
二叉树的建立：1 建立根结点。
2 若左子树不空则建左子树。
3 若右子树不空则建右子树。
二叉树的前序遍历1 访问根结点；2 先序遍历根结点的左子树；3 先序遍历根结点的右子树。
二叉树的中序遍历1 中序遍历根结点的左子树；2 访问根结点；3 中序遍历根结点的右子树。
二叉树的后序遍历1后序遍历根结点的左子树；2后序遍历根结点的右子树。
3访问根结点；四实验步骤1 进入Turbo C2.0，新建一个文件。
2 输入程序，程序要求使用子函数进行组织。
3 将源程序保存到指定文件夹“D:\学生姓名”。
4 按F9调试，纠正语法错误。
5按Ctrl＋F9运行，调试逻辑错误。
6 按Alt＋F5查看结果。
五、实验中应注意的问题与思考题：1 如果需要对树中的数据进行查询修改，应该如何实现？先找到需要修改的数据的位置，再让对其赋值。
2对各个功能模块采用独立编制子函数，增强程序的可执行性、可移植性和可读性。
增加情报信息量，对实际应用中可能发生的情况考虑周全，对非法情形要提出适当的处理方案。
3 深入了解树的逻辑结构，重点掌握递归方法的原理和实现，在确定递归终点条件的时候应特别小心，避免产生死循环。
数据结构实验三——二叉树基本操作及运算实验报告
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述：实现二叉树（包括二叉排序树）的建立，并实现先序、中序、后序和按层次遍历，计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为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．学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。
4.会用二叉树解决简单的实际问题。
二、实验内容设计程序实现二叉树结点的类型定义和对二叉树的基本操作。
该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。
1 按先序次序建立一个二叉树，2按（A:先序 B:中序 C:后序）遍历输出二叉树的所有结点以上比做，以下选做3求二叉树中所有结点数4求二叉树的深度三、实验步骤㈠、数据结构与核心算法的设计描述/* 定义DataType为char类型 */typedef char DataType;/* 二叉树的结点类型 */typedef struct BitNode{ DataType data;struct BitNode *lchild,*rchild;}*BitTree;相关函数声明：1、/* 初始化二叉树，即把树根指针置空 */void BinTreeInit(BitTree *BT){BT=(BitTree)malloc(sizeof(BitNode));BT->data=NULL;cout<<"二叉树初始化成功!"<<endl;}2、/* 按先序次序建立一个二叉树*/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;}3、/* 检查二叉树是否为空 */void BinTreeEmpty(BitTree &BT){if(BT->data==NULL)cout<<"是空二叉树!"<<endl;elsecout<<"不是空二叉树!"<<endl;}4、/*按任一种遍历次序（包括按先序、中序、后序、按层次）输出二叉树中的所有结点 */void BinTraverse(BitTree &BT)//按先序序列建立二叉树{if(BT!=NULL){cout<<BT->data;BinTraverse(BT->lchild);BinTraverse(BT->rchild);}}5、/* 求二叉树的深度 */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;}6、/* 求二叉树中所有结点数 */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;}㈡、函数调用及主函数设计㈢程序调试及运行结果分析测试数据： 1、初始化二叉树； 2、按先序序列建立二叉树；3、判断二叉树是否为空；4、先序序列遍历二叉树；5、求二叉树的深度；6、求二叉树节点的个数。
数据结构之二叉树编程实验报告
实验报告：二叉树题目：建立一棵二叉树，数据以字符串形式从键盘输入，在此二叉树上完成：（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;}。
二叉树的基本操作实验
图（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为总节点。
二叉树实验代码
实验目的：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##输出：说明：输入中的#号是分支结束的标志。
关于实现二叉树,平衡树的代码及每一行代码的解释
关于实现二叉树,平衡树的代码及每一行代码的解释以下为python实现二叉树的代码，每一行代码的解释已在注释中说明：# 定义二叉树的节点class BinaryTree:def __init__(self, value):# 节点的值self.value = value# 左子树self.leftchild = None# 右子树self.rightchild = None# 添加左子树节点def add_leftchild(self, node):self.leftchild = node# 添加右子树节点def add_rightchild(self, node):self.rightchild = node# 创建二叉树root = BinaryTree(1)node2 = BinaryTree(2)node3 = BinaryTree(3)node4 = BinaryTree(4)node5 = BinaryTree(5)root.add_leftchild(node2)root.add_rightchild(node3)node2.add_leftchild(node4)node2.add_rightchild(node5)以下为python实现平衡树的代码（基于AVL树），每一行代码的解释已在注释中说明：# 定义AVL树节点class AVLNode:def __init__(self, value):# 节点值self.value = value# 左子树self.leftchild = None# 右子树self.rightchild = None# 高度self.height = 1# 定义AVL树class AVLTree:def __init__(self):# 根节点self.root = None# 获取树高def get_height(self, root):if root is None:return 0else:return root.height# 获取平衡因子def get_balance_factor(self, root): if root is None:return 0else:return self.get_height(root.leftchild) -self.get_height(root.rightchild)# 右旋转def right_rotate(self, root):lefttree = root.leftchildrighttree = lefttree.rightchild# 右旋转lefttree.rightchild = rootroot.leftchild = righttree# 更新节点高度root.height = 1 + max(self.get_height(root.leftchild), self.get_height(root.rightchild))lefttree.height = 1 + max(self.get_height(lefttree.leftchild), self.get_height(lefttree.rightchild))# 返回新的根节点return lefttree# 左旋转def left_rotate(self, root):righttree = root.rightchildlefttree = righttree.leftchild# 左旋转righttree.leftchild = rootroot.rightchild = lefttree# 更新节点高度root.height = 1 + max(self.get_height(root.leftchild),self.get_height(root.rightchild))righttree.height = 1 + max(self.get_height(righttree.leftchild), self.get_height(righttree.rightchild))# 返回新的根节点return righttree# 插入节点def insert_node(self, root, value):# 如果树为空，则插入新节点if root is None:return AVLNode(value)# 如果插入的值小于根节点，则插入到左子树中if value < root.value:root.leftchild = self.insert_node(root.leftchild, value) # 如果插入的值大于根节点，则插入到右子树中else:root.rightchild = self.insert_node(root.rightchild, value)# 更新节点高度root.height = 1 + max(self.get_height(root.leftchild), self.get_height(root.rightchild))# 获取平衡因子balance_factor = self.get_balance_factor(root)# 平衡树# 左左情况if balance_factor > 1 and value < root.leftchild.value:return self.right_rotate(root)# 左右情况if balance_factor > 1 and value > root.leftchild.value:root.leftchild = self.left_rotate(root.leftchild)return self.right_rotate(root)# 右右情况if balance_factor < -1 and value > root.rightchild.value: return self.left_rotate(root)# 右左情况if balance_factor < -1 and value < root.rightchild.value: root.rightchild = self.right_rotate(root.rightchild)return self.left_rotate(root)return root# 中序遍历def in_order(self, root):res = []if root is not None:res = self.in_order(root.leftchild)res.append(root.value)res = res + self.in_order(root.rightchild)return res# 创建AVL树avl_tree = AVLTree()# 插入节点root = Noneroot = avl_tree.insert_node(root, 10) root = avl_tree.insert_node(root, 20) root = avl_tree.insert_node(root, 30) root = avl_tree.insert_node(root, 40) root = avl_tree.insert_node(root, 50) root = avl_tree.insert_node(root, 25)# 中序遍历print(avl_tree.in_order(root))。
二叉树的基本操作实验代码
二叉树的基本操作实验代码二叉树的基本操作实验代码介绍二叉树是一种非常常见的数据结构，它具有以下特点：1. 每个节点最多有两个子节点；2. 左子节点比父节点小，右子节点比父节点大；3. 左右子树也是二叉树。
在本篇文章中，我们将介绍二叉树的基本操作，并提供相应的实验代码。
创建二叉树创建一个二叉树需要两个步骤：首先创建一个空的根节点，然后逐个添加子节点。
下面是创建一个简单的二叉树的示例代码：```c++#include <iostream>using namespace std;struct TreeNode {int val;TreeNode *left;TreeNode *right;TreeNode(int x) : val(x), left(NULL), right(NULL) {} };TreeNode* createTree() {TreeNode* root = new TreeNode(1);root->left = new TreeNode(2);root->right = new TreeNode(3);root->left->left = new TreeNode(4);root->left->right = new TreeNode(5);return root;}int main() {TreeNode* root = createTree();}```遍历二叉树遍历二叉树有三种方式：前序遍历、中序遍历和后序遍历。
下面是三种遍历方式的示例代码：前序遍历：```c++void preorderTraversal(TreeNode* root) {if (!root) return;cout << root->val << " ";preorderTraversal(root->left);preorderTraversal(root->right);}```中序遍历：```c++void inorderTraversal(TreeNode* root) {if (!root) return;inorderTraversal(root->left);cout << root->val << " ";inorderTraversal(root->right);}```后序遍历：```c++void postorderTraversal(TreeNode* root) {if (!root) return;postorderTraversal(root->left);postorderTraversal(root->right);cout << root->val << " ";}```查找二叉树查找二叉树需要递归地遍历每个节点，直到找到目标节点。
完全二叉树操作演示
安徽省巢湖学院计算机与信息工程学院课程设计报告课程名称《数据结构》课题名称完全二叉树操作演示专业班级计算机科学与技术专升本1班学号********、********、********姓名李鹏王帅李泳波联系方式指导教师严小燕完成日期: 2014年12月27 日目录1 数据结构课程设计任务书 (1)1.1题目 (1)1.2目的 (1)1.3要求 (1)2 总体设计 (1)2.1功能模块设计 (1)2.2所有功能模块流程图 (1)3 详细设计 (2)3.1程序中所采用的数据结构及存储结构的说明 (2)3.2算法设计思想 (3)3.3主要的功能函数 (3)4 调试与测试 (3)4.1调试方法与步骤 (4)4.2测试结果分析与讨论 (4)4.3测试过程中遇到的主要问题及采取的解决措施 (5)5 时间复杂度分析 (6)6 程序清单 (6)7 总结 (12)参考文献 (13)1 数据结构课程设计任务书1.1题目完全二叉树操作演示1.2目的（1）掌握二叉树的概念和性质。
（2）掌握完全二叉树存储结构。
（3）掌握完全二叉树的基本操作。
1.3 要求（1）创建完全二叉树（用字母表示节点）(用顺序方式存储)。
（2）求二叉树的深度和叶子结点数。
（3）实现二叉树的前序、中序、后序和层次遍历。
（4）查找给定结点的双亲、祖先和左右孩子节点。
2 总体设计2.1 功能模块设计根据课程设计题目的功能要求，各个功能模块的组成框图如图1：图 1 功能组成框图2.2 所有功能模块流程图设计好功能模块后，各个模块的关系如下图2：图 2 流程图3 详细设计3.1程序中所采用的数据结构及存储结构的说明（1）整个程序采用结构体与顺序表相结合的编程方法一共完成了7个功能。
在你输入错误时有报错消息，这样使整个程序运行起来更加完整。
程序中有若干个子函数被主函数调用执行。
结构体定义如下：#define MAX 100 //定义100个节点typedef struct{char dat; //节点信息}node;typedef struct Tree //节点组成树{int length;node *r; //指向根节点}Tree;3.2 算法设计思想完全二叉树具有以下几个性质，由此可设计出相应算法。
二叉树的完整代码实现
⼆叉树的完整代码实现1 #include<stdio.h>2 #include<stdlib.h>3 #include<malloc.h>45 typedef struct Node//结构体6 {7char data;8struct Node *LChild;9struct Node *RChild;10 } BinNode,*BinTree;1112 BinTree CreateTree(BinTree T)13 {14char ch;15 scanf("%c",&ch);16if(ch=='#')17return NULL;18else19 {20 T=(BinTree)malloc(sizeof(BinNode));21 T->data=ch;22 T->LChild=CreateTree(T->LChild);/*创建左⼦树*/23 T->RChild=CreateTree(T->RChild);/*创建右⼦树*/24return T;25 }26 }2728void PreOrder(BinTree root)//先序遍历29 {30if (root != NULL)31 {32 printf("%c", root->data);33 PreOrder(root->LChild);34 PreOrder(root->RChild);35 }36 }3738void InOrder(BinTree root)//中序遍历39 {40if (root != NULL)41 {42 InOrder(root->LChild);43 printf("%c", root->data);44 InOrder(root->RChild);45 }46 }4748void PostOrder(BinTree root)//后序遍历49 {50if (root != NULL)51 {52 PostOrder(root->LChild);53 PostOrder(root->RChild);54 printf("%c", root->data);55 }56 }57/*求⼆叉树结点总数*/58int Count(BinTree T)59 {60if(T==NULL)61return0; /*空⼆叉树结点数为0*/62else/*左右⼦树结点总数加1*/63return Count(T->LChild)+Count(T->RChild)+1;64 }65//叶⼦数66int LeafCount(BinTree T){67if(T == NULL){68return0;69 }70else if ((T->LChild==NULL) && (T->RChild==NULL)){71return1;72 }73else{74return LeafCount(T->LChild)+LeafCount(T->RChild);75 }76 }77int main()78 {7980 BinTree bt;81 printf("⼀、请按先序的⽅式输⼊⼆叉树的结点元素（注：输⼊#表⽰节点为空）如:ABC##DE#G##F###\n");82 bt=CreateTree(bt);83 printf("⼆、前序遍历⼆叉树：\n");84 PreOrder(bt);85 printf("\n");86 printf("三、中序遍历⼆叉树：\n");87 InOrder(bt);88 printf("\n");89 printf("四、后序遍历⼆叉树：\n");90 PostOrder(bt);91 printf("\n");92 printf("五、⼆叉树结点数: %d\n",Count(bt));93 printf("六、叶⼦节点的个数：%d \n",LeafCount(bt));94 system("pause");95 }。
数据结构二叉树实验报告(附代码)
一、【实验构思（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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
InOrderTraverse(T,visit); //中序递归遍历二叉树T
printf("\n后序递归遍历二叉树：\n");
PostOrderTraverse(T,visit); //后序递归遍历二叉树T
printf("\n叶子结点总数为：\n");
Visit(T->data); //最后访问根结点
}
}பைடு நூலகம்
int LeafNum( BiTree T){
if(!T)
return 0;
else
if(!T->lchild&&!T->rchild)
return 1;
else
// printf("nihao");
return LeafNum(T->lchild)+LeafNum(T->rchild);
}
void main()
{
BiTree T;
int num;
//InitBiTree(T); //初始化二叉树T
printf("按先序次序输入二叉树中结点的值,输入0表示节点为空\n");
CreateBiTree(T); //建立二叉树T
printf("先序递归遍历二叉树：\n");
PreOrderTraverse(T ,visit); //先序递归遍历二叉树T
if(!T)
exit(-2);
T->data=number; //将值赋给T所指结点
CreateBiTree(T->lchild); //C递归构造左子树
CreateBiTree(T->rchild); //递归构造右子树
}
}
void DestroyBiTree(BiTree &T)
{
if(T) //非空树
{ DestroyBiTree(T->lchild);
DestroyBiTree(T->rchild);
free(T);
}
}
void PreOrderTraverse(BiTree T,void (*Visit)(int)){
if(T)
{ Visit(T->data);
PreOrderTraverse(T->lchild,Visit); //再先序遍历左子树
二叉树操作的实现
#include<malloc.h>
#include<stdio.h>
#include<stdlib.h>
typedef struct BiTNode
{
int data;
BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
int Nil=0; //设整型以0为空
void visit(int e)
{
printf("%d ",e);
}
void CreateBiTree(BiTree &T)
{
int number;
scanf("%d",&number);
if(number==Nil)
T=NULL;
else //结点的值不为空
{ T=(BiTree)malloc(sizeof(BiTNode)); //生成根结点
num= LeafNum (T);
printf("%d \n",num);
}
PreOrderTraverse(T->rchild,Visit); //最后先序遍历右子树
}
}
void InOrderTraverse(BiTree T,void(*Visit)(int))
{
if(T)
{ InOrderTraverse(T->lchild,Visit); //先中序遍历左子树
Visit(T->data); //再访问根结点
InOrderTraverse(T->rchild,Visit); //最后中序遍历右子树
}
}
void PostOrderTraverse(BiTree T,void(*Visit)(int))
{
if(T) // T不空
{ PostOrderTraverse(T->lchild,Visit);
PostOrderTraverse(T->rchild,Visit);