5.3. 二叉树的遍历和线索二叉树
5.3.1_1 二叉树的先中后序遍历
遍历：按照某种次序把所有结点都访问一遍
二叉树的递归特性：
①要么是个空二叉树
②要么就是由“根节点+左子树+右子树”组成的二叉树
先序遍历：根左右（NLR）
中序遍历：左根右（LNR）
后序遍历：左右根（LRN）
先序遍历（PreOrder）的操作过程如下：
1. 若二叉树为空，则什么也不做；
2. 若二叉树非空：
①访问根结点；
②先序遍历左子树；
③先序遍历右子树。
代码实现如下：
typedef struct BiTNode{
ElemType data;
struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
// 先序遍历
void PreOrder(BiTree T){
if(T!=NULL){
visit(T); //访问根结点
PreOrder(T->lchild); //递归遍历左子树
PreOrder(T->rchild); //递归遍历右子树
}
}
先序遍历—第一次路过时访问结点，图示如下
中序遍历（InOrder）的操作过程如下：
1. 若二叉树为空，则什么也不做；
2. 若二叉树非空：
①中序遍历左子树；
②访问根结点；
③中序遍历右子树；
代码实现如下：
typedef struct BiTNode{
ElemType data;
struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
// 中序遍历
void PreOrder(BiTree T){
if(T!=NULL){
PreOrder(T->lchild); //递归遍历左子树
visit(T); //访问根结点
PreOrder(T->rchild); //递归遍历右子树
}
}
中序遍历—第二次路过时访问结点，图示如下
后序遍历（InOrder）的操作过程如下：
1. 若二叉树为空，则什么也不做；
2. 若二叉树非空：
①后序遍历左子树；
②后序遍历右子树；
③访问根结点。
代码实现如下：
typedef struct BiTNode{
ElemType data;
struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
// 后序遍历
void PreOrder(BiTree T){
if(T!=NULL){
PreOrder(T->lchild); //递归遍历左子树
PreOrder(T->rchild); //递归遍历右子树
visit(T); //访问根结点
}
}
后序遍历—第三次路过时访问结点 ，图示如下
// 应用：求树的深度
int treeDepth(BiTree T){
if(T == NULL){
return 0;
}else{
int l = treeDepth(T->lchild);
int r = treeDepth(T->rchild);
//树的深度=Max(左子树深度，右子树深度)+1
return l>r ? l+1 r+1;
}
}
5.3.1_2 二叉树的层次遍历
算法思想:
①初始化一个辅助队列
②根结点入队
③若队列非空，则队头结点出队，访问该结点，并将其左、右孩子插入队尾（如果有的话)
④重复③直至队列为空
代码实现：
// 二叉树结点(链式存储)
typedef struct BiTNode{
char data;
struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
// 链式队列结点
typedef struct LinkNode{
BiTNode *data; //存结点的指针而不是结点本身
struct LinkNode *next;
}LinkNode;
typedef struct{
LinkNode *front, *rear; //队头队尾
}LinkQueue;
// 层序遍历
void LevelOrder(BiTree T){
LinkQueue Q;
InitQueue(Q); //初始化辅助队列
BiTree p;
EnQueue(Q, T); //将根结点入队
while(!IsEmpty(Q)){ //队列不空则循环
DeQueue(Q, p); //队头结点出队
visit(p); //访问出队结点
if(p->lchild!=NULL)
EnQueue(Q, p->lchild); //左孩子入队
if(p->rchild!=NULL)
EnQueue(Q, p->rchild); //右孩子入队
}
}
5.3.1_3 由遍历序列构造二叉树
若只给出一棵二叉树的 前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树
一种遍历序列可能对应多种形态
前序 + 中序遍历序列
由前序遍历可推出根节点在中序遍历中的位置，从而确定左右结点，再依此类推
后序 + 中序遍历序列
由后序遍历可推出根结点在中序遍历中的位置，从而确定左右结点在中序遍历的位置
层序 + 中序遍历序列
由层序遍历可推出根结点，再根据根节点进一步确定左右的根的位置
5.3.2_1 线索二叉树的概念
普通二叉树进行遍历时，找前驱、后继很不方便，且每次都要从根结点出发，无法从一个指定的结点开始遍历。
n 个结点的二叉树，有 n+1 个空链域，可用来记录前驱、后继的信息。
指向前驱、后继的指针被称为“线索”，形成的二叉树就称为线索二叉树。
线索二叉树的存储
线索二叉树的结点在原本二叉树的基础上，新增了左右线索标志 tag。
tag == 0 时，表示指针指向孩子；tag == 1 时，表示指针是“线索”。
// 线索二叉树的结点
typedef struct ThreadNode{
ElemType data;
struct ThreadNode *lchild, *rchild;
int ltag, rtag; //左、右线索标志
}ThreadNode,*ThreadTree;
中序线索二叉树的存储
先序线索二叉树
5.3.2_2 二叉树的线索化
中序线索化
//线索二叉树结点
typedef struct ThreadNode{
ElemType data;
struct ThreadNode *lchild, *rchild;
int ltag, rtag; //左、右线索标志
}ThreadNode, *ThreadTree;
// 中序遍历二叉树，一边遍历一边线索化
void InThread(ThreadTree T) {
if (T != NULL) {
InThread(p->lchild); //中序遍历左子树
visit(T); //访问根结点
InThread(p->rchild); //中序遍历右子树
}
}
void visit(ThreadNode *q) {
if(q->lchild==NULL){ //左子树为空，建立前驱线索
q->lchild=pre; //
q->ltag=1; //修改ltag=1,只有变成1才表示指针是线索
}
if(pre!=NULL&&pre->rchild==NULL){
pre->rchild=q; //建立前驱结点的后继线索
pre->rtag=1;
}
pre=q;
}
//全局变量pre，指向当前访问结点的前驱
ThreadNode *pre=NULL; //pre没有前驱，最开始指向NULL
// 中序化线索二叉树T
void CreateInThread(ThreadTree T) {
pre = NULL; //pre初始化为NULL
if (T != NULL) { //非空二叉树才能线索化
InThread(T, pre); //中序化线索二叉树
if(pre->rchild = NULL)
pre->rtag = 1; //处理遍历的最后一个结点
}
}
先序线索化
// 先序遍历二叉树T
void PreThread(ThreadTree T) {
if (T != NULL) { //非空二叉树才能线索化
visit(T); //先处理根结点
if(T->ltag ==0) //lchild不是前驱线索
PreThread(T->child);
PreThread(T->child);
}
}
void visit(ThreadNode *q) {
if(q->lchild==NULL){ //左子树为空，建立前驱线索
q->lchild=pre; //
q->ltag=1; //修改ltag=1,只有变成1才表示指针是线索
}
if(pre!=NULL&&pre->rchild==NULL){
pre->rchild=q; //建立前驱结点的后继线索
pre->rtag=1;
}
pre=q;
}
//全局变量pre，指向当前访问结点的前驱
ThreadNode *pre=NULL; //pre没有前驱，最开始指向NULL
void CreateInThread(ThreadTree T) {
pre = NULL; //pre初始化为NULL
if (T != NULL) { //非空二叉树才能线索化
PreThread(T); //先序化线索二叉树
if(pre->rchild = NULL)
pre->rtag = 1; //处理遍历的最后一个结点
}
}
后序线索化
// 后序遍历二叉树T
void PostThread(ThreadTree T) {
if (T != NULL) { //非空二叉树才能线索化
PreThread(T->child); //后序遍历左子树
PreThread(T->child); //后序遍历右子树
visit(T); //访问根结点
}
}
void visit(ThreadNode *q) {
if(q->lchild==NULL){ //左子树为空，建立前驱线索
q->lchild=pre; //
q->ltag=1; //修改ltag=1,只有变成1才表示指针是线索
}
if(pre!=NULL&&pre->rchild==NULL){
pre->rchild=q; //建立前驱结点的后继线索
pre->rtag=1;
}
pre=q;
}
//全局变量pre，指向当前访问结点的前驱
ThreadNode *pre=NULL; //pre没有前驱，最开始指向NULL
//后续线索化二叉树T
void CreateInThread(ThreadTree T) {
pre = NULL; //pre初始化为NULL
if (T != NULL) { //非空二叉树才能线索化
PostThread(T); //后续线索化二叉树
if(pre->rchild = NULL)
pre->rtag = 1; //处理遍历的最后一个结点
}
}
5.3.2_3 在线索二叉树中找前驱后继
在中序线索二叉树中找到指定结点*p 的中序后继 next
①若 p->rtag==1，则 next = p->rchild
②若 p->rtag==0，则 next = p 的右子树中最左下结点
// 找到以p为根的子树中，第一个被中序遍历的结点
ThreadNode *FirstNode(ThreadNode *p){
// 循环找到最左下结点（不一定是叶结点）
while(p->ltag==0)
p=p->rchild;
return p;
}
// 在中序线索二叉树中找到结点p的后继结点
ThreadNode *NextNode(ThreadNode *p){
// 右子树中最左下的结点
if(p->rtag==0)
return FirstNode(p->lchild);
else
return p->rchild; //rtage==1直接返回后继线索
}
// 对中序线索二叉树进行中序循环（利用线索实现的非递归方法） 空间复杂度O(1)
void InOrder(ThreadNode *T){
for(ThreadNode *p=FirstNode(T); p!=NULL; p=NextNode(p))
visit(p);
}
在中序线索二叉树中找到指定结点*p 的中序前驱 pre
①若 p->ltag==1，则 pre = p->lchild
②若 p->ltag==0
// 找到以p为根的子树中，最后一个被中序遍历的结点
ThreadNode *LastNode(ThreadNode *p){
// 循环找到最右下结点（不一定是叶结点）
while(p->rtag==0)
p=p->rchild;
return p;
}
// 在中序线索二叉树中找到结点p的前驱结点
ThreadNode *PreNode(ThreadNode *p){
// 左子树中最右下的结点
if(p->ltag==0)
return LastNode(p->lchild);
else
return p->lchild; //ltage==1直接返回前驱线索
}
// 对中序线索二叉树进行中序循环（非递归方法实现）
void RevOrder(ThreadNode *T){
for(ThreadNode *p=LastNode(T); p!=NULL; p=PreNode(p))
visit(p);
}
在先序线索二叉树中找到指定结点*p 的先序后继 next
①若 p->rtag==1，则 next = p->rchild
②若 p->rtag==0
在先序线索二叉树中找到指定结点*p 的先序前驱 pre
①若 p->ltag==1，则 next = p->lchild
②若 p->ltag==0
在后序线索二叉树中找到指定结点*p 的后序前驱 pre
①若 p->ltag==1，则 pre = p->lchild
②若 p->ltag==0
在后序线索二叉树中找到指定结点*p 的后序后继 next
①若 p->rtag==1，则 next = p->rchild
②若 p->rtag==0
