复习：二叉树的遍历

二叉树的遍历操作

按照一定次序访问树中的所有节点，并且每个节点仅被访问一次的过程
二叉树的三种遍历
先序遍历：根节点–>左子树–>右子树
中序遍历：左子树–>根节点–>右子树
后序遍历：左子树–>右子树–>根节点

先序：ABDGCEF
中序：DGBAECF
后序：GDBEFCA

先序遍历的递归算法

（1）访问根节点
（2）先序遍历左子树
（3）先序遍历右子树

//先序遍历
void PreOrder(BTNode *b)
{
if(b!=NULL)
{
cout<data;
PreOrder(b->lchild);
PreOrder(b->rchild);

}

}

中序遍历

（1）中序遍历左子树
（2）访问根节点
（3）中序遍历右子树
//中序遍历
void InOrder(BTNode *b)
{
if(b!=NULL)
{
InOrder(b->lchild);
cout<data;
InOrder(b->rchild);

}

}

后序遍历

（1）后序遍历左子树
（2）后序遍历右子树
（3）访问根节点

//后序遍历
void PostOrder(BTNode *b)
{
if(b!=NULL)
{
PostOrder(b->lchild);
PostOrder(b->rchild);
cout<data;
}
}

计算二叉树节点的个数

计算二叉树b中所有节点个数 使用递归模型
F(b)= 0 b=NULL
F（b->lchild）+F（b->rchild）+1 其他情况

//计算二叉树节点
int Nodes(BTNode *b)
{
if(b==NULL)
return 0;
else
return Nodes(b->lchild)+Nodes(b->rchild)+1;
}

输出所有叶子节点

//输出所有叶子节点
void DispLeaf(BTNode *b)
{
if(b!=NULL)
{
if(b->lchild==NULL&&b->rchild==NULL)
cout<data;
else
{
DispLeaf(b->lchild);
DispLeaf(b->rchild);
}
}
}

输出节点所在层数

二叉树（没有值相同的节点）采用二叉链存储结构，返回二叉链中b中data值为x的节点层数
//输出节点所在层数
int Level(BTNode *b,ElemType x,int h) //h表示所指节点的层数 也就是b的层数
{
int I;

if(b==NULL)
    return 0;
else if(b->data==x)
    return h;
else
{
    I=Level(b->lchild,x,h+1);
    if(I==0)
        return Level(b->rchild,x,h+1);
    else
        return I;
} 

}

相似二叉树

//相似二叉树
int Like(BTNode *b1,BTNode *b2)
{
int like1,like2;
if(b1==NULL&&b2==NULL)
return 1;
else if(b1==NULL||b2==NULL)
return 0;
else
{
like1=Lke(b1->lchild,b2->lchild);
like2=Lke(b1->rchild,b2->rchild);
return (like1&like2);
}
}

层次遍历

逐层进行访问
对某层的节点访问完后，再按照其访问次序对各个节点的左右孩子顺序访问

算法实现：
//层次遍历
void LevelOrder(BTNode *b)
{
BTNode *p;
BTNode *qu[MaxSize];
int front,rear;
front=rear=-1;
rear++; //根节点入队
qu[i]=b;
while(front!=rear)
{
//从队列中出列一个节点*p，访问它 出队操作
front=(front+1)%MaxSize;
p=qu[front];
cout<data;
//若它有左孩子节点，将左孩子进队；
if(p->lchild!=NULL)
{
rear=(rear+1)%MaxSize;
qu=[rear]=p->lchild;

    } 
    //若它有右孩子节点，右孩子进队 
    if(p->rchild!=NULL)
    {
        rear=(rear+1)%MaxSize;
        qu[rear]=p->rchild;

    } 
}

}

//路径之逆
%%%