二叉树的建立和遍历（递归、非递归）

从二叉树的遍历的定义可知，3种遍历算法的不同之处在于访问根节点和左右子树的先后关系。如果在算法中暂时忽略访问根节点的printf语句，则3种遍历算法完全相同。因此，从递归执行的角度来看，先序、中序和后序遍历是完全相同的。上图中的用带箭头的虚线表示这3种遍历算法执行的过程。其中，向下的箭头表示更深一层的递归调用，向上的箭头表示从递归调用退出返回；虚线旁的三角形、圆形和方形内的字符分别表示先序、中序和后序遍历二叉树过程中访问节点时输出的信息。

# include<stdio.h>
# include<malloc.h>
# define MAX 100

//二叉树节点
typedef struct BiNode{
    char data;
    struct BiNode *lchild,*rchild;
}BiNode,*BiTree;

//栈
typedef struct{
    BiTree data[MAX];
    int top;
}Stack;

void createBiTree(BiTree &T);
void PreOrder(BiTree T);
void PreOrder2(BiTree T,Stack &s);
void InOrder(BiTree T);
void InOrder2(BiTree T,Stack &s);
void PostOrder(BiTree T);
void PostOrder2(BiTree T,Stack s1,Stack s2);
int getTop(Stack &s,BiTree &t);
void InitStack(Stack &s);
int isFull(Stack s);
int isEmpty(Stack s);
int Push(Stack &s,BiTree t);
int Pop(Stack &s);


int main()
{
    BiTree T=NULL;
    Stack s1,s2;
    InitStack(s1);
    InitStack(s2);
    printf("创建二叉树('#'代表空节点):");
    createBiTree(T);
    printf("\n先序遍历二叉树(递归):");
    PreOrder(T);
    printf("\n先序遍历二叉树(非递归):");
    PreOrder2(T,s1);
    printf("\n中序遍历二叉树(递归):");
    InOrder(T);
    printf("\n中序遍历二叉树(非递归):");
    InOrder2(T,s1);
    printf("\n后序遍历二叉树(递归):");
    PostOrder(T);
    printf("\n后序遍历二叉树(非递归):");
    PostOrder2(T,s1,s2);
    printf("\n");
    return 0;
}

//创建二叉树
void createBiTree(BiTree &T)
{
    char ch;
    scanf("%c",&ch);
    if(ch=='#')
    {
        T=NULL;
        return ;
    }
    else
    {
        T=(BiTree)malloc(sizeof(BiNode));
        T->data=ch;
        T->lchild=T->rchild=NULL;
        createBiTree(T->lchild);
        createBiTree(T->rchild);
    }
}

//先序遍历二叉树(递归)
void PreOrder(BiTree T)
{
    if(!T)
        return ;
    else
    {
        printf("%c ",T->data);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

//先序遍历二叉树（非递归）
void PreOrder2(BiTree T,Stack &s)
{
    if(!T)
        return ;
    BiTree p=NULL;
    InitStack(s);
    Push(s,T);
    while(!isEmpty(s))
    {
        //一直向左，直到遇到NULL
        while(getTop(s,p)&&p)
        {
            printf("%c ",p->data);
            Push(s,p->lchild);
        }
        Pop(s);//空指针退栈
        if(!isEmpty(s))
        {
            getTop(s,p);
            Pop(s);
            Push(s,p->rchild);
        }
    }
}

//中序遍历二叉树（递归）
void InOrder(BiTree T)
{
    if(!T)
        return ;
    else
    {
        InOrder(T->lchild);
        printf("%c ",T->data);
        InOrder(T->rchild);
    }
}

//中序遍历二叉树（非递归）
void InOrder2(BiTree T,Stack &s)
{
    if(!T)
        return ;
    BiTree p=NULL;
    InitStack(s);
    Push(s,T);
    while(!isEmpty(s))
    {
        while(getTop(s,p)&&p) Push(s,p->lchild);//一直向左走到尽头
        Pop(s);//空指针出栈
        if(!isEmpty(s))
        {
            getTop(s,p);
            printf("%c ",p->data);
            Pop(s);
            Push(s,p->rchild);
        }
    }
}
//后序二叉树遍历（递归）
void PostOrder(BiTree T)
{
    if(!T)
        return ;
    else
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        printf("%c ",T->data);
    }
}



//后序遍历二叉树（非递归）
void PostOrder2(BiTree T,Stack s1,Stack s2)
{
    if(!T)
        return ;
    BiTree p=NULL;
    InitStack(s1);
    InitStack(s2);
    Push(s1,T);
    //先按照‘根右左’的顺序遍历，s1作为该遍历顺序的辅助栈。逆过来，就是'左右根'。s1中先访问的节点先压入栈s2.
    while(!isEmpty(s1))
    {
        while(getTop(s1,p)&&p) 
        {
            Push(s2,p);
            Push(s1,p->rchild);//一直向右走，直到尽头
        }
        Pop(s1);//空指针出栈
        if(!isEmpty(s1))
        {
            getTop(s1,p);
            Pop(s1);
            Push(s1,p->lchild);
        }
    }
    //依次从s2栈顶弹出节点便是按照‘左右根’顺序遍历二叉树
    while(!isEmpty(s2))
    {
        getTop(s2,p);
        printf("%c ",p->data);
        Pop(s2);
    }
}

//初始化栈
void InitStack(Stack &s)
{
    s.top=0;
}

//判断栈是否满了，若是，则返回1，否则返回0.
int isFull(Stack s)
{
    if(s.top>=MAX)
        return 1;
    else
        return 0;
}

//判断栈是否为空，若是，返回1，否则返回0
int isEmpty(Stack s)
{
    if(s.top==0)
        return 1;
    else
        return 0;
}

//入栈，若成功，则返回1，否则返回0
int Push(Stack &s,BiTree t)
{
    if(isFull(s))
        return 0;
    else
    {
        s.data[s.top]=t;
        s.top++;
        return 1;
    }
}

//出栈，若出栈成功，则返回1，否则返回0
int Pop(Stack &s)
{
    if(isEmpty(s))
        return 0;
    else
    {
        s.top--;
        return 1;
    }
}

//获得栈顶元素，成功返回1，失败返回0
int getTop(Stack &s,BiTree &t)
{
    if(isEmpty(s))
        return 0;
    else
    {
        t=s.data[s.top-1];
        return 1;
    }
}