大数据结构实验7：二叉树子系统
实验报告二叉树
递归遍历右子树输出根结点数data}void postOrder1 (struct btnode *bt){概念栈，结点参数p,prebt入栈While(栈或p是不是为空){提取栈顶元素值if判定p是不是为空或是pre的根结点输出根结点数data栈顶元素出栈栈顶元素p赋给pre记录else if右结点非空将右结点压栈if左结点将左结点压栈}}void main(){struct btnode *root=NULL;root=createbt(root);preOrder(root); midOrder(root); postOrder(root);preOrder1(root); midOrder1(root)； postOrder1(root);
数据结构二叉树实验报告
一 、实验目的和要求(1)掌握树的相关概念，包括树、节点的度、树的度、分支节点、叶子节点、孩子节点、双亲节 点、树的深度、森林等定义。
(2)掌握树的表示，包括树形表示法、文氏图表示法、凹入表示法和括号表示法等。
(3)掌握二叉树的概念，包括二叉树、满二叉树和完全二叉树的定义。
(4)掌握二叉树的性质。
(5)重点掌握二叉树的存储结构，包括二叉树顺序存储结构和链式存储结构。
(6)重点掌握二叉树的基本运算和各种遍历算法的实现。
(7)掌握线索二叉树的概念和相关算法的实现。
(8)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码的产生方法。
(9)掌握并查集的相关概念和算法。
(10)灵活运用二叉树这种数据结构解决一些综合应用问题。
二、实验内容注：二叉树b 为如图7-123所示的一棵二叉树图7-123+实验7.1 编写一个程序algo7-1.cpp,实现二叉树的各种运算，并在此基础上设计一个程序exp7-1.cpp 完成如下功能：(1)输出二叉树b ;(2)输出H 节点的左、右孩子节点值； (3)输出二叉树b 的深度； (4)输出二叉树b 的宽度； (5)输出二叉树b 的节点个数；(6)输出二叉树b 的叶子节点个数。
实验7.2设计一个程序exp7-2.cpp,实现二叉树的先序遍历、中序遍历和后序遍历和非递归算法， 以及层次变量里的算法。
并对图7-123所示的二叉树b 给出求解结果。
b+ACF GIKL+NM+E+HdJD₄B臣1607-1.CPPif(b?-HULL)re3P4+;Qu[rear]-p-b;Qu[rear].1no=1;while(reart=front){Front++;b=Qu[front]-P;lnum-Qu[front].1no;if(b->Ichildt=NULL)rpar+t;Qu[rear]-p=b->1child;Qu[rear].Ino-lnun+1;if(D->rch11d?=NULL)1/根结点指针入队//根结点的层次编号为1 1/队列不为空1/队头出队1/左孩子入队1/右孩子入队redr+t;qu[rear]-p=b->rchild;Qu[rear].1no-lnun*1;}}nax-0;lnun-1;i-1;uhile(i<=rear){n=0;whdle(i<=rear ge Qu[1].1no==1num)n+t;it+;Inun-Qu[i].1n0;if(n>max)nax=n;}return max;田1607-1.CPPreturn max;}elsereturn o;口×int Modes(BTNode *D) //求二叉树D的结点个数int nun1,nun2;if(b==NULL)returng,else if(b->ichild==NULL&D->rchild==NULL)return 1;else{num1-Hodes(b->Ichild);num2=Nodes(b->rchild);return(num1+nun2+1);LeafNodes(BINode *D) //求二叉树p的叶子结点个数int num1,num2;1f(D==NULL)return 0;else if(b->1chi1d==NULLc& b->rch11d==NULL)return 1;else{num1-LeafModes(b->lchild);num2=LeafNodes(b->rchild);return(nun1+nun2);int程序执行结果如下：xCProrn FlslirosfViu l SudiollyPrjecslro7 LJebuglFoj7 ex<1)输出二叉树：A<B<D,E<H<J,K<L,M<,N>>>>),C<F,G<,I>>)<2)'H’结点：左孩子为J石孩子为K(3)二叉树b的深度：7<4)二叉树b的宽度：4(5)二叉树b的结点个数：14(6)二叉树b的叶子结点个数：6<?>释放二叉树bPress any key to continue实验7 . 2程序exp7-2.cpp设计如下：坠eTPT-2.EPP#include<stdio.h》winclude<malloc.h>deFn Masie 00typde chr ElemTyetypede sruct nde{ElemType data;stuc node *lclldstruct node rchild;》BTHode;extern vod reaeBNodeBTNode extrn void DispBTHode(BTNodeuoid ProrderBTNode *b)if(b?-NULL)- 回1 / 数据元素1 / 指向左孩子1 / 指向右孩子*eb car *str)xb1 / 先序遍历的递归算法1 / 访问根结点/ / 递归访问左子树1 7 递归访问右子树/ / 根结点入栈//栈不为空时循环/ / 退栈并访问该结点/ / 右孩子入栈{》v oidprintf(*c“,b->data); Preorder(b->lchild); Pre0rder(b->rchild);Preorder1(BTNode *b)BTNode xSt[Maxsize],*p;int top=-1;if(b!-HULL)top++;St[top]-b;uhle (op>-)p-St[top];top--;printf("%c“,p->data);if(p->rchild?-HULL)A约e程p7-2.CPPprintF(”后序逅历序列：\n");printf(" 递归算法=");Postorder(b);printf("\n");printf(“非递归算法：“);Postorder1(b);printf("\n");序执行结果如下：xCAPrograFleicsoftVisal SudlyrjecsProj 2Debuzlroj72ex"二叉树b:A(B(D,ECH<J,K(L,M<,N)>))),C(F,GC.I>))层次遍历序列：A B C D E F G H I J K L M N先序遍历序列：递归算法：A B D E H J K L M N C F G I非归算法：A B D E H J K L M N C F G I中序遍历序列：递归算法： D B J H L K M N E A F C G I非递归算法：D B J H L K M N E A F C G I后序遍历序列：递归算法： D J L N M K H E B F I G C A非递归算法：D J L N H K H E B F I G C APress any key to continue臼p7-3.CPP15Pp a t h[p a t h l e n]-b->d a t a;//将当前结点放入路径中p a t h l e n t+;/7路任长度培1Al1Path1(b->ichild,patn,pathlen);1/递归扫描左子树Al1Path1(b->rchild,path,pathlen); //递归扫描右子树pathlen-- ; //恢复环境uoid Longpath(BTNode *b,Elemtype path[1,int pathlen,Elemtype longpath[],int elongpatnien) int i;1f(b==NULL){if(pathlen>longpatnlen) //若当前路径更长，将路径保存在1ongpatn中for(i-pathlen-1;i>-8;i--)longpath[i]=path[1];longpathlen-pathlen;elsepath[pathlen]=b->data; pathlen4; //将当前结点放入路径中//路径长度增1iongPath(b->lchild,path₇pathlen,langpath,longpathien);//递归扫描左子树LongPath(b->rchiid,path,pathien,longpath,longpathien);//递归扫描石子树pathlen--; /7饮其环境oid DispLeaf(BTNode xb)- 口凶uoid DispLeaf(BTNode xb)iE(D!=NULL){ if(b->1child--HULL B& b->rchild--HULL)printf("3c“,b->data);elsepispLeaf(b->ichild);DispLeaf(b->rchild);oid nain()8TNodexb;ElenType patn[Maxsize],longpath[Maxsize];int i.longpathien-U;CreateBTNode(b,"A(B(D,E(H(J,K(L,H(,N))))),C(F,G(,I)))");printf("\n二灾树b:");DispBTNode(b);printf("\n\n*);printf(”b的叶子结点：");DispLeaf(b);printf("\n\n");printf("A11Path:");A11Path(b);printf("m");printf("AiiPath1:n");AliPath1(b.path.);printf("");LongPath(b,path,8,longpath,longpathlen);printf(”第一条量长路径长度=d\n”,longpathlen);printf(”"第一茶最长路径：");for(i=longpathlen;i>=0;i--)printf("c",longpatn[1]);printf("\n\n");。
数据结构实验报告 二叉树
数据结构实验报告二叉树数据结构实验报告：二叉树引言：数据结构是计算机科学中的重要基础，它为我们提供了存储和组织数据的方式。
二叉树作为一种常见的数据结构，广泛应用于各个领域。
本次实验旨在通过实践，深入理解二叉树的概念、性质和操作。
一、二叉树的定义与性质1.1 定义二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树可以为空树，也可以是由根节点和左右子树组成的非空树。
1.2 基本性质（1）每个节点最多有两个子节点；（2）左子树和右子树是有顺序的，不能颠倒；（3）二叉树的子树仍然是二叉树。
二、二叉树的遍历2.1 前序遍历前序遍历是指首先访问根节点，然后按照先左后右的顺序遍历左右子树。
在实际应用中，前序遍历常用于复制一颗二叉树或创建二叉树的副本。
2.2 中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。
中序遍历的结果是一个有序序列，因此在二叉搜索树中特别有用。
2.3 后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。
后序遍历常用于计算二叉树的表达式或释放二叉树的内存。
三、二叉树的实现与应用3.1 二叉树的存储结构二叉树的存储可以使用链式存储或顺序存储。
链式存储使用节点指针连接各个节点，而顺序存储则使用数组来表示二叉树。
3.2 二叉树的应用（1）二叉搜索树：二叉搜索树是一种特殊的二叉树，它的左子树上的节点都小于根节点，右子树上的节点都大于根节点。
二叉搜索树常用于实现查找、插入和删除等操作。
（2）堆：堆是一种特殊的二叉树，它满足堆序性质。
堆常用于实现优先队列，如操作系统中的进程调度。
（3）哈夫曼树：哈夫曼树是一种带权路径最短的二叉树，常用于数据压缩和编码。
四、实验结果与总结通过本次实验，我成功实现了二叉树的基本操作，包括创建二叉树、遍历二叉树和查找节点等。
在实践中，我进一步理解了二叉树的定义、性质和应用。
二叉树作为一种重要的数据结构，在计算机科学中有着广泛的应用，对于提高算法效率和解决实际问题具有重要意义。
数据结构：二叉树子系统学习资料
数据结构：二叉树子系统*题目：按屏幕提示用前序方法建立一棵二叉树，并能按凹入法显示二叉树结构。
* 编写前序遍历、中序遍历、后序遍历、层次遍历程序。
* 编写求二叉树的叶结点数、总结点数和深度的程序。
* 设计一个选择式菜单，以菜单方式选择下列操作。
* 二叉树子系统* ******************************** * 1------建二叉树 ** * 2------凹入显示 ** * 3------先序遍历 ** * 4------中序遍历 ** * 5------后序遍历 ** * 6------层次遍历 ** * 7------求叶子数 ** * 8------求结点数 ** * 9------求树深度 ** * 0------返回 ** ******************************** 请选择菜单号（0--9）*/#include <stdio.h>#include <stdlib.h>typedef struct bTree //二叉树结点char data; //值域struct bTree *lchild; //左孩子struct bTree *rchild; //右孩子}BT;BT *createTree();void showTree(BT *t);void preOrder(BT *t);void postOrder(BT *t);void inOrder(BT *t);void levelOrder(BT *t);int leafNum(BT *t);int nodeNum(BT *t);int treeDepth(BT *t);/************************************************* Function: main()Description: 主调函数Calls: createTree()showTree()preOrder()postOrder()inOrder()leafNum()levelOrder()nodeNum()treeDepth()Input: NULLReturn: voidOthers: NULL*************************************************/ void main(){BT *t = NULL;int choice, k = 1;while (k){printf("\n 二叉树子系统\n");printf("*******************************\n");printf("* 1------建二叉树 *\n");printf("* 2------凹入显示 *\n");printf("* 3------先序遍历 *\n");printf("* 4------中序遍历 *\n");printf("* 5------后序遍历 *\n");printf("* 6------层次遍历 *\n");printf("* 7------求叶子数 *\n");printf("* 8------求结点数 *\n");printf("* 9------求树深度 *\n");printf("* 0------返回 *\n");printf("*******************************\n");printf("请选择菜单号（0--9）：");fflush(stdin);scanf("%d", &choice);switch(choice){case 1:printf("请输入根结点（'0'表示该结点为空）："); t = createTree();printf("二叉树建立成功。
数据结构实验报告二叉树
数据结构实验报告二叉树《数据结构与算法》实验报告专业班级姓名学号实验项目实验三二叉树。
实验目的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.二叉树的遍历基本思想：二叉树是由三个基本单元组成：根节点、左子树和右子树。
因此若能依次遍历这三部分，便是遍历了整棵二叉树。
可采用递归调用来实现。
（1）先序遍历若二叉树为空，则空操作；否则访问根节点；先序遍历左子树；先序遍历右子树。
（2）中序遍历若二叉树为空，则空操作；否则中序遍历左子树；访问根节点；中序遍历右子树。
（3）后序遍历若二叉树为空，则空操作；否则后序遍历左子树；后序遍历右子树；访问根节点。
（4）层次遍历若节点不为空，则访问该节点，并将其入列；接着从队列中取已被访问的，但其左右孩子尚未被访问的；访问该节点的左孩子，将其入列；访问该节点的右孩子，将其入列。
2.二叉树的建立基本思想：对二叉树遍历基本操作已经建立的基础上，在遍历过程中生成节点，建立二叉树存储结构，采用先序遍历建立二叉树链表：（1）按先序序列输入二叉树中节点的元素，以空格表示空，直到输入回车为止；（2）若元素值为空，则赋值NULL；否则生成一个新的节点，将元素值赋值给该根节点的数值域；（3）建立该根节点的左子树；（4）建立根节点的右子树。
BiTree CreateBiTree(BiTree T){//构造二叉树T，按先序序列输入二叉树中节点的值，空格表示空树char ch;if((ch=getchar())==’‘)T=NULL;elseif(ch!=’\n’){if(!(T=(BiTree)malloc(sizeof(BiTNode))))exit(1);T->data=ch;//生成根节点T->lchild=CreateBiTree(T->lchild);//构造左子树T->rchild=CreateBiTree(T->rchild);//构造右子树}return T；}3.二叉树的叶子数基本思想：（1）若该节点无孩子，则表示为叶子，计数器加一；（2）若该节点右孩子，求其左子树的叶子；（3）再求其右子树的叶子4.二叉树的高度基本思想：首先分析二叉树的深度（高度）和它的左、右子树深度之间的关系。
[精品]【数据结构】二叉树实验报告
![[精品]【数据结构】二叉树实验报告](https://img.taocdn.com/s3/m/5d561ae96e1aff00bed5b9f3f90f76c661374c27.png)
[精品]【数据结构】二叉树实验报告二叉树实验报告一、实验目的：1.掌握二叉树的基本操作；2.理解二叉树的性质；3.熟悉二叉树的广度优先遍历和深度优先遍历算法。
二、实验原理：1.二叉树是一种树形结构，由n(n>=0)个节点组成；2.每个节点最多有两个子节点，称为左子节点和右子节点；3.二叉树的遍历分为四种方式：前序遍历、中序遍历、后序遍历和层次遍历。
三、实验环境：1.编程语言：C++；2.编译器：Dev-C++。
四、实验内容：1.定义二叉树节点结构体：struct BinaryTreeNode{int data; // 节点数据BinaryTreeNode *leftChild; // 左子节点指针BinaryTreeNode *rightChild; // 右子节点指针};2.初始化二叉树：queue<BinaryTreeNode *> q; // 使用队列存储节点q.push(root);int i = 1; // 创建子节点while (!q.empty() && i < length){BinaryTreeNode *node = q.front();q.pop();if (data[i] != -1) // 创建左子节点 {BinaryTreeNode *leftChild = new BinaryTreeNode;leftChild->data = data[i];leftChild->leftChild = nullptr;leftChild->rightChild = nullptr;node->leftChild = leftChild;q.push(leftChild);}i++;if (data[i] != -1) // 创建右子节点 {BinaryTreeNode *rightChild = new BinaryTreeNode;rightChild->data = data[i];rightChild->leftChild = nullptr;rightChild->rightChild = nullptr;node->rightChild = rightChild;q.push(rightChild);}i++;}return root;}3.前序遍历二叉树：五、实验结果：输入：int data[] = {1, 2, 3, 4, -1, -1, 5, 6, -1, -1, 7, 8};输出：前序遍历结果：1 2 4 5 3 6 7 8中序遍历结果：4 2 5 1 6 3 7 8后序遍历结果：4 5 2 6 8 7 3 1层次遍历结果：1 2 3 4 5 6 7 8通过本次实验，我深入理解了二叉树的性质和遍历方式，并掌握了二叉树的基本操作。
验证性实验7： 二叉树子系统
if(a!='\xA')
{
getchar();ch1='n';
}
}
}
}
BT *createtree()
{
BT *t;
char x;
scanf("%c",&x);
getchar();
if(x=='0')
t=NULL;
else
{
t=new BT;
t->data=x;
printf("\n\t\t 请输入%c结点的左子结点：",t->data);
（2）参考程序
#include<stdio.h>
#define TREEMAX 100
typedef struct BT
{
char data;
BT* lchild;
BT*rchild;
}BT;
BT *createtree();
void showtree(BT *T);
void preorder(BT *T);
printf("\n\t\t * 1 建立二叉树 *");
printf("\n\t\t * 2 凹入显示 *");
printf("\n\t\t * 3 先序遍历 *");
printf("\n\t\t * 4 中序遍历 *");
printf("\n\t\t * 5 后序遍历 *");
printf("\n\t\t * 6 层次遍历 *");
levelorder(T);break;
二叉树实验报告
二叉树实验报告二叉树是数据结构中最常见且重要的一种类型。
它由节点组成，每个节点最多有两个子节点，分别称为左节点和右节点。
通过连接这些节点，可以构建一个有序且具有层次结构的树形结构。
本实验报告将介绍二叉树的概念、特点以及常见的操作，同时介绍二叉树在实际应用中的一些典型案例。
一、二叉树的定义和特点二叉树是一种树形结构，它的每个节点至多只有两个子节点。
它的定义可以使用递归的方式进行描述：二叉树要么是一棵空树，要么由根节点和两棵分别称为左子树和右子树的二叉树组成。
二叉树的特点是每个节点最多只有两个子节点。
二、二叉树的创建和操作1.创建二叉树：二叉树可以通过两种方式来创建，一种是使用树的节点类来手动构建二叉树；另一种是通过给定的节点值列表，使用递归的方式构建二叉树。
2.遍历二叉树：二叉树的遍历有三种方式，分别是前序遍历、中序遍历和后序遍历。
a.前序遍历：先遍历根节点，再遍历左子树，最后遍历右子树。
b.中序遍历：先遍历左子树，再遍历根节点，最后遍历右子树。
c.后序遍历：先遍历左子树，再遍历右子树，最后遍历根节点。
3.查找节点：可以根据节点的值或者位置来查找二叉树中的节点。
4.插入节点：可以通过递归的方式在指定位置上插入一个新节点。
5.删除节点：可以通过递归的方式删除二叉树中的指定节点。
三、二叉树的应用案例二叉树在实际应用中有很多重要的用途，下面介绍几个典型的案例。
1.表示文件系统结构：文件系统可以使用二叉树来进行表示，每个文件或文件夹都可以看作是树中一个节点，节点之间的父子关系可以通过左右子树建立连接。
2.实现二叉树：二叉树是一种特殊的二叉树，它要求左子树上的节点值小于根节点的值，右子树上的节点值大于根节点的值。
这种树结构可以快速实现元素的插入、删除和查找等操作。
3.表达式求值：二叉树可以用来表示数学表达式，并且可以通过遍历来对表达式进行求值。
四、实验总结通过本次实验，我们深入了解了二叉树的定义和特点，学会了二叉树的创建和操作方法，以及了解了二叉树在实际应用中的一些典型案例。
数据结构——二叉树
数据结构——二叉树在计算机科学的广袤世界里，数据结构就像是一个个精巧的工具，帮助我们高效地组织和处理数据。
而在众多的数据结构中，二叉树是一个非常重要且实用的存在。
那么，什么是二叉树呢？想象一下一棵倒立的树，它的每个节点最多有两个分支，就像一个“Y”字形。
这就是二叉树的基本形态。
二叉树有很多种类，比如满二叉树、完全二叉树等等。
满二叉树就像是一个完美的对称结构，每一层的节点都填满了，没有空缺。
而完全二叉树则稍微宽松一些，除了最后一层，其他层的节点都是填满的，并且最后一层的节点都靠左排列。
为什么我们要使用二叉树呢？这是因为它在很多方面都有着出色的表现。
首先，二叉树可以让我们快速地查找数据。
比如在一个有序的二叉树中，通过比较节点的值，我们可以很快地确定目标数据所在的位置，这种查找的效率比简单的线性查找要高得多。
其次，二叉树在插入和删除数据时也有优势。
当我们需要插入一个新的数据时，通过比较节点的值，能够快速找到合适的位置进行插入。
删除操作也是类似，通过一定的规则和调整，可以保持二叉树的结构特性。
再来说说二叉树的遍历。
这就像是按照一定的顺序去访问二叉树的每个节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历是先访问根节点，然后再遍历左子树，最后遍历右子树。
比如说，对于一棵二叉树，根节点是 5，左子树的根节点是 3，右子树的根节点是 7。
那么前序遍历的顺序就是 5、3、7。
中序遍历则是先遍历左子树，然后访问根节点，最后遍历右子树。
对于刚才的例子，中序遍历的顺序就是 3、5、7。
后序遍历是先遍历左子树，再遍历右子树，最后访问根节点。
相应的顺序就是 3、7、5。
二叉树在实际应用中也非常广泛。
比如在文件系统中，目录和文件的组织就可以用二叉树来实现，方便快速地查找和管理文件。
在数据库中，索引结构也常常基于二叉树，提高数据的查询和操作效率。
在编程实现二叉树时，我们通常会定义一个节点类来表示每个节点。
这个节点类包含数据域和指向左子节点和右子节点的指针。
数据结构：二叉树子系统
数据结构：二叉树子系统在计算机科学的广袤世界中，数据结构就像是构建高效程序的基石，而二叉树则是其中一颗璀璨的明珠。
二叉树子系统作为一种重要的数据结构，在各种算法和应用中都发挥着关键作用。
让我们先从最基础的概念开始理解二叉树。
简单来说，二叉树是每个节点最多有两个子节点的树结构。
这两个子节点分别被称为左子节点和右子节点。
想象一下一棵倒立的树，根节点在顶部，然后分支向下伸展，是不是很形象？二叉树有许多独特的性质。
比如，它的深度（从根节点到最远叶子节点的路径长度）决定了其查找、插入和删除操作的效率。
而且，二叉树可以是满二叉树（所有节点都有两个子节点，除了叶子节点）、完全二叉树（除了最后一层，其他层的节点都是满的，且最后一层的节点都靠左排列）等等。
接下来，我们看看二叉树的常见操作。
首先是插入操作。
要在二叉树中插入一个新节点，需要根据节点的值与当前节点的值进行比较，然后决定向左子树还是向右子树插入。
这个过程有点像在书架上找一本书，根据书名的字母顺序来决定放在左边还是右边。
查找操作也类似。
从根节点开始，比较要查找的值和当前节点的值，如果相等，就找到了；如果小于当前节点的值，就向左子树查找；如果大于，就向右子树查找。
这种二分查找的思想使得二叉树在查找数据时具有较高的效率。
删除操作相对复杂一些。
如果要删除的节点没有子节点，那直接删除就好；如果有一个子节点，就让子节点替代它的位置；如果有两个子节点，就需要找到它的后继节点（右子树中的最小节点）或者前驱节点（左子树中的最大节点），然后用这个节点的值替换要删除的节点的值，并删除后继或前驱节点。
二叉树的遍历也是非常重要的概念。
常见的遍历方式有前序遍历（先访问根节点，然后递归遍历左子树，最后递归遍历右子树）、中序遍历（先递归遍历左子树，然后访问根节点，最后递归遍历右子树）和后序遍历（先递归遍历左子树，然后递归遍历右子树，最后访问根节点）。
这些遍历方式在不同的应用场景中都有着独特的用途。
数据结构实验报告—二叉树
数据结构实验报告—二叉树数据结构实验报告—二叉树引言二叉树是一种常用的数据结构，它由节点和边构成，每个节点最多有两个子节点。
在本次实验中，我们将对二叉树的基本结构和基本操作进行实现和测试，并深入了解它的特性和应用。
实验目的1. 掌握二叉树的基本概念和特性2. 熟练掌握二叉树的基本操作，包括创建、遍历和查找等3. 了解二叉树在实际应用中的使用场景实验内容1. 二叉树的定义和存储结构：我们将首先学习二叉树的定义，并实现二叉树的存储结构，包括节点的定义和节点指针的表示方法。
2. 二叉树的创建和初始化：我们将实现二叉树的创建和初始化操作，以便后续操作和测试使用。
3. 二叉树的遍历：我们将实现二叉树的前序、中序和后序遍历算法，并测试其正确性和效率。
4. 二叉树的查找：我们将实现二叉树的查找操作，包括查找节点和查找最大值、最小值等。
5. 二叉树的应用：我们将探讨二叉树在实际应用中的使用场景，如哈夫曼编码、二叉搜索树等。
二叉树的定义和存储结构二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。
节点被表示为一个由数据和指向其左右子节点的指针组成的结构。
二叉树可以分为三类：满二叉树、完全二叉树和非完全二叉树。
二叉树可以用链式存储结构或顺序存储结构表示。
- 链式存储结构：采用节点定义和指针表示法，通过将节点起来形成一个树状结构来表示二叉树。
- 顺序存储结构：采用数组存储节点信息，通过计算节点在数组中的位置来进行访问和操作。
二叉树的创建和初始化二叉树的创建和初始化是二叉树操作中的基础部分。
我们可以通过手动输入或读取外部文件中的数据来创建二叉树。
对于链式存储结构，我们需要自定义节点和指针，并通过节点的方式来构建二叉树。
对于顺序存储结构，我们需要定义数组和索引，通过索引计算来定位节点的位置。
一般来说，初始化一个二叉树可以使用以下步骤：1. 创建树根节点，并赋初值。
2. 创建子节点，并到父节点。
3. 重复步骤2，直到创建完整个二叉树。
数据结构二叉树实验报告
数据结构二叉树实验报告二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。
本文将介绍二叉树的定义、基本操作以及一些常见的应用场景。
一、二叉树的定义和基本操作二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。
一个节点的左子节点称为左子树，右子节点称为右子树。
二叉树的示意图如下：```A/ \B C/ \D E```在二叉树中，每个节点可以有零个、一个或两个子节点。
如果一个节点没有子节点，我们称之为叶子节点。
在上面的示例中，节点 D 和 E 是叶子节点。
二叉树的基本操作包括插入节点、删除节点、查找节点和遍历节点。
插入节点操作可以将一个新节点插入到二叉树中的合适位置。
删除节点操作可以将一个指定的节点从二叉树中删除。
查找节点操作可以在二叉树中查找指定的节点。
遍历节点操作可以按照一定的顺序遍历二叉树中的所有节点。
二、二叉树的应用场景二叉树在计算机科学中有着广泛的应用。
下面将介绍一些常见的应用场景。
1. 二叉搜索树二叉搜索树是一种特殊的二叉树，它的每个节点的值都大于其左子树中的节点的值，小于其右子树中的节点的值。
二叉搜索树可以用来实现快速的查找、插入和删除操作。
它在数据库索引、字典等场景中有着重要的应用。
2. 堆堆是一种特殊的二叉树，它的每个节点的值都大于或小于其子节点的值。
堆可以用来实现优先队列，它在任务调度、操作系统中的内存管理等场景中有着重要的应用。
3. 表达式树表达式树是一种用来表示数学表达式的二叉树。
在表达式树中，每个节点可以是操作符或操作数。
表达式树可以用来实现数学表达式的计算，它在编译器、计算器等场景中有着重要的应用。
4. 平衡二叉树平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不超过1。
平衡二叉树可以用来实现高效的查找、插入和删除操作。
它在数据库索引、自平衡搜索树等场景中有着重要的应用。
三、总结二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。
本文介绍了二叉树的定义、基本操作以及一些常见的应用场景。
数据结构二叉树实验报告
数据结构二叉树实验报告1. 引言二叉树是一种常见的数据结构，由节点（Node）和链接（Link）构成。
每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树在计算机科学中被广泛应用，例如在搜索算法中，二叉树可以用来快速查找和插入数据。
本实验旨在通过编写二叉树的基本操作来深入理解二叉树的特性和实现方式。
2. 实验内容2.1 二叉树的定义二叉树可以用以下方式定义：class TreeNode:def__init__(self, val):self.val = valself.left =Noneself.right =None每个节点包含一个值和两个指针，分别指向左子节点和右子节点。
根据需求，可以为节点添加其他属性。
2.2 二叉树的基本操作本实验主要涉及以下二叉树的基本操作：•创建二叉树：根据给定的节点值构建二叉树。
•遍历二叉树：将二叉树的节点按照特定顺序访问。
•查找节点：在二叉树中查找特定值的节点。
•插入节点：向二叉树中插入新节点。
•删除节点：从二叉树中删除特定值的节点。
以上操作将在下面章节详细讨论。
3. 实验步骤3.1 创建二叉树二叉树可以通过递归的方式构建。
以创建一个简单的二叉树为例：def create_binary_tree():root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left.left = TreeNode(4)root.left.right = TreeNode(5)return root以上代码创建了一个二叉树，根节点的值为1，左子节点值为2，右子节点值为3，左子节点的左子节点值为4，左子节点的右子节点值为5。
3.2 遍历二叉树二叉树的遍历方式有多种，包括前序遍历、中序遍历和后序遍历。
以下是三种遍历方式的代码实现：•前序遍历：def preorder_traversal(root):if root:print(root.val)preorder_traversal(root.left)preorder_traversal(root.right)•中序遍历：def inorder_traversal(root):if root:inorder_traversal(root.left)print(root.val)inorder_traversal(root.right)•后序遍历：def postorder_traversal(root):if root:postorder_traversal(root.left)postorder_traversal(root.right)print(root.val)3.3 查找节点在二叉树中查找特定值的节点可以使用递归的方式实现。
数据结构实验报告-树(二叉树)
实验5：树（二叉树）（采用二叉链表存储）一、实验项目名称二叉树及其应用二、实验目的熟悉二叉树的存储结构的特性以及二叉树的基本操作。
三、实验基本原理之前我们都是学习的线性结构，这次我们就开始学习非线性结构——树。
线性结构中结点间具有唯一前驱、唯一后继关系，而非线性结构中结点的前驱、后继的关系并不具有唯一性。
在树结构中，节点间关系是前驱唯一而后继不唯一，即结点之间是一对多的关系。
直观地看，树结构是具有分支关系的结构（其分叉、分层的特征类似于自然界中的树）。
四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和预定义2.创建二叉树3.前序遍历4.中序遍历5.后序遍历6.总结点数7.叶子节点数8.树的深度9.树根到叶子的最长路径10.交换所有节点的左右子女11.顺序存储12.显示顺序存储13.测试函数和主函数对二叉树的每一个操作写测试函数，然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序，代码见“实验完整代码”。
实验完整代码：#include <bits/stdc++.h>using namespace std;#define MAX_TREE_SIZE 100typedef char ElemType;ElemType SqBiTree[MAX_TREE_SIZE];struct BiTNode{ElemType data;BiTNode *l,*r;}*T;void createBiTree(BiTNode *&T){ElemType e;e = getchar();if(e == '\n')return;else if(e == ' ')T = NULL;else{if(!(T = (BiTNode *)malloc(sizeof (BiTNode)))){cout << "内存分配错误!" << endl;exit(0);}T->data = e;createBiTree(T->l);createBiTree(T->r);}}void createBiTree2(BiTNode *T,int u) {if(T){SqBiTree[u] = T->data;createBiTree2(T->l,2 * u + 1);createBiTree2(T->r,2 * u + 2); }}void outputBiTree2(int n){int cnt = 0;for(int i = 0;cnt <= n;i++){cout << SqBiTree[i];if(SqBiTree[i] != ' ')cnt ++;}cout << endl;}void preOrderTraverse(BiTNode *T) {if(T){cout << T->data;preOrderTraverse(T->l);preOrderTraverse(T->r);}}void inOrderTraverse(BiTNode *T) {if(T){inOrderTraverse(T->l);cout << T->data;inOrderTraverse(T->r);}}void beOrderTraverse(BiTNode *T){if(T){beOrderTraverse(T->l);beOrderTraverse(T->r);cout << T->data;}}int sumOfVer(BiTNode *T){if(!T)return 0;return sumOfVer(T->l) + sumOfVer(T->r) + 1;}int sumOfLeaf(BiTNode *T){if(!T)return 0;if(T->l == NULL && T->r == NULL)return 1;return sumOfLeaf(T->l) + sumOfLeaf(T->r);}int depth(BiTNode *T){if(!T)return 0;return max(depth(T->l),depth(T->r)) + 1;}bool LongestPath(int dist,int dist2,vector<ElemType> &ne,BiTNode *T) {if(!T)return false;if(dist2 == dist)return true;if(LongestPath(dist,dist2 + 1,ne,T->l)){ne.push_back(T->l->data);return true;}else if(LongestPath(dist,dist2 + 1,ne,T->r)){ne.push_back(T->r->data);return true;}return false;}void swapVer(BiTNode *&T){if(T){swapVer(T->l);swapVer(T->r);BiTNode *tmp = T->l;T->l = T->r;T->r = tmp;}}//以下是测试程序void test1(){getchar();cout << "请以先序次序输入二叉树结点的值，空结点用空格表示:" << endl; createBiTree(T);cout << "二叉树创建成功!" << endl;}void test2(){cout << "二叉树的前序遍历为:" << endl;preOrderTraverse(T);cout << endl;}void test3(){cout << "二叉树的中序遍历为:" << endl;inOrderTraverse(T);cout << endl;}void test4(){cout << "二叉树的后序遍历为:" << endl;beOrderTraverse(T);cout << endl;}void test5(){cout << "二叉树的总结点数为：" << sumOfVer(T) << endl;}void test6(){cout << "二叉树的叶子结点数为：" << sumOfLeaf(T) << endl; }void test7(){cout << "二叉树的深度为：" << depth(T) << endl;}void test8(){int dist = depth(T);vector<ElemType> ne;cout << "树根到叶子的最长路径:" << endl;LongestPath(dist,1,ne,T);ne.push_back(T->data);reverse(ne.begin(),ne.end());cout << ne[0];for(int i = 1;i < ne.size();i++)cout << "->" << ne[i];cout << endl;}void test9(){swapVer(T);cout << "操作成功!" << endl;}void test10(){memset(SqBiTree,' ',sizeof SqBiTree);createBiTree2(T,0);cout << "操作成功!" << endl;}void test11(){int n = sumOfVer(T);outputBiTree2(n);}int main(){int op = 0;while(op != 12){cout << "-----------------menu--------------------" << endl;cout << "--------------1：创建二叉树--------------" << endl;cout << "--------------2：前序遍历----------------" << endl;cout << "--------------3：中序遍历----------------" << endl;cout << "--------------4：后序遍历----------------" << endl;cout << "--------------5：总结点数----------------" << endl;cout << "--------------6：叶子节点数--------------" << endl;cout << "--------------7：树的深度----------------" << endl;cout << "--------------8：树根到叶子的最长路径----" << endl;cout << "--------------9：交换所有节点左右子女----" << endl;cout << "--------------10：顺序存储---------------" << endl;cout << "--------------11：显示顺序存储-----------" << endl;cout << "--------------12：退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl;if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1();break;case 2:test2();break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:cout << "测试结束!" << endl;break;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果测试用例：1.创建二叉树（二叉链表形式）2.前序遍历3.中序遍历4.后序遍历5.总结点数6.叶子结点数7.树的深度8.树根到叶子的最长路径9.交换所有左右子女10.顺序存储七、思考讨论题或体会或对改进实验的建议通过这次实验，我掌握了二叉树的顺序存储和链式存储，体会了二叉树的存储结构的特性，掌握了二叉树的树上相关操作。
数据结构实验报告二叉树
数据结构实验报告二叉树二叉树是一种重要的数据结构，广泛应用于计算机科学和算法设计中。
在本次实验中，我们通过实际编程实践，深入理解了二叉树的基本概念、性质和操作。
一、二叉树的定义和基本性质二叉树是一种特殊的树结构，每个节点最多有两个子节点。
它具有以下基本性质：1. 根节点：二叉树的顶部节点称为根节点，它没有父节点。
2. 子节点：每个节点最多有两个子节点，分别称为左子节点和右子节点。
3. 叶节点：没有子节点的节点称为叶节点。
4. 深度：从根节点到某个节点的路径长度称为该节点的深度。
5. 高度：从某个节点到其叶节点的最长路径长度称为该节点的高度。
6. 层次遍历：按照从上到下、从左到右的顺序遍历二叉树的节点。
二、二叉树的实现在本次实验中，我们使用C++语言实现了二叉树的基本操作，包括创建二叉树、插入节点、删除节点、查找节点等。
通过这些操作，我们可以方便地对二叉树进行增删改查。
三、二叉树的遍历二叉树的遍历是指按照某种顺序访问二叉树的所有节点。
常用的遍历方式有三种：前序遍历、中序遍历和后序遍历。
1. 前序遍历：先访问根节点，然后依次递归遍历左子树和右子树。
2. 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。
3. 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。
四、二叉树的应用二叉树在计算机科学和算法设计中有广泛的应用。
以下是一些常见的应用场景：1. 二叉搜索树：二叉搜索树是一种特殊的二叉树，它的左子树的值都小于根节点的值，右子树的值都大于根节点的值。
它可以高效地支持插入、删除和查找操作，常用于有序数据的存储和检索。
2. 堆：堆是一种特殊的二叉树，它的每个节点的值都大于（或小于）其子节点的值。
堆常用于实现优先队列等数据结构。
3. 表达式树：表达式树是一种用二叉树表示数学表达式的方法。
通过对表达式树的遍历，可以实现对数学表达式的计算。
4. 平衡树：平衡树是一种特殊的二叉树，它的左右子树的高度差不超过1。
数据结构实验报告—二叉树
数据结构实验报告—二叉树目录1. 引言1.1 背景1.2 目的2. 前期准备2.1 问题定义2.2 数据准备3. 算法设计3.1 插入节点3.2 删除节点3.3 查找节点3.4 遍历二叉树4. 实验过程4.1 实验环境4.2 实验步骤5. 实验结果与分析5.1 插入节点的结果 5.2 删除节点的结果 5.3 查找节点的结果5.4 遍历二叉树的结果6. 总结与讨论6.1 实验总结6.2 实验改进方向7. 结论8. 参考文献1. 引言1.1 背景介绍二叉树的概念和应用领域，以及在数据结构中的重要性。
1.2 目的明确本实验的目标，即设计一个能够实现插入、删除、查找和遍历二叉树的算法，并对其进行实验验证。
2. 前期准备2.1 问题定义对二叉树的基本操作进行定义，包括插入节点、删除节点、查找节点和遍历二叉树。
2.2 数据准备准备一组用于测试的数据集，包括插入节点、删除节点和查找节点时所需的数据。
3. 算法设计3.1 插入节点详细描述如何设计实现插入节点的算法，并分析算法的时间复杂度和空间复杂度。
3.2 删除节点详细描述如何设计实现删除节点的算法，并分析算法的时间复杂度和空间复杂度。
3.3 查找节点详细描述如何设计实现查找节点的算法，并分析算法的时间复杂度和空间复杂度。
3.4 遍历二叉树详细描述如何设计实现遍历二叉树的算法，并分析算法的时间复杂度和空间复杂度。
4. 实验过程4.1 实验环境描述实验所用的编程语言和相关工具的环境配置。
4.2 实验步骤详细描述实验的具体步骤，包括数据准备、算法实现、代码编写、实验运行和结果分析等。
5. 实验结果与分析5.1 插入节点的结果展示插入节点的实验结果，并对结果进行详细分析和讨论。
5.2 删除节点的结果展示删除节点的实验结果，并对结果进行详细分析和讨论。
5.3 查找节点的结果展示查找节点的实验结果，并对结果进行详细分析和讨论。
5.4 遍历二叉树的结果展示遍历二叉树的实验结果，并对结果进行详细分析和讨论。
国家开放大学《数据结构》课程实验报告(实验4——二叉树)参考答案
（实验4二叉树）
学生姓名
学 号
班 级
指导老师
实验名称
实验成绩
实验报告
实ቤተ መጻሕፍቲ ባይዱ
验
概
述
实验目的：
（1）根据数组tree，建立与该二叉树对应的链式存储结构。
（2）对该二叉树采用中序遍历法显示遍历结果。
实验要求：
（1）在主函数中，通过键盘输入建立设定的完全二叉树的顺序存储结构。
（2）设计子函数，其功能为将顺序结构的二叉树转化为链式结构。
（2）中序遍历采用递归算法，即中序遍历左子树、访问根结点、中序遍历右子树。
实
验
内
容
程序代码：
/*实验3.1二叉树的顺序存储结构和链式存储结构*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 20
/*二叉树链式存储结构结点定义*/
typedef struct BTreeNode
指
导
教
师
评
语
指导教师 日期
（3）设计子函数，其功能为对给定二叉树进行中序遍历，显示遍历结果。
（4）通过实例判断算法和相应程序的正确性。
实验基本原理：
（1）顺序存储的二叉树转化为链式存储结构，采用递归算法，递归函数的形式为Creab(tree,n,i,b)，其中形参：tree为顺序存储二叉树的数组，n为二叉树的结点数，i是二叉树某结点在数组tree中的下标（初始值为1），b为要建立的链式存储二叉树结点指针。转化时，首先建立*b结点，将tree[i]的值赋给*b的数据域，再调用递归函数分别构造左子树和右子树。
数据结构二叉树实验报告(附代码)
一、【实验构思（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)。
验证性实验7：二叉树子系统班级学号BX100420 姓名施程程成绩1．实验目的（1）掌握二叉树的特点及其存储的方式。
（2）掌握二叉树的创建和显示方法。
（3）复习二叉树遍历的概念，掌握二叉树遍历的基本方法（4）掌握求二叉树的叶结点数、总结点数和深度等基本算法。
2．实验内容（1）按屏幕提示用前序方法建立一棵二叉树，并能按凹入法显示二叉树结构。
（2）编写前序遍历、中序遍历、后序遍历、层次遍历程序。
（3）编写求二叉树的叶结点数、总结点数和深度的程序。
（4）设计一个选择式菜单，以菜单方式选择下列操作。
二叉树子系统********************************************");* 1---------建二叉树 *");* 2---------凹入显示 *");* 3---------先序遍历 *");* 4---------中序遍历 *");* 5---------后序遍历 *");* 6---------层次遍历 *");* 7---------求叶子数 *");* 8---------求结点数 *");* 9---------求树深度 *");* 0---------返回 *");********************************************");请选择菜单号（0--9）：3．实验步骤：（1）输入并调试程序；（2）按下图建立二叉树；二叉树子系统******************************************* 1---------建二叉树** 2---------凹入显示** 3---------先序遍历** 4---------中序遍历** 5---------后序遍历** 6---------层次遍历** 7---------求叶子数** 8---------求结点数** 9---------求树深度** 0---------返回*******************************************请选择菜单号：1<CR>请输入按先序建立二叉树的结点序列：说明：'0'代表后继结点为空，请逐个输入，按回车键输入下一结点。
请输入根结点：a<CR>请输入a结点的左子结点：b<CR>请输入b结点的左子结点：d<CR>请输入d结点的左子结点：0<CR>请输入d结点的右子结点：0<CR>请输入b结点的右子结点：0<CR>请输入a结点的右子结点：c<CR>请输入c结点的左子结点：e<CR>请输入e结点的左子结点：0<CR>请输入e结点的右子结点：0<CR>请输入c结点的右子结点：f<CR>请输入f结点的左子结点：0<CR>请输入f结点的右子结点：0<CR>（3）检查凹入法显示的二叉树是否正确；二叉树子系统******************************************* 1---------建二叉树** 2---------凹入显示** 3---------先序遍历** 4---------中序遍历** 5---------后序遍历** 6---------层次遍历** 7---------求叶子数** 8---------求结点数** 9---------求树深度** 0---------返回*******************************************请选择菜单号：2<CR>凹入表示法：a ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃b ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃d ▃▃▃▃▃▃▃▃▃▃▃▃▃c ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃e ▃▃▃▃▃▃▃▃▃▃▃▃▃f ▃▃▃▃▃▃▃▃▃▃▃▃▃按回车键返回主菜单! <CR>（4）检查其他算法的正确性举例：二叉树子系统******************************************* 1---------建二叉树** 2---------凹入显示** 3---------先序遍历** 4---------中序遍历** 5---------后序遍历** 6---------层次遍历** 7---------求叶子数** 8---------求结点数** 9---------求树深度** 0---------返回*******************************************请选择菜单号：3<CR>该二叉树的先序遍历序列为：a b d c e f4．实验程序#include<stdio.h>#define TREEMAX 100typedef struct BT{char data;BT *lchild;BT *rchild;}BT;BT *CreateTree();void ShowTree(BT *T);void Preorder(BT *T);void Postorder(BT *T);void Levelorder(BT *T);void Inorder(BT *T);void Leafnum(BT *T);void Nodenum(BT *T);int TreeDepth(BT *T);int count=0;void main(){BT *T=NULL;char ch1,ch2,a;ch1='y';while(ch1=='y'||ch1=='y'){printf("\n");printf("\n\t\t 二叉树子系统");printf("\n\t\t******************************************");printf("\n\t\t* 1---------建二叉树*");printf("\n\t\t* 2---------凹入显示*");printf("\n\t\t* 3---------先序遍历*");printf("\n\t\t* 4---------中序遍历*");printf("\n\t\t* 5---------后序遍历*");printf("\n\t\t* 6---------层次遍历*");printf("\n\t\t* 7---------求叶子数*");printf("\n\t\t* 8---------求结点数*");printf("\n\t\t* 9---------求树深度*");printf("\n\t\t* 0---------返回*");printf("\n\t\t******************************************");printf("\n\t\t 请选择菜单号（0--9）：");scanf("%c",&ch2);getchar();printf("\n");switch(ch2){case '1':printf("\n\t\t请按先序序列输入二叉树的结点：\n");printf("\n\t\t说明：输入结点('0'代表后继结点为空)后按回车.\n");printf("\n\t\t请输入根结点：");T=CreateTree();printf("\n\t\t二叉树成功建立！\n");break;case '2':ShowTree(T);break;case '3':printf("\n\t\t该二叉树的先序遍历序列为：");Preorder(T);break;case '4':printf("\n\t\t该二叉树的中序遍历序列为：");Inorder(T);break;case '5':printf("\n\t\t该二叉树的后序遍历序列为：");Postorder(T);break;case '6':printf("\n\t\t该二叉树的层次遍历序列为：");Levelorder(T);break;case '7':count=0;Leafnum(T);printf("\n\t\t该二叉树有%d个叶子。
\n",count);break;case '8':count=0;Nodenum(T);printf("\n\t\t该二叉树总共有%d个结点。
\n",count);break;case '9':printf("\n\t\t该树的深度是：%d",TreeDepth(T));break;case '0':ch1='n';break;default:printf("\n\t\t***请注意：输入有误！***");}if(ch2!='0'){printf("\n\n\t\t按【Enter】键继续，按任意键返回主菜单！\n");a=getchar();if(a!='\xA'){getchar();ch1='n';}}}}BT *CreateTree(){BT *t;char x;scanf("%c",&x);getchar();if(x=='0')t=NULL;else{t=new BT;t->data=x;printf("\n\t\t请输入%c结点的左子结点：",t->data);t->lchild=CreateTree();printf("\n\t\t请输入%c结点的右子结点：",t->data);t->rchild=CreateTree();}return t;}void Preorder(BT *T){if(T){printf("%3c",T->data);Preorder(T->lchild);Preorder(T->rchild);}}void Inorder(BT *T){if(T){Inorder(T->lchild);printf("%3c",T->data);Inorder(T->rchild);}}void Postorder(BT *T){if(T){Postorder(T->lchild);Postorder(T->rchild);printf("%3c",T->data);}}void Levelorder(BT *T){int i,j;BT *q[100],*p;p=T;if(p!=NULL){i=1;q[i]=p;j=2;}while(i!=j){p=q[i];printf("%3c",p->data);if(p->lchild!=NULL){q[j]=p->lchild;j++;}if(p->rchild!=NULL){q[j]=p->rchild;j++;}i++;}}void Leafnum(BT *T){if(T){if(T->lchild==NULL&&T->rchild==NULL)count++;Leafnum(T->lchild);Leafnum(T->rchild);}}void Nodenum(BT *T){if(T){count++;Nodenum(T->lchild);Nodenum(T->rchild);}}int TreeDepth(BT *T){int ldep,rdep;if(T==NULL)return 0;else{ldep=TreeDepth(T->lchild);rdep=TreeDepth(T->rchild);if(ldep>rdep)return ldep+1;elsereturn rdep+1;}}void ShowTree(BT *T){BT *stack[TREEMAX],*p;int level[TREEMAX][2],top,n,i,width=4;if(T!=NULL){printf("\n\t\t凹入表示法：\n\t\t");top=1;stack[top]=T;level[top][0]=width;while(top>0){p=stack[top];n=level[top][0];for(i=1;i<=n;i++)printf(" ");printf("%c",p->data);for(i=n+1;i<30;i+=2)printf("▃");printf("\n\t\t");top--;if(p->rchild!=NULL){top++;stack[top]=p->rchild;level[top][0]=n+width;level[top][1]=2;}if(p->lchild!=NULL){top++;stack[top]=p->lchild;level[top][0]=n+width;level[top][1]=1;}}}}5．程序运行6．实验小结本章要求我们掌握的是二叉树的特点、存储方式、创建、显示、遍历以及节点数等计算方法。