二叉树的先序遍历

一、软件背景介绍树的遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。

访问结点所做的操作依赖于具体的应用问题。

遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算的基础。

从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。

因此，在任一给定结点上，可以按某种次序执行三个操作：⑴访问结点本身（N），⑵遍历该结点的左子树（L），⑶遍历该结点的右子树（R）。

所以二叉树的遍历也包括三种：先序遍历，中序遍历，和后序遍历。

图1：程序显示结果二、核心算法思想二叉树的存储：在内存中为数组binary分配一个大小为63（0，0，0）的存储空间，所有数组元素初始化为0，用来存放二叉树。

每三个连续的数组地址存放一个节点：第一个地址存放节点的值；第二个地址存放有无左孩子的信息，如果有则将其置为1，否则为0；第三个地址存放有无右孩子的信息，如果有则将其置为1，否则为0。

将binary的首址偏移赋给si，cx初始化为0用来计数，用回车代表输入的为空，即没有输入。

按先根存储的方式来存二叉树，首先输入一个字符，若为回车则退出程序，否则cx+3且调用函数root。

然后该结点若有左孩子，调用leftchild函数，置该结点标志即第二个地址中的0为1，该结点进栈，再存储左孩子结点，递归调用左右，若没有左孩子，看有没有右孩子，若有，则调用rightchild置该结点标志位即上第三个地址中的0为1，然后该结点进栈，再存储右孩子结点，递归调用左右，整个用cx计数，数组binary中每多一个节点，cx加3。

此存储方式正好符合先序遍历思想。

遍历二叉树的执行踪迹：三种递归遍历算法的搜索路线相同，具体线路为：从根结点出发，逆时针沿着二叉树外缘移动，对每个结点均途径三次，最后回到根结点。

二叉树的遍历有常用的三种方法，分别是：先根次序、中根次序、后根次序。

为了验证这几种遍历算法的区别，本次的实验将会实现所有的算法。

数据结构先序中序后序理解数据结构是计算机科学中的重要概念之一，它是指一组数据的组织方式以及对这组数据进行操作的方法。

在学习数据结构的过程中，我们经常会遇到先序、中序和后序这三个概念。

它们是用来描述二叉树的遍历方式的，也可以用来表示表达式的计算顺序。

本文将从先序、中序和后序这三个角度来解释数据结构的含义和应用。

一、先序遍历先序遍历是指按照根节点、左子树、右子树的顺序访问二叉树的节点。

在先序遍历中，我们首先访问根节点，然后递归地遍历左子树和右子树。

先序遍历的应用非常广泛，比如在文件系统的目录结构中，我们可以使用先序遍历来列出所有的文件和文件夹。

二、中序遍历中序遍历是指按照左子树、根节点、右子树的顺序访问二叉树的节点。

在中序遍历中，我们首先递归地遍历左子树，然后访问根节点，最后再递归地遍历右子树。

中序遍历在二叉搜索树的操作中非常常见，它可以按照从小到大的顺序输出二叉搜索树中的元素。

三、后序遍历后序遍历是指按照左子树、右子树、根节点的顺序访问二叉树的节点。

在后序遍历中，我们首先递归地遍历左子树和右子树，最后访问根节点。

后序遍历常用于对二叉树进行一些计算操作，比如计算二叉树的深度、判断二叉树是否对称等。

除了用于二叉树的遍历，先序、中序和后序还可以用来表示表达式的计算顺序。

在数学表达式中，运算符和操作数之间的顺序非常重要，它决定了表达式的计算结果。

先序、中序和后序可以用来表示运算符的位置，从而决定表达式的计算顺序。

先序表示法中，运算符位于操作数之前，如"+ 3 4"表示加法运算。

中序表示法中，运算符位于操作数之间，如"3 + 4"表示加法运算。

后序表示法中，运算符位于操作数之后，如"3 4 +"表示加法运算。

不同的表示法对应着不同的计算顺序，但它们都能得到相同的结果。

先序、中序和后序在数据结构中有着广泛的应用。

它们不仅仅是一种遍历方式，还可以表示表达式的计算顺序。

7
二叉树的遍历——递归算法
中序遍历算法 LDR(node *root) {if(root !=NULL) {LDR(root->lchild);
printf(“%d”,root->data); LDR(root->rchild); } return(0);}
后序遍历算法 LRD (node *root) {if(root !=NULL) {LRD(root->lchild); LRD(root->rchild); printf(“%d”,root->data); } return(0);}
二叉树的遍历
单位：xx师范学院科技学院 作者：xx
1
二叉树的遍历——定义
定义——
指如何按某条搜索路径巡访二叉树 中每个结点，使得每个结点均被访 问一次，而且仅被访问一次。
2
二叉树的遍历——规则
二叉树由根、左子树、右子树构成，定义为D、 L、R ❖ D、 L、R的组合定义了六种可能的遍历方案：
LDR, LRD, DLR, DRL, RDL, RLD ❖ 若限定先左后右，则有三种实现方案：
B
E
中序序列：
C
F
B D C AE H G K F
D
G
后序序列：
H K DCBHKGFEA
10
谢谢观看！
11
DLR 先序遍历
LDR 中序遍历
LRD 后序遍历
3
二叉树的遍历——先序遍历
A
D
L
R
B D
C
A
D LR
D LR
B
先序遍历序列：A B D C
C D LR
D
4
二叉树的遍历——中序遍历

return(p); }
建立二叉树
以字符串的形式“根左子树右子树”定义 一棵二叉树
1）空树 2）只含一个根 结点的二叉树 A 3）
B C
A
以空白字符“ ”表示
以字符串“A ”表示
D
以下列字符串表示 AB C D
建立二叉树 A B C C
T
A ^ B ^ C^ ^ D^
D
建立二叉树
Status CreateBiTree(BiTree &T) {
1 if (!T) return;
2 Inorder(T->lchild, visit); // 遍历左子树 3 visit(T->data); } // 访问结点 4 Inorder(T->rchild, visit); // 遍历右子树
后序（根）遍历
若二叉树为空树，则空操
根
左 子树
右 子树
作；否则， （1）后序遍历左子树； （2）后序遍历右子树； （3）访问根结点。
统计二叉树中结点的个数
遍历访问了每个结点一次且仅一次
设置一个全局变量count=0
将visit改为:count++
统计二叉树中结点的个数
void PreOrder (BiTree T){ if (! T ) return; count++; Preorder( T->lchild); Preorder( T->rchild); } void Preorder (BiTree T,void( *visit)(TElemType& e)) { // 先序遍历二叉树 1 if (!T) return; 2 visit(T->data); // 访问结点 3 Preorder(T->lchild, visit); // 遍历左子树 4 Preorder(T->rchild, visit);// 遍历右子树 }

/*栈结构定义*/
{ bintree data[100];
int tag[100];//为栈中每个元素设置的标记，用于后序遍历 int top; //栈顶指针,指向栈顶元素,这和2章中top有区别
} seqstack;
void push(seqstack *s,bintree t) /*进栈*/
{ s->data[++s->top]=t;
}
bintree pop(seqstack *s) /*出栈*/
{ if (s->top!=-1) { s->top--; return(s->data[s->top+1]); } else return NULL; }
1、 二叉树前序遍历的非递归实现
前序遍历一棵非空二叉树t 时，访问完t的根结点后， 就应该进入t的左子树，但此时必须将t保存起来， 以便访问完其左子树后，通过t的RCHILD再进入其 右子树的访问，即在t处必须设置一个回溯点；对t 的左子树和右子树的遍历也是如此。仔细观察不难 发现，这些回溯点应该使用栈来进行管理。在整个 二叉树前序遍历的过程中，程序要做的工作始终分 成两个部分：当前正在处理的树（子树）和保存在 栈中待处理的部分，只有这两部分的工作均完成后， 程序方能结束。
void createbintree(bintree *t) { char ch; if ((ch=getchar())==' ') *t=NULL; else { *t=(bintnode *)malloc(sizeof(bintnode)); /*生成二叉树的根结点*/ (*t)->data=ch; createbintree(&(*t)->lchild); /*递归实现左子树的建立*/ createbintree(&(*t)->rchild); /*递归实现右子树的建立*/ }

大工14秋《数据结构》在线作业2
一,单选题
1. 二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK；中序遍历: HFIEJKG 。

该二叉树根的右子树的根是（）。

A. E
B. F
C. G
D. H
?
正确答案：C
2. union(A,B,C)表示求集合A和B的并集C。

若A={a,b,c},B={c,d},则union(A,B,C)运算后C=（）。

A. {a,b,c,d}
B. {a,b,c}
C. {a,b}
D. {c,d}
?
正确答案：A
3. 对二叉树的结点从1开始进行连续编号，要求每个结点的编号大于其左、右孩子的编号，同一结点的左右孩子中，其左孩子的编号小于其右孩子的编号，可采用（）次序的遍历实现编号。

A. 先序
B. 中序
C. 后序
D. 从根开始按层次遍历
?
正确答案：C
4. 树中的结点数等于所有结点的度数加（）。

A. 0
B. 1
C. 2
D. 3
?
正确答案：B
5. concat(s,t)表示连接运算。

将串t连接在串s之后，形成新的串s。

若s="he",t="llo",则concat(s,t)之后，s="（）"。

A. hello
B. helo。

特别讨论
若已知先序（或后序）遍历结果和中序遍历结 果，能否“恢复”出二叉树？
例：已知一棵二叉树的中序序列和后序序列分别是 BDCEAFHG 和 DECBHGFA，请画出这棵二叉树。 分析：
①由后序遍历特征，根结点必在后序序列尾部（即A）；
②由中序遍历特征，根结点必在其中间，而且其左部必全 部是左子树的子孙（即BDCE），其右部必全部是右子树的 子孙（即FHG）；
知识拓展—利用遍历建立二叉树
如何把二叉树存入电脑内？ 怎样利用遍历建立一棵二叉树？
例：将下面的二叉树以二叉链表形式存入计算机内。
A
B
C
D
E
F
考虑1：输入结点时怎样表示“无孩子”？ 考虑2：以何种遍历方式来输入和建树？
字符串输完后应当再 以加先一序特遍殊历的最结为束合符适号， 用空格字符表示 让(如每$个)，结因点为都能及时无 ‘无孩子’或指针 被法连惟接一到表位示。结束。 为空
三种遍历算法分析
1. 从前面的三种遍历算法可以知道：如果将print语句抹去， 从递归的角度看，这三种算法是完全相同的，或者说这三种 遍历算法的访问路径是相同的，只是访问结点的时机不同。
A
B
C
D
E
F
G
从虚线的出发点到终点的路径 上，每个结点经过3次。 第1次经过时访问，是先序遍历 第2次经过时访问，是中序遍历 第3次经过时访问，是后序遍历
难
的遍历方法。
二叉树遍历
➢理解二叉树
的应用。
点
的遍历算法
烧伤病人的治疗通常是取烧伤病人的 健康皮 肤进行 自体移 植，但 对于大 面积烧 伤病人 来讲， 健康皮 肤很有 限，请 同学们 想一想 如何来 治疗该 病人

二叉树知识点总结二叉树是一种常见的数据结构，它由节点和边组成，每个节点最多有两个子节点。

以下是关于二叉树的知识点总结。

1. 二叉树的基本概念二叉树是一种树形结构，它由节点和边组成。

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

如果一个节点没有子节点，则称其为叶子节点。

二叉树可以为空。

2. 二叉树的遍历方式遍历是指按照一定顺序访问二叉树中的所有节点。

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

前序遍历：先访问当前节点，然后递归访问左子树和右子树。

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

后序遍历：先递归访问左子树和右子树，最后访问当前节点。

3. 二叉搜索树二叉搜索树（Binary Search Tree）也称为有序二叉树或排序二叉树。

它是一种特殊的二叉树，在满足以下条件的情况下被称为“搜索”：对于任意节点，其左子树中的所有节点的值都小于该节点的值。

对于任意节点，其右子树中的所有节点的值都大于该节点的值。

左右子树也分别为二叉搜索树。

二叉搜索树支持快速查找、插入和删除操作。

它还有一些变种，如平衡二叉搜索树（AVL Tree）和红黑树（Red-Black Tree）等。

4. 二叉堆二叉堆是一种特殊的完全二叉树，它分为最大堆和最小堆两种类型。

最大堆满足父节点的值大于等于其子节点的值，最小堆满足父节点的值小于等于其子节点的值。

在最大堆中，根节点是整个堆中最大的元素；在最小堆中，根节点是整个堆中最小的元素。

二叉堆常用来实现优先队列（Priority Queue），即按照一定优先级顺序处理元素。

5. 二叉树常见问题5.1 判断是否为平衡二叉树平衡二叉树（Balanced Binary Tree）是指任意节点左右子树高度差不超过1的二叉搜索树。

判断一个二叉搜索树是否为平衡二叉树可以通过递归遍历每个节点，计算其左右子树的高度差。

5.2 判断是否为完全二叉树完全二叉树（Complete Binary Tree）是指除了最后一层外，其他层都是满的，并且最后一层的节点都靠左排列的二叉树。

⼆叉树的遍历及相关题⽬⼆叉树的遍历及相关题⽬1.1⼆叉树遍历的概念⼆叉树结构体的定义：typedef struct node{ ElemType data; struct node * lchild; struct node * rchild;}⼆叉树的遍历是指按照⼀定的次序访问⼆叉树中的所有的节点，并且每个节点仅访问⼀次的过程。

若规定先遍历左⼦树，后遍历右⼦树，则对于⾮空⼆叉树，可得到如下3种递归的遍历⽅法：（1）先序遍历访问根节点，先序遍历左⼦树，先序遍历右⼦树。

（根，左，右）（2）中序遍历中序遍历左⼦树，访问根节点，中序遍历右⼦树。

（左，根，右）（3）后序遍历后序遍历左⼦树，后序遍历右⼦树，访问根节点。

（左，右，根）除此之外也有层次遍历。

先访问根节点，在从左到右访问第⼆层的所有节点，从左到右访问第三层的所有节点......1.2⼆叉树遍历递归算法先序遍历递归算法：void PreOrder(BTNode * b){ if(n != NULL) { cout<<b->data; PreOrder(b->lchild); PreOrder(b->rchild); }}中序遍历递归算法void InOrder(BTNode * b){ if(n != NULL) { InOrder(b->lchild); cout<<b->data; InOrder(b->rchild); }}后序遍历递归算法：void PostOrder(BTNode * b){ if(b != NULL) { PostOrder(b->lchild); PostOrder(b->rchild); cout<<b->data; }}题⽬1：输出⼀个给定⼆叉树的所有的叶⼦节点：void DispLeaf(BTNode * b){ if(b != NULL) { if(b->lchild == NULL && b->rchild == NULL) cout<<b->data; DispLeaf(b->lchild); DispLeaf(b->rchild); }}以上算法采⽤先序遍历输出了所有的叶⼦节点，所以叶⼦节点是从左到右输出的。

二叉树各种计算公式总结二叉树是一种常见的数据结构，它由一个根节点和最多两个子节点组成。

许多计算问题可以通过对二叉树进行各种操作和遍历来解决。

在本文中，将总结二叉树的各种计算公式。

1.二叉树节点个数：二叉树节点个数的计算公式是N=N1+N2+1，其中N表示二叉树的节点个数，N1表示左子树的节点个数，N2表示右子树的节点个数。

2. 二叉树的高度：二叉树的高度是指从根节点到最远叶子节点的最长路径上的节点数量。

计算二叉树的高度的公式是H = max(H1, H2) + 1，其中H表示二叉树的高度，H1表示左子树的高度，H2表示右子树的高度。

3.二叉树的深度：二叉树的深度是指从根节点到当前节点的路径的长度。

计算二叉树的深度的公式是D=D1+1，其中D表示二叉树的深度，D1表示父节点的深度。

4.二叉查找树：二叉查找树是一种有序二叉树，它要求对于树中的每个节点，左子树的值都小于节点的值，右子树的值都大于节点的值。

在二叉查找树中进行的公式是：-如果目标值等于当前节点的值，则返回当前节点；-如果目标值小于当前节点的值，则在左子树中继续；-如果目标值大于当前节点的值，则在右子树中继续。

5.二叉树的遍历：二叉树的遍历是指按照一定的顺序访问二叉树中的所有节点。

常见的二叉树遍历方式有三种：- 前序遍历：先访问根节点，然后递归地访问左子树，最后递归地访问右子树。

可以表示为：root -> 左子树 -> 右子树。

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

可以表示为：左子树 -> root -> 右子树。

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

可以表示为：左子树 -> 右子树 -> root。

6.二叉树的最大路径和：二叉树的最大路径和是指二叉树中两个节点之间路径上的节点值的最大和。

可以通过递归地计算每个子树的最大路径和，然后选择最大的子树路径和来得出最终结果。

竭诚为您提供优质文档/双击可除二叉树的建立和遍历的实验报告篇一：二叉树遍历实验报告数据结构实验报告报告题目：二叉树的基本操作学生班级：学生姓名：学号：一．实验目的1、基本要求：深刻理解二叉树性质和各种存储结构的特点及适用范围；掌握用指针类型描述、访问和处理二叉树的运算；熟练掌握二叉树的遍历算法；。

2、较高要求:在遍历算法的基础上设计二叉树更复杂操作算法；认识哈夫曼树、哈夫曼编码的作用和意义;掌握树与森林的存储与便利。

二.实验学时：课内实验学时：3学时课外实验学时：6学时三．实验题目1．以二叉链表为存储结构，实现二叉树的创建、遍历（实验类型：验证型）1）问题描述：在主程序中设计一个简单的菜单，分别调用相应的函数功能：1…建立树2…前序遍历树3…中序遍历树4…后序遍历树5…求二叉树的高度6…求二叉树的叶子节点7…非递归中序遍历树0…结束2）实验要求：在程序中定义下述函数，并实现要求的函数功能：createbinTree(binTreestructnode*lchild,*rchild;}binTnode;元素类型：intcreatebinTree(binTreevoidpreorder(binTreevoidInorder(binTreevoidpostorder(binTreevoidInordern(binTreeintleaf(bi nTreeintpostTreeDepth(binTree2、编写算法实现二叉树的非递归中序遍历和求二叉树高度。

1）问题描述：实现二叉树的非递归中序遍历和求二叉树高度2）实验要求：以二叉链表作为存储结构3)实现过程：1、实现非递归中序遍历代码：voidcbiTree::Inordern(binTreeinttop=0;p=T;do{while(p!=nuLL){stack[top]=p;;top=top+1;p=p->lchild;};if(top>0){top=top-1;p=stack[top];printf("%3c",p->data);p=p->rchild;}}while(p!=nuLL||top!=0);}2、求二叉树高度：intcbiTree::postTreeDepth(binTreeif(T!=nuLL){l=postTreeDepth(T->lchild);r=postTreeDepth(T->rchil d);max=l>r?l:r;return(max+1);}elsereturn(0);}实验步骤：1）新建一个基于consoleApplication的工程，工程名称biTreeTest；2）新建一个类cbiTree二叉树类。

数据结构先序中序后序理解一、先序遍历先序遍历是指首先访问根节点，然后按照先序遍历的方式遍历左子树，最后再遍历右子树。

具体来说，先序遍历的顺序是根节点→左子树→右子树。

先序遍历的特点是能够保证根节点最先被访问，适用于需要先处理根节点的场景。

先序遍历常用的应用场景包括二叉树的构建和重建、表达式的求值和转换、图的深度优先搜索等。

在二叉树的构建和重建中，先序遍历可以用来确定根节点的位置，进而构建整棵二叉树。

而在表达式的求值和转换中，先序遍历可以将中缀表达式转换为后缀表达式，方便进行求值。

在图的深度优先搜索中，先序遍历可以帮助我们找到从起始节点出发的所有路径。

二、中序遍历中序遍历是指先遍历左子树，然后访问根节点，最后再遍历右子树。

具体来说，中序遍历的顺序是左子树→根节点→右子树。

中序遍历的特点是能够保证节点按照从小到大的顺序被访问，适用于需要按照顺序处理节点的场景。

中序遍历常用的应用场景包括二叉搜索树的操作、中序表达式的求值和转换等。

在二叉搜索树的操作中，中序遍历可以按照从小到大的顺序输出树中的所有节点，方便进行查找和排序操作。

在中序表达式的求值和转换中，中序遍历可以将中缀表达式转换为前缀或后缀表达式，方便进行求值。

三、后序遍历后序遍历是指先遍历左子树，然后遍历右子树，最后访问根节点。

具体来说，后序遍历的顺序是左子树→右子树→根节点。

后序遍历的特点是能够保证根节点最后被访问，适用于需要先处理子节点的场景。

后序遍历常用的应用场景包括二叉树的销毁和释放、表达式树的构建等。

在二叉树的销毁和释放中，后序遍历可以先销毁子节点，最后释放根节点的内存，避免内存泄漏。

在表达式树的构建中，后序遍历可以根据后缀表达式构建整棵表达式树，方便进行表达式的求值。

先序遍历、中序遍历和后序遍历是数据结构中常用的三种遍历方式。

它们各自具有不同的特点和应用场景，能够帮助我们更好地处理和操作数据。

在实际应用中，我们需要根据具体的需求选择合适的遍历方式，以达到最优的效果。

创建二叉树的三种算法1.递归算法递归算法是最直观也是最常用的创建二叉树的方法之一、递归算法通过递归地创建左子树和右子树来构建完整的二叉树。

具体步骤如下：-创建一个二叉树结构的定义，包含一个存储数据的变量和左右子节点。

-如果当前节点为空，直接将新节点插入当前位置。

-如果新节点的值小于当前节点的值，递归地将新节点插入当前节点的左子树。

-如果新节点的值大于等于当前节点的值，递归地将新节点插入当前节点的右子树。

递归算法的示例代码如下所示：```pythonclass TreeNode:def __init__(self, val):self.val = valself.left = Noneself.right = Nonedef insert(root, val):if root is None:return TreeNode(val)if val < root.val:root.left = insert(root.left, val)elif val >= root.val:root.right = insert(root.right, val)return root```2.先序遍历算法先序遍历算法通过遍历给定的节点集合，按照先序的顺序将节点逐个插入到二叉树中。

这种算法可以使用栈来实现。

具体步骤如下：-创建一个空栈，同时创建一个新节点的拷贝作为当前节点。

-依次遍历给定的节点集合，如果新节点的值小于当前节点的值，将当前节点的左子节点指向新节点，并将新节点入栈，并将新节点移动到当前节点的左子节点。

-如果新节点的值大于等于当前节点的值，重复上述过程，直到找到一个合适的位置并插入新节点。

-当遍历完所有节点后，返回二叉树的根节点。

先序遍历算法的示例代码如下所示：```pythonclass TreeNode:def __init__(self, val): self.val = valself.left = Noneself.right = Nonedef insert(root, val): if root is None:return TreeNode(val) stack = []cur = rootwhile True:if val < cur.val:if not cur.left:cur.left = TreeNode(val) breakelse:cur = cur.leftelse:if not cur.right:cur.right = TreeNode(val)breakelse:cur = cur.rightreturn root```3.层次遍历算法层次遍历算法通过逐层遍历给定的节点集合，按照从上到下、从左到右的顺序将节点逐个插入到二叉树中。

⼆叉树的四种遍历算法⼆叉树作为⼀种重要的数据结构，它的很多算法的思想在很多地⽅都⽤到了，⽐如STL算法模板，⾥⾯的优先队列、集合等等都⽤到了⼆叉树⾥⾯的思想，先从⼆叉树的遍历开始：看⼆叉树长什么样⼦：我们可以看到这颗⼆叉树⼀共有七个节点0号节点是根节点1号节点和2号节点是0号节点的⼦节点，1号节点为0号节点的左⼦节点，2号节点为0号节点的右⼦节点同时1号节点和2号节点⼜是3号节点、四号节点和五号节点、6号节点的双亲节点五号节点和6号节点没有⼦节点（⼦树），那么他们被称为‘叶⼦节点’这就是⼀些基本的概念⼆叉树的遍历⼆叉树常⽤的遍历⽅式有：前序遍历、中序遍历、后序遍历、层序遍历四种遍历⽅式，不同的遍历算法，其思想略有不同，我们来看⼀下这四种遍历⽅法主要的算法思想：1、先序遍历⼆叉树顺序：根节点 –> 左⼦树 –> 右⼦树，即先访问根节点，然后是左⼦树，最后是右⼦树。

上图中⼆叉树的前序遍历结果为：0 -> 1 -> 3 -> 4 -> 2 -> 5 -> 62、中序遍历⼆叉树顺序：左⼦树 –> 根节点 –> 右⼦树，即先访问左⼦树，然后是根节点，最后是右⼦树。

上图中⼆叉树的中序遍历结果为：3 -> 1 -> 4 -> 0 -> 5 -> 2 -> 63、后续遍历⼆叉树顺序：左⼦树 –> 右⼦树 –> 根节点，即先访问左⼦树，然后是右⼦树，最后是根节点。

上图中⼆叉树的后序遍历结果为：3 -> 4 -> 1 -> 5 -> 6 -> 2 -> 04、层序遍历⼆叉树顺序：从最顶层的节点开始，从左往右依次遍历，之后转到第⼆层，继续从左往右遍历，持续循环，直到所有节点都遍历完成上图中⼆叉树的层序遍历结果为：0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6下⾯是四种算法的伪代码：前序遍历：preOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在，那么结束cout << tree[n].w ; // 输出当前节点内容preOrderParse(tree[n].leftChild); // 递归输出左⼦树preOrderParse(tree[n].rightChild); // 递归输出右⼦树}中序遍历inOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在，那么结束inOrderParse(tree[n].leftChild); // 递归输出左⼦树cout << tree[n].w ; // 输出当前节点内容inOrderParse(tree[n].rightChild); // 递归输出右⼦树}pastOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在，那么结束pastOrderParse(tree[n].leftChild); // 递归输出左⼦树pastOrderParse(tree[n].rightChild); // 递归输出右⼦树cout << tree[n].w ; // 输出当前节点内容}可以看到前三种遍历都是直接通过递归来完成，⽤递归遍历⼆叉树简答⽅便⽽且好理解，接下来层序遍历就需要动点脑筋了，我们如何将⼆叉树⼀层⼀层的遍历输出？其实在这⾥我们要借助⼀种数据结构来完成：队列。

T->rchild= CreatBiTree(); /*构造右子树*/ 扩展先序遍历序列
}
2021/2/21
return (T) ;}
A B Φ D Φ Φ C Φ 17Φ
T
T
T
ch=B
ch=Φ
Λ
T
T= Λ, Creat(T)
ch=A T
A
B creat(T L)
ΛB 返回
creat(T L)
creat(T R)
A
p=p->RChild;
}
2021/2/21
}
top
A
B
C
D
top
B
top
A
A
top
D
A
top
A
top
C
13
top
中序遍历二叉树的非递归算法：
A
void InOrder(BiTree T)
{ InitStack(&S); 相当于top=-1;
p=T;
B
C
while(p!=NULL | | !IsEmpty(S)) 相当于top==-1;
}
后序遍历二叉树的递归算法：
void PostOrder (BiTree T)
{ if(T!=NULL)
{ PostOrder (T->lchild);
PostOrder (T->rchild);
printf(T->data); }
2021/2/21
15
}
先序遍历二叉树的递归算法： void PreOder (BiTree T) { if(T! =NULL){ printf (T->data); PreOrder (T->lchild); PreOrder (T->rchild); } }