遍历二叉树（先中后序递归与非递归，层次）

思路清晰，种类齐全，无法理解强记，

二叉树的遍历：

按某条搜索路径访问树中每个结点，使得每个结点均被访问一次，而且仅被访问一次。
要求理解记忆

先序遍历

如果二叉树为空，什么也不做，否则：
1、访问根结点
2、先序遍历左子树
3、先序遍历右子树
对应的递归算法如下：

void PreOrder(BiTree T)
{
if(T!=NULL)
{
visit(T);
PreOrder(T->lchild);
PreOrder(T->rchild);
}
}

上图先序访问次序
1，2，4，8，5，3，6，9，10，7

中序遍历

如果二叉树为空，什么也不做。否则：
1、中序遍历左子树。
2、访问根结点
3、中序遍历右子树
对应的递归算法如下：

    void InOrder(BiTree T)
    {
    if(T!=NULL)
    {
    PreOrder(T->lchild);
    visit(T);
    PreOrder(T->rchild);
    }
    }

上图中序遍历次序：4，8，2，5，1，9，6，10，3，7

后续遍历

如果二叉树为空，什么也不做，否则：
1、后序遍历左子树
2、后续遍历右子树
3、访问根结点
对应的递归算法如下：

    void PostOrder(BiTree T)
    {
    if(T!=NULL)
    {
    PreOrder(T->lchild);
    PreOrder(T->rchild);
    visit(T);
    }
    }

上图后序遍历次序：8，4，5，2，9，10，6，7，3，1

递归算法与非递归的转换

借助栈，将二叉树递归遍历算法转换为非递归的。

先序遍历：

思路1

先将根结点压入栈
如果栈不为空，循环执行以下三步：
1、访问栈顶元素并出栈
2、如果栈顶元素有右孩子结点，则将右孩子结点压入栈，没有不执行。
3、如果栈顶元素有左孩子结点，则将左孩子结点压入栈，没有不执行。
实现代码如下：

void preOrder(BiTree T)    //T是二叉树的根结点
{
if(T==NULL)   return;
InitStack(S);     //初始化一个栈
Push(S,T);       //将根结点压入栈中
while(S)
{
Pop(S,p);      //弹出栈顶元素，并用p返回 ,即p此时指向栈顶元素
visit(p);        //访问栈顶元素
if(p->rchild!=NULL)
Push(S,p->rchild);
if((p->lchild!=NULL)
Push(S,p->lchild);
}
}

思路2

当前结点指向二叉树根结点。
只要当前结点不为空或者栈不为空，循环执行以下两步：
1、当前结点不为空，访问当前结点并压入栈，指向当前结点的左孩子结点；
2、当前结点为空，出栈，并指向栈顶元素的右孩子结点。
实现代码如下：

       void preOrder(BiTree T)
        {
        InitStack(S);
        BiTree p=T;     //当前结点指向二叉树根结点
        while(p!=NULL||S!=NULL)
        {
        if(p!=NULL)
        {
        visit(p);
        Push(S,p);
        p=p->lchild;
        }else
        {
        Pop(S,p);   弹出栈顶元素，并用p返回 ,即p此时指向栈顶元素
        p=p->rchild;  //此时p指向栈顶元素的右孩子结点
        }
        }
        }

中序遍历

当前结点指向二叉树根结点。
只要当前结点不为空或者栈不为空，循环执行以下两步：
1、当前结点不为空，将当前结点压入栈，指向当前结点的左孩子结点；
2、当前结点为空，访问栈顶元素并出栈，指向栈顶元素的右孩子结点。
实现代码如下：

    void InOrder(BiTree T)
    {
    InitStack(S);
    BiTree p=T;
    while(p!=NULL||S!=NULL)
    {
    if(p!=NULL)
    {
    Push(S,p);
    p=p->lchild;
    }else
    {
    Pop(S,p);   弹出栈顶元素，并用p返回 ,即p此时指向栈顶元素
    visit(p);
    p=p->rchild;  //此时p指向栈顶元素的右孩子结点
    }
    }

后序遍历

较为复杂(如下述不能理解，不急，多搜、看几篇blog，每个人写法可能不同)
说明：对于一个结点是否能访问，要看它左右子树是否遍历完，如果是遍历完此结点的左子树回到此结点的，此结点标志为tag=1,此时这个结点不能被访问，如果是遍历完此结点的右子树回到此结点的，此结点标志为tag=2，表示能够访问该结点。
实现思路
只要当前结点不为空或者栈不为空，循环执行以下两大步：
1、当前结点p不为空，循环执行以下两步
1）将当前结点入栈并设当前结点标志位tag=1（实现方法代码一看就懂）
2）指向当前结点的左孩子结点。
2、当栈非空，执行以下步骤
栈顶元素的标志位tag=1时，当前结点指向栈顶元素的右孩子结点，栈顶元素标志tag改为2，
否则（栈顶元素的标志位tag=2时），出栈并访问栈顶元素。
实现代码如下：

   #define max 100
    void postOrder(BiTree T)
    {
    InitStack(S);
    BiTree p=T;    //当前结点
    BiTree x;  //出栈元素
    int top=-1;
    int tag[max];   //存储标记位，下标为top的值
    while(p||S)
    {
    while(p)
    {
    top++;
    Push(S,p);
    tag[top]=1;
    p=p->lchild;
    }
    if(S)
    {
    if(tag[top]==1)
    {
    p=S.top();   //p指向栈顶元素
    p=p->rchild;   //p指向栈顶元素的右孩子结点
    tag[top]=2;
    }
    else{
    Pop(S,x)
    visit(x);
    top–;
    }
    }  }  }

层次遍历二叉树

二叉树的层次遍历是指从根节点开始，沿着树的宽度一层一层向下遍历
如上图遍历结果：1，2，3，4，5，6，7，8，9，10
实现思路：
根结点入队
如果队列不为空，则执行以下3步循环：
1、将当前结点指向队头元素，访问当前结点，并将队头元素出队
2、如果当前结点左孩子结点不为空，则将左孩子结点入队
3、如果当前结点右孩子结点不为空，则将右孩子结点入队

      void LevelOrder(BiTree T)
        {
        InitQueue(Q);
        BiTree p;   //当前结点
        EnQueue（Q，T）；
        While(!isEmpty(Q))
        {
        DeQueue(Q,p);    出队列，并将队头元素赋予p
        visit(p);
        if(p->lchild!=NULL)
        EnQueue(Q,p->lchild);
        if(p->rchild!=NULL)
        EnQueue(Q,p->rchild);
        }
        }