二叉树遍历非递归算法

 输入代码：

#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
using namespace std;
typedef struct node
{
    ElemType data;
    struct node *lchild;
    struct node *rchild;
} BTNode;
/*
建立二叉树
*/
void CreateBTNode(BTNode *&b,char *str)
{
    BTNode *St[MaxSize],*p;
    int top=-1,k,j=0;
    char ch;
    b=NULL;
    ch=str[j];
    while(ch!='\0')
    {
        switch(ch)
        {
        case '(':
            top++;
            St[top]=p;
            k=1;
            break;
        case ')':
            top--;
            break;
        case ',':
            k=2;
            break;
        default:
            p=(BTNode *)malloc(sizeof(BTNode));
            p->data=ch;
            p->lchild=p->rchild=NULL;
            if(b==NULL)
                b=p;
            else
            {
                switch(k)
                {
                case 1:
                    St[top]->lchild=p;
                    break;
                case 2:
                    St[top]->rchild=p;
                    break;
                }
            }
        }
        j++;
        ch=str[j];
    }
}
void PreOrder1(BTNode *b)   //先序非递归遍历算法
{
    BTNode *St[MaxSize],*p;
    int top=-1;            //根节点进栈
    if(b!=NULL)
    {
        top++;
        St[top]=b;
        while(top>-1)    //栈不为空时进栈
        {
            p=St[top];    //退栈并访问该节点
            top--;
            printf("%c",p->data);
            if(p->rchild!=NULL)  //右孩子节点进栈
            {
                top++;
                St[top]=p->rchild;
            }
            if(p->lchild!=NULL)   //左孩子节点进栈
            {
                top++;
                St[top]=p->lchild;
            }
        }
        printf("\n");
    }
}
void InOrder(BTNode *b)   //中序遍历非递归算法
{
    BTNode *St[MaxSize],*p;
    int top=-1;
    if(b!=NULL)
    {
        p=b;
        while(top>-1||p!=NULL)   //处理*b节点的左子树
        {
            while(p!=NULL)     //扫描*p的所有左节点并进栈
            {
                top++;
                St[top]=p;
                p=p->lchild;
            }
            //执行到此处时，栈顶元素没有左孩子或左子树均已访问过
            if(top>-1)
            {
                p=St[top];   //出栈*p节点
                top--;
                printf("%c",p->data);   //访问之
                p=p->rchild;    //转向处理*p的右孩子节点
            }
        }
        printf("\n");
    }
}
void PostOrder(BTNode *b)   //后序遍历的非递归算法
{
    BTNode *St[MaxSize],*p;
    int top=-1,flag;
    if(b!=NULL)
    {
        do
        {
            while(b!=NULL)     //扫描*p的所有左节点并进栈
            {
                top++;
                St[top]=b;
                b=b->lchild;
            }
            //执行到此处时，栈顶元素没有左孩子或者左子树均已访问过
            p=NULL;        //p指向栈顶节点的前一个已访问过的节点
            flag=1;        //表示*b的左孩子已访问或为空
            while(top!=-1&&flag)
            {
                b=St[top];    //取出当前栈顶元素
                if(b->rchild==p)
                    /*
                    若*p=NULL，表示b的右孩子不存在，而其左子树不存在或已访问，可以访问*b；
                    若*p!=NULL，表示b的右子树已访问，可以访问*b。
                    */
                {
                     printf("%c",b->data);
                    top--;
                    p=b;
                }
                else
                {
                    b=b->rchild;
                    flag=0;
                }
            }
        }
        while(top!=-1);
         printf("\n");
    }
}
int main()
{
    BTNode *b;
    CreateBTNode(b,"A(B(D(,G)),C(E,F))");
    printf("先序遍历：");
    PreOrder1(b);
    printf("中序遍历：");
    InOrder(b);
    printf("后序遍历：");
    PostOrder(b);
    return 0;
}

运行截图：