二叉树的建立与遍历
if(NodeCount==pow(2,depth)-1)//计算是否为满二叉树
printf("该树为满二叉树!\n");
else
printf("该树不是满二叉树!\n");
}
5.测试数据及结果
输入为abc..d..ef..g..
输出结果为如下图：
输入为ab.d.f..g..c.e.h..
输出结果为如下图：
实验总结：
本次实验主要判断一个二叉树是否为满二叉树并且进行一些要求:
1.先序进行创建二叉树；
2.中序输出二叉树的结点；
3.中序统计二叉树的总结点数目；
4.后序遍历求二叉树的深度。
（5）主函数：void main()
4.详细设计
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int NodeCount=0;
int h=0;
int depth=0;
typedef char DataType;
typedef struct Node
{
if (root!=NULL)
{
d);
printf("%c ",root ->data);
InOrder(root ->RChild);
}
}
void Node_num(BiTree root) //统计二叉树的结点数目
{
if(root!=NULL)
{
Node_num(root->LChild);
printf("先序创建二叉树:\n");
CreateBiTree(&root);
printf("先序输出二叉树:\n");
InOrder(root);
printf("\n");
Node_num(root);//计算树中节点的总数
printf("树中结点的个数为:%d\n",NodeCount);
depth=PostTreeDepth(root);
NodeCount++;
Node_num(root->RChild);
}
}
int PostTreeDepth(BiTree bt) /*后序遍历求二叉树的高度递归算法*/
{
int hl,hr,max;
if(bt!=NULL)
{
hl=PostTreeDepth(bt->LChild); /*求左子树的深度*/
洛阳理工学院实验报告
系别
计算机系
班级
学号
姓名
课程名称
数据结构
实验日期
2014.4.18
实验名称
二叉树的建立与遍历
成绩
实验目的：
熟悉掌握二叉链表存储结构及基本算法，并能应用二叉树的基本算法解决与之有关的简单问题，训练和提高结构化程序设计能力及程序调试能力。
实验条件：
计算机一台，Visual C++6.0
3.模块划分
（1）先序创建二叉树链表：void CreateBiTree(BiTree *bt)
（2）中序遍历输出二叉树中结点：void InOrder(BiTree root)
（3）统计二叉树的结点数目：void Node_num(BiTree root)
（4）后序遍历求二叉树的高度递归算法：int PostTreeDepth(BiTree bt)
{
DataType data;
struct Node*LChild;
struct Node*RChild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree *bt) //先序创建二叉树链表
{
DataType ch;
ch=getchar();
if(ch=='.') *bt=NULL;//用.表示节点的左或右孩子为空
else
{
*bt=(BiTree)malloc(sizeof(BiTNode));
(*bt)->data=ch;
CreateBiTree(&((*bt)->LChild));
CreateBiTree(&((*bt)->RChild));
}
}
void InOrder(BiTree root) //中序遍历输出二叉树中结点
实验内容：
1.问题描述
判断一棵二叉树是否为满二叉树。要求二叉树用二叉链表存储。
2.数据结构类型定义
typedef char DataType;
typedef struct Node
{
DataType data;
struct Node*LChild;
struct Node*RChild;
}BiTNode,*BiTree;
hr=PostTreeDepth(bt->RChild); /*求右子树的深度*/
max=hl>hr?hl:hr; /*得到左、右子树深度较大者*/
return(max+1); /*返回树的深度*/
}
else return(0); /*如果是空树，则返回0 */
}
void main()
{
BiTree root;
二叉树的基本操作课件浙教版(2019)高中信息技术选修1(24张PPT)
A
B
D
C
E
F
G
头指针
二叉树的list实现
二叉树节点可以看成是一个三元组，元素是左、右子树和本节点数据。
Python的list可以用于组合这样的三个元素。
下面介绍用list构造二叉树的方法。
（1）空树用None表示。
（2）非空二叉树用包含三个元素的列表[d,l,r]表示，其中：d表示根节点的元素，l和r是两棵子树，采用与整个二叉树同样结构的list表示。
二叉树的遍历
在完成二叉树的建立操作后，就可以对二叉树的各个节点进行访问，即遍历操作。二叉树的遍历，是指按照一定的规则和次序访问二叉树中的所有节点，使得每个节点都被访问一次且仅被访问一次。按照不同的遍历方式对节点进行访问，其处理效率不完全相同。二叉树的遍历方式有很多，主要有前序遍历、中序遍历和后序遍历等。
1.数组实现
用数组来表示二叉树时，分为以下两种情况。
（1）完全二叉树从二叉树的根节点开始，按从上而下、自左向右的顺序对n个节点进行编号，根节点的编号为0，最后一个节点的编号为n-1。然后依次将二叉树的节点用一组连续的数组元素来表示，节点编号与数组的下标一一对应。如下图中图甲所示的完全二叉树所对应的一维数组表示如图乙所示。
A
B
C
A
B
C
甲 原二叉树
乙 补全后的二叉树
0
1
2
3
4
5
6
7
丙 数组实现示意图
A
B
C
对于完全二叉树而言，一维数组的表示方式既简单又节省存储空间。但对于一般的二叉树来说，采用一维数组表示时，结构虽然简单，却容易造成存储空间的浪费。
二叉树的建立与基本操作
二叉树的建立与基本操作二叉树是一种特殊的树形结构，它由节点（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.中序遍历中序遍历是指先访问左子节点，然后访问根节点，最后访问右子节点。
二叉树的建立与先序中序后序遍历 求叶子节点个数 求分支节点个数 求二叉树的高度
/*一下总结一些二叉树的常见操作：包括建立二叉树先/中/后序遍历二叉树求二叉树的叶子节点个数求二叉树的单分支节点个数计算二叉树双分支节点个数计算二叉树的高度计算二叉树的所有叶子节点数*/#include<stdio.h> //c语言的头文件#include<stdlib.h>//c语言的头文件stdlib.h千万别写错了#define Maxsize 100/*创建二叉树的节点*/typedef struct BTNode //结构体struct 是关键字不能省略结构体名字可以省略（为无名结构体）//成员类型可以是基本型或者构造形，最后的为结构体变量。
{char data;struct BTNode *lchild,*rchild;}*Bitree;/*使用先序建立二叉树*/Bitree Createtree() //树的建立{char ch;Bitree T;ch=getchar(); //输入一个二叉树数据if(ch==' ') //' '中间有一个空格的。
T=NULL;else{ T=(Bitree)malloc(sizeof(Bitree)); //生成二叉树(分配类型*)malloc(分配元素个数*sizeof(分配类型))T->data=ch;T->lchild=Createtree(); //递归创建左子树T->rchild=Createtree(); //地柜创建右子树}return T;//返回根节点}/*下面先序遍历二叉树*//*void preorder(Bitree T) //先序遍历{if(T){printf("%c-",T->data);preorder(T->lchild);preorder(T->rchild);}} *//*下面先序遍历二叉树非递归算法设计*/void preorder(Bitree T) //先序遍历非递归算法设计{Bitree st[Maxsize];//定义循环队列存放节点的指针Bitree p;int top=-1; //栈置空if(T){top++;st[top]=T; //根节点进栈while(top>-1) //栈不空时循环{p=st[top]; //栈顶指针出栈top--;printf("%c-",p->data );if(p->rchild !=NULL) //右孩子存在进栈{top++;st[top]=p->rchild ;}if(p->lchild !=NULL) //左孩子存在进栈{top++;st[top]=p->lchild ;}}printf("\n");}}/*下面中序遍历二叉树*//*void inorder(Bitree T) //中序遍历{if(T){inorder(T->lchild);printf("%c-",T->data);inorder(T->rchild);}}*//*下面中序遍历二叉树非递归算法设计*/void inorder(Bitree T) //中序遍历{Bitree st[Maxsize]; //定义循环队列，存放节点的指针Bitree p;int top=-1;if(T){p=T;while (top>-1||p!=NULL) //栈不空或者*不空是循环{while(p!=NULL) //扫描*p的所有左孩子并进栈{top++;st[top]=p;p=p->lchild ;}if(top>-1){p=st[top]; //出栈*p节点，它没有右孩子或右孩子已被访问。
山大数据结构实验报告二叉树
实验报告实验内容：二叉树的建立与基本操作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.二叉树的高度基本思想：首先分析二叉树的深度（高度）和它的左、右子树深度之间的关系。
实验8 线索二叉树的创建和遍历
实验八线索二叉树的创建和遍历1.实验目的（1）掌握二叉树的线索链表存储结构。
（2）能够实现二叉树的线索链表的创建、遍历等基本操作。
2.实验内容编程实现二叉树的线索链表存储表示的基本操作，包括线索二叉树的创建与遍历。
3.实验要求（1）根据实验内容编写程序，上机调试并获得运行结果（2）撰写实验报告4.准备工作本次实验将会构造此二叉树，并会对此二叉树进行遍历5.关键步骤与算法(1)构造线索二叉树算法步骤；若某节点的左孩子节点指针域（lchild）为空，就可以利用它来指出该节点在某种遍历序列中的直接前驱的存储地址；若某节点的右孩子指针域（rchild）为空，就可以利用它来指出该节点在某种遍历序列中的直接后继的存储地址。
那些非空的指针域仍存放指向该节点左、右孩子节点的指针域。
这样，就得到了一棵线索二叉树。
算法如下；1.//按先序遍历序列输入树中各节点的值，构造线索二叉树2.BiThrTree* CreateBiThrTree()3.{4. BiThrTree *s;5. DataType ch;6. scanf("%c",&ch);7.8.if(ch == '#')9. exit(0);10.if(ch == '@')11. s = NULL;12.else if (ch=='\n')13. getchar();14.15.else16. {17. s = (BiThrTree *)malloc(sizeof(BiThrTree));18.if(!s)19. exit(ERROR);20. s->data = ch;21. s->lflag = 0;22. s->rflag = 0;23. s->lchild = CreateBiThrTree();24. s->rchild = CreateBiThrTree();25. }26.return s;27.}(2) 将二叉树中序线索化现将树递归到左子树然后再判断这个树的左右子树是否为空，如果为空则把它们的标志设为1，代表线索，首先设一个current代表前驱结点，然后判断它是否为空，如果为空则进行下一次递归，如果不为空，则判断左标志和右标志如果左标志为线索，则让前驱节点的右孩子指向当前节点，如果右标志为1，则让当前节点的左孩子指向前驱结点算法如下；1.void InThreading(BiThrTree *t)2.{3.if(t != NULL)//先判断树为不为空，如果为空，则不执行函数4. {5. InThreading(t->lchild);//递归调用左子树进行线索化6.if(t->lchild == NULL)7. t->lflag = 1;8.if(t->rchild == NULL)9. t->rflag = 1;10.//以上两步是判断这个结点的左右结点是否为空，若为空，把他们对应的flag标上111.if(current != NULL)//因为要用到current所以要判断一下，且current只有当t回到倒数第二个结点时，才会不为NULL12. {13.if(current->rflag == 1)14. current->rchild = t;//前驱结点的右孩子指针指向当前节点t15.if(t->lflag == 1)16. t->lchild = current;//现结点t的左孩子指针指向前驱结点17. }18. current = t;//让前驱结点为t为下一次执行函数做准备19. InThreading(t->rchild);//递归调用右子树进行线索化20. }21.}6．源代码1.#include<malloc.h>2.#include<stdio.h>3.#include<stdlib.h>4.#include<io.h>5.#define ERROR -16.7.typedef char DataType;8.typedef struct BiThrNode//二叉树的二叉链表的存储结构9.{10. DataType data;11.struct BiThrNode *lchild,*rchild;12.int lflag,rflag;//左右标志，值为0表示指针，值为1表示线索13.}BiThrTree;14.BiThrTree *current = NULL;15.//检查if的==16.//按先序遍历序列输入树中各节点的值，构造线索二叉树17.BiThrTree* CreateBiThrTree()18.{19. BiThrTree *s;20. DataType ch;21. scanf("%c",&ch);22.23.if(ch == '#')24. exit(0);25.if(ch == '@')26. s = NULL;27.else if (ch=='\n')28. getchar();29.30.else31. {32. s = (BiThrTree *)malloc(sizeof(BiThrTree));33.if(!s)34. exit(ERROR);35. s->data = ch;36. s->lflag = 0;37. s->rflag = 0;38. s->lchild = CreateBiThrTree();39. s->rchild = CreateBiThrTree();40. }41.return s;42.}43.//将二叉树前序线索化（递归）44.void PreThreading(BiThrTree *t)45.{46.if(t != NULL)//先判断树为不为空，如果为空，则不执行函数47. {48.if(t->lchild == NULL)49. t->lflag = 1;50.if(t->rchild == NULL)51. t->rflag = 1;52.//以上两步是判断这个结点的左右结点是否为空，若为空，把他们对应的flag标上153.if(current != NULL)//因为要用到current所以要判断一下，且current只有当t回到倒数第二个结点时，才会不为NULL54. {55.if(current->rflag == 1)56. current->rchild = t;//前驱结点的右孩子指针指向当前节点t57.if(t->lflag == 1)58. t->lchild = current;//现结点t的左孩子指针指向前驱结点59. }60. current = t;//让前驱结点为t为下一次执行函数做准备61.if(t->lflag == 0)62. PreThreading(t->lchild);//递归调用右子树进行线索化63.if(t->rflag == 0)64. PreThreading(t->rchild);65. }66.}67.//遍历前序线索二叉树68.void PreVisitThrtree(BiThrTree *t)69.{70.while(t != NULL)//大循环71. {72.while(t->lflag == 0)73. {74. printf("%c\t",t->data);75. t = t->lchild;76. }77. printf("%c\t",t->data);78. t = t->rchild;79. }80.}81.82.//检查if的==83.//将二叉树中序线索化（递归）84.void InThreading(BiThrTree *t)85.{86.if(t != NULL)//先判断树为不为空，如果为空，则不执行函数87. {88. InThreading(t->lchild);//递归调用左子树进行线索化89.if(t->lchild == NULL)90. t->lflag = 1;91.if(t->rchild == NULL)92. t->rflag = 1;93.//以上两步是判断这个结点的左右结点是否为空，若为空，把他们对应的flag标上194.if(current != NULL)//因为要用到current所以要判断一下，且current只有当t回到倒数第二个结点时，才会不为NULL95. {96.if(current->rflag == 1)97. current->rchild = t;//前驱结点的右孩子指针指向当前节点t98.if(t->lflag == 1)99. t->lchild = current;//现结点t的左孩子指针指向前驱结点100. }101. current = t;//让前驱结点为t为下一次执行函数做准备102. InThreading(t->rchild);//递归调用右子树进行线索化103. }104.}105.//检查if的==106.//遍历中序线索二叉树107.void InVisitThrtree(BiThrTree *t)108.{109.while(t != NULL)//大循环110. {111.while(t->lflag == 0)//小循环1;此循环第一次进行时首先要去找到最左节点112. t = t->lchild;113.if(t == NULL)114. exit(ERROR);115. printf("%c\t",t->data);116.while(t->rflag == 1 && t->rchild != NULL)//小循环2117. {118. t = t->rchild;119. printf("%c\t",t->data);120. }121. t = t->rchild;122./*123.两种情况：124. 1.如果t的右子树为空则t直接指向t的中序后继结点.125. 2.如果t的右子树不为空，即t->rflag为0，那么退出这个小循环2回到大循环中，再到小循环1中去找t的右子树的最左下的结点.126. */127. }128.}129.130.//将二叉树后序线索化（递归）131.void PostThreading(BiThrTree *t)132.{133.if(t != NULL)//先判断树为不为空，如果为空，则不执行函数134. {135. PreThreading(t->lchild);136. PreThreading(t->rchild);137.if(t->lchild == NULL)138. t->lflag = 1;139.if(t->rchild == NULL)140. t->rflag = 1;141.//以上两步是判断这个结点的左右结点是否为空，若为空，把他们对应的flag标上1142.if(current != NULL)//因为要用到current所以要判断一下，且current只有当t回到倒数第二个结点时，才会不为NULL143. {144.if(current->rflag == 1)145. current->rchild = t;//前驱结点的右孩子指针指向当前节点t146.if(t->lflag == 1)147. t->lchild = current;//现结点t的左孩子指针指向前驱结点148. }149. current = t;//让前驱结点为t为下一次执行函数做准备150. }151.}152.//遍历后序线索二叉树153.void PostVisitThrtree(BiThrTree *t)154.{155.if(t)156. {157.while(t->lchild != NULL && t->lflag == 0)158. {159. t = t->lchild;//先遍历到最左边的节点160. }161. }162.}163.//主函数164.void main()165.{166. BiThrTree *t,*s;167. printf("\t\t请按先序序列输入二叉树(如：ABC@@DE@G@@F@@@#)\n\t\t");168. t = CreateBiThrTree();169. InThreading(t);170. printf("\t\t按中序遍历输出线索二叉树：\n\t\t");171. InVisitThrtree(t);172. printf("\n");173.//getchar();174.//getchar();175. fflush(stdin);//这个操作必须要进行，或者是进行上面注释的那两步操作，要不然176. printf("\t\t请按先序序列输入二叉树(如：ABC@@DE@G@@F@@@#)\n\t\t");177. s = CreateBiThrTree();178. PreThreading(s);179. printf("\t\t按前序遍历输出线索二叉树：\n\t\t");180. PreVisitThrtree(s);181.}7.测试图8.实验总结然对于这一节，主要是讨论线索二叉树的建立以及遍历，对于二叉树的建立，主要有五个部分构成，分别是data，lchild，rchild，lflag，rflag，而它与二叉树不同的地方就是多了lflag和rflag的判断，当当前节点的左节点为空时一定会指向它的前驱结点，当前驱节点的右节点为空时，让前驱结点的右指针域指向当前节点，这就是线索化，而对于前序中序后序的线索化本质都是一样的。
数据结构入门-树的遍历以及二叉树的创建
数据结构⼊门-树的遍历以及⼆叉树的创建树定义：1. 有且只有⼀个称为根的节点2. 有若⼲个互不相交的⼦树，这些⼦树本⾝也是⼀个树通俗的讲：1. 树是有结点和边组成，2. 每个结点只有⼀个⽗结点，但可以有多个⼦节点3. 但有⼀个节点例外，该节点没有⽗结点，称为根节点⼀、专业术语结点、⽗结点、⼦结点、根结点深度：从根节点到最底层结点的层数称为深度，根节点第⼀层叶⼦结点：没有⼦结点的结点⾮终端节点：实际上是⾮叶⼦结点度：⼦结点的个数成为度⼆、树的分类⼀般树：任意⼀个结点的⼦结点的个数都不受限制⼆叉树：任意⼀个结点的⼦结点个数最多是两个，且⼦结点的位置不可更改⼆叉数分类：1. ⼀般⼆叉数2. 满⼆叉树：在不增加树层数的前提下，⽆法再多添加⼀个结点的⼆叉树3. 完全⼆叉树：如果只是删除了满⼆叉树最底层最右边的连续若⼲个结点，这样形成的⼆叉树就是完全⼆叉树森林：n个互不相交的树的集合三、树的存储⼆叉树存储连续存储(完全⼆叉树)优点：查找某个结点的⽗结点和⼦结点(也包括判断有没有⼦结点)速度很快缺点：耗⽤内存空间过⼤链式存储⼀般树存储1. 双亲表⽰法：求⽗结点⽅便2. 孩⼦表⽰法：求⼦结点⽅便3. 双亲孩⼦表⽰法：求⽗结点和⼦结点都很⽅便4. ⼆叉树表⽰法：把⼀个⼀般树转化成⼀个⼆叉树来存储，具体转换⽅法：设法保证任意⼀个结点的左指针域指向它的第⼀个孩⼦，右指针域指向它的兄弟，只要能满⾜此条件，就可以把⼀个⼀般树转化为⼆叉树⼀个普通树转换成的⼆叉树⼀定没有右⼦树森林的存储先把森林转化为⼆叉树，再存储⼆叉树四、树的遍历先序遍历：根左右先访问根结点，再先序访问左⼦树，再先序访问右⼦树中序遍历：左根右中序遍历左⼦树，再访问根结点，再中序遍历右⼦树后续遍历：左右根后续遍历左⼦树，后续遍历右⼦树，再访问根节点五、已知两种遍历求原始⼆叉树给定了⼆叉树的任何⼀种遍历序列，都⽆法唯⼀确定相应的⼆叉树，但是如果知道了⼆叉树的中序遍历序列和任意的另⼀种遍历序列，就可以唯⼀地确定⼆叉树已知先序和中序求后序先序：ABCDEFGH中序：BDCEAFHG求后序：这个⾃⼰画个图体会⼀下就可以了，⾮常简单，这⾥简单记录⼀下1. ⾸先根据先序确定根，上⾯的A就是根2. 中序确定左右，A左边就是左树(BDCE)，A右边就是右树(FHG)3. 再根据先序，A左下⾯就是B，然后根据中序，B左边没有，右边是DCE4. 再根据先序，B右下是C，根据中序，c左下边是D，右下边是E，所以整个左树就确定了5. 右树，根据先序，A右下是F，然后根据中序，F的左下没有，右下是HG，6. 根据先序，F右下为G，然后根据中序，H在G的左边，所以G的左下边是H再来⼀个例⼦，和上⾯的思路是⼀样的，这⾥就不详细的写了先序：ABDGHCEFI中序：GDHBAECIF已知中序和后序求先序中序：BDCEAFHG后序：DECBHGFA这个和上⾯的思路是⼀样的，只不过是反过来找，后序找根，中序找左右树简单应⽤树是数据库中数据组织⼀种重要形式操作系统⼦⽗进程的关系本⾝就是⼀棵树⾯向对象语⾔中类的继承关系哈夫曼树六、⼆叉树的创建#include <stdio.h>#include <stdlib.h>typedef struct Node{char data;struct Node * lchild;struct Node * rchild;}BTNode;/*⼆叉树建⽴*/void BuildBT(BTNode ** tree){char ch;scanf("%c" , &ch); // 输⼊数据if(ch == '#') // 如果这个节点的数据是#说明这个结点为空*tree = NULL;else{*tree = (BTNode*)malloc(sizeof(BTNode));//申请⼀个结点的内存 (*tree)->data = ch; // 将数据写⼊到结点⾥⾯BuildBT(&(*tree)->lchild); // 递归建⽴左⼦树BuildBT(&(*tree)->rchild); // 递归建⽴右⼦树}}/*⼆叉树销毁*/void DestroyBT(BTNode *tree) // 传⼊根结点{if(tree != NULL){DestroyBT(tree->lchild);DestroyBT(tree->rchild);free(tree); // 释放内存空间}}/*⼆叉树的先序遍历*/void Preorder(BTNode * node){if(node == NULL)return;else{printf("%c ",node->data );Preorder(node->lchild);Preorder(node->rchild);}}/*⼆叉树的中序遍历*/void Inorder(BTNode * node){if(node == NULL)return;else{Inorder(node->lchild);printf("%c ",node->data );Inorder(node->rchild);}}/*⼆叉树的后序遍历*/void Postorder(BTNode * node){if(node == NULL)return;else{Postorder(node->lchild);Postorder(node->rchild);printf("%c ",node->data );}}/*⼆叉树的⾼度树的⾼度 = max(左⼦树⾼度，右⼦树⾼度) +1*/int getHeight(BTNode *node){int Height = 0;if (node == NULL)return 0;else{int L_height = getHeight(node->lchild);int R_height = getHeight(node->rchild);Height = L_height >= R_height ? L_height +1 : R_height +1; }return Height;}int main(int argc, char const *argv[]){BTNode * BTree; // 定义⼀个⼆叉树printf("请输⼊⼀颗⼆叉树先序序列以#表⽰空结点:");BuildBT(&BTree);printf("先序序列：");Preorder(BTree);printf("\n中序序列：");Inorder(BTree);printf("\n后序序列：");Postorder(BTree);printf("\n树的⾼度为：%d" , getHeight(BTree));return 0;}// ABC##DE##F##G##。
二叉树的各种基本运算的实现实验报告
二叉树的各种基本运算的实现实验报告
一、实验目的
实验目的为了深入学习二叉树的各种基本运算，通过操作实现二叉树的建立、存储、查找、删除、遍历等各种基本运算操作。
二、实验内容
1、构造一个二叉树。
我们首先用一定的节点来构建一棵二叉树，包括节点的左子节点和右子节点。
2、实现查找二叉树中的节点。
在查找二叉树中的节点时，我们根据二叉树的特点，从根节点开始查找，根据要查找的节点的值与根节点的值的大小的关系，来决定接下来查找的方向，直到找到要查找的节点为止。
3、实现删除二叉树中的节点。
在删除二叉树节点时，我们要做的是找到要删除节点的父节点，然后让父节点的链接指向要删除节点的子节点，有可能要删除节点有一个子节点，有可能有两个极点，有可能没有子节点，我们要根据每种情况进行处理，来保持二叉树的结构不变。
4、对二叉树进行遍历操作。
二叉树的遍历有多种方法，本实验使用的是先序遍历。
首先从根节点出发，根据先序遍历的顺序，先访问左子树，然后再访问右子树，最后访问根节点。
三、实验步骤
1、构建二叉树：
我们用一个数组代表要构建的二叉树，第一项为根节点，第二项和第三项是根节点的子节点。
树和二叉树的实验报告
树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构，它们在各种算法和应用中都有广泛的应用。
本实验旨在通过实际操作和观察，深入了解树和二叉树的特性和操作。
二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构，由节点和边组成。
每个节点可以有零个或多个子节点，其中一个节点没有父节点的称为根节点。
树的特点包括层次结构、唯一根节点和无环等。
2. 树的构建在本实验中，我们使用Python语言构建了一棵树。
通过定义节点类和树类，我们可以方便地创建树的实例，并添加节点和连接节点之间的边。
3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
我们在实验中实现了这三种遍历方式，并观察了它们的输出结果。
三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树，每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。
2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。
通过定义节点类和二叉树类，我们可以创建二叉树的实例，并实现插入节点、删除节点和查找节点等操作。
3. 二叉树的应用二叉树在实际应用中有很多用途。
例如，二叉搜索树可以用于实现快速查找和排序算法。
AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。
我们在实验中实现了这些应用，并通过实际操作验证了它们的效果。
四、实验结果与讨论通过实验，我们成功构建了树和二叉树的数据结构，并实现了它们的基本操作。
通过观察和分析实验结果，我们发现树和二叉树在各种算法和应用中的重要性和灵活性。
树和二叉树的特性使得它们适用于解决各种问题，例如搜索、排序、图算法等。
同时，我们也发现了一些问题和挑战，例如树的平衡性和节点的插入和删除操作等。
这些问题需要进一步的研究和优化。
五、总结本实验通过实际操作和观察，深入了解了树和二叉树的特性和操作。
二叉树的建立、遍历、叶子节点计数、深度计算
⼆叉树的建⽴、遍历、叶⼦节点计数、深度计算⼆叉树的建⽴有三中⽅式：先序遍历建树，中序遍历建树，后序遍历建树⼆叉树的遍历⽅式也有三种：先序遍历，中序遍历，后序遍历另外还可以计算⼆叉树的深度，计算⼆叉树的叶⼦结点数遍历倒是没有什么问题，但是我刚开始建树的时候总是出现问题；先定义⼀个树节点，然后把这个树节点传进建树的函数中进⾏建树，这样的话建树的函数必须把树根的地址返回给建树之前定义的那个节点总之就是：建树的函数必须能够把所建⽴的树的地址传回去(不管⽤什么传递⽅式);下⾯粘贴两个代码（建树⽅式都是先序）;sampleinputABD*F***CE***输出先序遍历结果ABDFCE中序遍历结果DFBAEC后序遍历结果FDBECA树的深度为4叶节点个数为2代码⼀：#include <string.h>#include <stdlib.h>#include <stdio.h>#include <malloc.h>#include <iostream>using namespace std;struct Node{char data;struct Node *l, *r;};int sum = 0;struct Node *Creat(struct Node *p){char q;scanf("%c", &q);if(q == '*')p = NULL;else{p = (struct Node *)malloc(sizeof(struct Node));p->data = q;p->l = Creat(p->l);p->r = Creat(p->r);}return p;}int Xianxu(struct Node *p){if(p){printf("%c", p->data);Xianxu(p->l);Xianxu(p->r);}return0;}int Zhongxu(struct Node *p){if(p){Zhongxu(p->l);printf("%c", p->data);Zhongxu(p->r);}return0;}int Houxu(struct Node *p){if(p){Houxu(p->l);Houxu(p->r);printf("%c", p->data);}return0;}int Deep(struct Node *p){int c1, c2;if(!p)return0;c1 = Deep(p->l);c2 = Deep(p->r);return c1 > c2 ? c1+1 : c2+1;}int Jiedian(struct Node *p){if(p){Jiedian(p->l);Jiedian(p->r);if((p->l == NULL) && (p->r == NULL))sum++;}return sum;}int main(){int sum;struct Node *head;head = (struct Node *)malloc(sizeof(struct Node));head = Creat(head);printf("先序遍历结果\n");Xianxu(head);printf("\n");printf("中序遍历结果\n");Zhongxu(head);printf("\n");printf("后序遍历结果\n");Houxu(head);printf("\n");printf("树的深度为%d\n", Deep(head));sum = Jiedian(head);printf("叶节点个数为%d\n", sum);return0;}代码⼆：/*⼆叉树的⼆叉链表的存储⽅式注意⼆叉树也有三叉链表的存储⽅式，这种存储⽅式记录左右⼦树的根以及双亲节点的地址但是⼆叉树的三叉链表存储⽅式存储有n个节点的树会产⽣n+1个空的链域遍历是⼆叉树最基本的操作，对某个节点的改动可以通过遍历来实现，检索某个节点也可以通过遍历来实现*/#include <windows.h>#include <stdio.h>#include <string.h>#include <iostream>int i = 0;using namespace std;typedef struct TreeNode //定义树上的每⼀个节点{char data;struct TreeNode *lchild, *rchild;}TreeNode;int Preorder(struct TreeNode *p); //先序遍历void Inorder(struct TreeNode *p); //中根遍历void Posorder(struct TreeNode *p); //后根遍历void CreatBiTree(TreeNode &p); // 建⽴⼆叉树int Preorder(struct TreeNode *p)//先序遍历{if(p){cout << p->data;Preorder(p->lchild);Preorder(p->rchild);}return0;}void Inorder(struct TreeNode *p) //中根遍历{if(p){Inorder(p->lchild);cout << p->data;Inorder(p->rchild);}}void Posorder(struct TreeNode *p)//后根遍历{if(p){Posorder(p->lchild);Posorder(p->rchild);cout << p->data;}}char Getonech(char ar[]){return ar[i++];}TreeNode* CreatBiTree(TreeNode *p) //建⽴⼆叉树{char ch;scanf("%c", &ch);if(ch != '*'){p = new TreeNode;p->data = ch;p->lchild = CreatBiTree(p->lchild);p->rchild = CreatBiTree(p->rchild);}elsep = NULL;return p;}TreeNode* CreatBiTree(TreeNode *p, char ar[]){char ch;ch = Getonech(ar);if(ch != '*'){p = new TreeNode;p->data = ch;p->lchild = CreatBiTree(p->lchild, ar);p->rchild = CreatBiTree(p->rchild, ar);}elsep = NULL;return p;}int main(){//第⼀种建树⽅式(⽤已经定义的字符串建树) char s[19] = "ABD*F***CE***";TreeNode *tree = new TreeNode;tree = CreatBiTree(tree, s);printf("先序遍历结果\n");Preorder(tree);printf("\n");printf("中序遍历结果\n");Inorder(tree);printf("\n");printf("后序遍历结果\n");Posorder(tree);printf("\n");//第⼆种建树⽅式（输⼊树）TreeNode *tree1 = new TreeNode; tree1 = CreatBiTree(tree1);printf("先序遍历结果\n");Preorder(tree1);printf("\n");system("pause");printf("中序遍历结果\n");Inorder(tree1);system("pause");printf("\n");printf("后序遍历结果\n");Posorder(tree1);system("pause");printf("\n");return0;}。
二叉树的创建与遍历的实验总结
二叉树的创建与遍历的实验总结一、实验目的二叉树是一种重要的数据结构，本实验旨在通过编写程序实现二叉树的创建和遍历，加深对二叉树的理解，并掌握二叉树相关算法。
二、实验原理1. 二叉树的定义：每个节点最多有两个子节点的树结构。
2. 二叉树的遍历方式：前序遍历、中序遍历、后序遍历和层次遍历。
3. 二叉树的创建方式：递归创建和非递归创建。
三、实验内容1. 实现递归创建二叉树：通过输入节点值，按照前序遍历方式逐个创建节点，直到输入结束符号为止。
2. 实现非递归创建二叉树：通过输入节点值，按照层次遍历方式逐个创建节点，直到输入结束符号为止。
3. 实现前序遍历、中序遍历、后序遍历和层次遍历函数，并输出结果。
四、实验步骤1. 定义节点结构体Node，包含数据域和左右子节点指针域。
2. 实现递归创建函数createTreeRecursion()：读入一个字符，如果是结束符号，则返回NULL；否则新建一个节点，并依次读入左右子节点值并分别递归调用createTreeRecursion()函数，将左右子节点指针指向返回值。
3. 实现非递归创建函数createTreeNonRecursion()：读入一个字符，如果是结束符号，则返回NULL；否则新建一个节点，并将其加入队列中。
在队列不为空的情况下，取出队首元素并分别读入左右子节点值并新建节点加入队列中，将左右子节点指针指向新建的节点。
4. 实现前序遍历函数preorderTraversal()：输出当前节点数据，递归调用preorderTraversal()函数遍历左子树和右子树。
5. 实现中序遍历函数inorderTraversal()：递归调用inorderTraversal()函数遍历左子树，输出当前节点数据，再递归调用inorderTraversal()函数遍历右子树。
6. 实现后序遍历函数postorderTraversal()：递归调用postorderTraversal()函数遍历左子树和右子树，输出当前节点数据。