二叉树的非递归遍历与层次遍历

二叉树的递归遍历很好写，也很好理解。但因为是递归程序，不可避免地需要调用系统栈，耗时较长，这里我们来探究一下二叉树的非递归遍历的算法。这种方法需要使用栈这种数据结构，这里关于栈的一些操作函数可以看成伪代码吧，先给出线序、中序、后序遍历的代码即说明。

先序遍历：

void PreOrderTraverse(BinTree b)
{
    InitStack(S);///初始化创建栈
    BinTree p=b;///p为工作指针
    while(p||!isEmpty(s))
    {
        while(p)///到最左下的孩子
        {
            printf(" %c ",p->date);///先序先遍历结点
            Push(S,p);///入栈
            p=p->lchild;
        }
        if(!isEmpty(s))///在栈不为空的情况下，左孩子为空，弹出该结点，遍历右孩子
        {
            p=Pop(s);
            p=p->rchild;
        }
    }
}

 再给出使用数组模拟的函数

void Preorder_n(BiTree bt)  /*先序遍历的非递归算法*/
{
    BiTree stack[MAX],p;
    int top=0,i;
    for(i=0; i<MAX; i++)
    {
        stack[i]=NULL; /*初始化栈*/
    }
    p=bt;
    do
    {
        while(p)
        {
             printf("%c",p->data);
             stack[top++]=p;
             p=p->lchild;
        }
        if(top!=0)
        {
            p=stack[top-1];//去栈底
            top--;//出栈
            p=p->rchild;
        }
    }while(top!=0||p!=NULL);
}

中序遍历：

void InOrderTraverse(BinTree b)
{
    InitStack(S);///初始化创建栈
    BinTree p=b;///p为工作指针
    while(p||!isEmpty(s))
    {
        while(p)
        {
            Push(S,p);///中序现将结点进栈保存
            p=p->lchild;
        }///遍历到左下角尽头再出栈访问
        if(!isEmpty(s))///在栈不为空的情况下，左孩子为空，弹出该结点，遍历右孩子
        {
            p=Pop(s);
            printf(" %c ",p->data);
            p=p->rchild;///遍历右孩子
        }
    }
}

 再给出使用数组模拟的函数

void InOrder_n(BiTree bt)  /*中序遍历的非递归算法*/
{
    BiTree stack[MAX],p;
    int top=0,i;
    for(i=0; i<MAX; i++)
    {
        stack[i]=NULL; /*初始化栈*/
    }
    p=bt;
    do
    {
        while(p)//顺着左链走到尽头
        {
            stack[top++]=p;
            p=p->lchild;
        }
        if(top>0)
        {
            p=stack[top-1];
            printf("%c",stack[top-1]->data);
            top--;
            p=p->rchild;
        }
    }while(top!=0||p);
}

后序遍历：后序遍历较前两种遍历方法比较难实现，原因在于需要遍历完左子树，遍历完右子树，最后才去访问根节点。这样栈顶结点可能会从他的左子树返回，也有可能从他的右子树返回，需要区分这种情况，如果是第一次从左子树返回，那么还需要去遍历其右子树，如果是从右子树返回，那么直接返回该结点就可以了。这里使用辅助指针来区分来源。

void PostOrderTraverse(BinTree b)
{
    InitStack(S);///初始化创建栈
    BinTree p=b, r=NULL;///p为工作指针,辅助指针r
    while(p||!isEmpty(s))
    {
        if(p)///从根节点到最左下角的左子树都入栈
        {
            Push(S,p);///中序现将结点进栈保存
            p=p->lchild;
        }
        else
        {
            GetTop(S,p);///取栈顶，注意！不是出栈！
            if(p->rchild&&p->rchild!=r)///1.右子树还没有访问并且右子树不空，第一次栈顶
            {
                p=p->rchild;///进入右子树
            }
            else///右子树已经访问或为空，接下来出栈访问结点，第二次栈顶
            {
                p=Pop(s);
                printf(" %c ",p->data);
                r=p;///指向访问过的右子树结点
                p=NULL;///使p为空继续访问栈顶
            }
        }
    }
}

 数组模拟：

void PostOrder_n(BiTree bt)
{
    BiTree stack[MAX],p,r;
    int top=0,i;
    for(i=0; i<MAX; i++)
    {
        stack[i]=NULL; /*初始化栈*/
    }
    p=bt, r=NULL;///p为工作指针,辅助指针r
    do
    {
        if(p)///从根节点到最左下角的左子树都入栈
        {
            stack[top++]=p;///中序现将结点进栈保存
            p=p->lchild;
        }
        else
        {
            p=stack[top-1];///取栈顶，注意！不是出栈！
            if(p->rchild&&p->rchild!=r)///1.右子树还没有访问并且右子树不空，第一次栈顶
            {
                p=p->rchild;///进入右子树
            }
            else///右子树已经访问或为空，接下来出栈访问结点，第二次栈顶
            {
                top--;
                printf("%c",p->data);
                r=p;///指向访问过的右子树结点
                p=NULL;///使p为空继续访问栈顶
            }
        }
    } while(p||top!=0);
}

层次遍历：

从二叉树的第一层（根节点）开始，从上至下逐层遍历，在每一层中又按照从左到右的顺序对结点逐个遍历。我们可以看出如果某个结点比同一层的先遍历，其孩子也将比其同层的孩子结点先遍历，这种先进先出的方式，不就是队列这种数据结构吗？

void LevelOrder(BiTree b)
{
    InitQueue(Q);///初始化建立队列
    BinTree p;
    EnQueue(Q,b);///根节点入队
    while(!isEmpty(Q))///队列不空循环
    {
        DeQueue(Q,p);///队头元素出队
        printf(" %c ",p->data);
        ///左右孩子入队
        if(p->lchild!=NULL)
        {
            EnQueue(Q,p->lchild);
        }
        if(p->rchild!=NULL)
        {
            EnQueue(Q,p->rchild);
        }
    }
}

 使用C++ STL库 queue 的函数：

void LevelOrder(BiTree p)
{
    queue<BiTree>Q;//使用C++ STL库
    Q.push(p);//根节点入队
    while(!Q.empty())//队列不空循环
    {
        p=Q.front();//取对头
        printf("%c",p->data);//左右孩子入队
        if(p->lchild!=NULL)
        {
            Q.push(p->lchild);
        }
        if(p->rchild!=NULL)
        {
            Q.push(p->rchild);
        }
        Q.pop();//队头元素出队
    }
    printf("
");
}