二叉树的创建、前中后序遍历（递归和非递归）C语言实现

直接上代码：

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50
typedef struct BiTNode  //二叉树节点
{
    int data;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

typedef struct SqStack  //顺序栈
{
    BiTree data[MaxSize];
    int top;
}SqStack;

//顺序栈的相关操作
void InitStack(SqStack &);
bool Push(SqStack &,BiTree);
bool Pop(SqStack &,BiTree&);
bool IsEmpty(SqStack);

//树的相关操作
void InitTree(BiTree &); //初始化
void Visit(BiTree); //访问节点数据
void PreOrder(BiTree); //递归先序遍历
void InOrder(BiTree); //递归中序遍历
void PostOrder(BiTree); //递归后续遍历
void InOrder2(BiTree);//非递归中序遍历
void PreOrder2(BiTree);//非递归先序遍历

int main()
{
    BiTree T;   //二叉树根结点
    InitTree(T); //初始化二叉树

    printf("preorder:");
    PreOrder(T); //先序遍历

    printf("inorder:");
    InOrder(T); //中序遍历

    printf("postorder:");
    PostOrder(T);   //后续遍历

    printf("非递归中序遍历:");
    InOrder2(T);

    printf("非递归先序遍历:");
    PreOrder2(T);

    system("pause");
    return 0;
}

//按照先序遍历初始化二叉树
void InitTree(BiTree &T){  
    int data ;
    scanf("%d", &data); //输入0代表子树为NULL
    if (data!=0){
        T = (BiTNode*)malloc(sizeof(BiTNode));
        T->lchild = NULL;
        T->rchild = NULL;
        T->data = data;
        InitTree(T->lchild);
        InitTree(T->rchild);
    }
    return;
}
//访问存储的元素
void Visit(BiTree T) {
    printf(" %d ", T->data);
}
//递归先序遍历
void PreOrder(BiTree T)
{
    if (T != NULL){
        Visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}
//递归中序遍历
void InOrder(BiTree T)
{
    if (T != NULL){
        InOrder(T->lchild);
        Visit(T);
        InOrder(T->rchild);
    }
}
//递归后续遍历
void PostOrder(BiTree T) {
    if (T != NULL)
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        Visit(T);
    }
}
//非递归先序遍历
void PreOrder2(BiTree T) {
    if (T!=NULL){
        SqStack S;
        InitStack(S);
        BiTree p = T;
        while (p!=NULL || !IsEmpty(S)){
            while (p != NULL){
                Visit(p);
                Push(S, p);
                p = p->lchild;
            }
            if (!IsEmpty(S)){
                Pop(S, p);
                p = p->rchild;
            }
        }
    }
}
//非递归中序遍历
void InOrder2(BiTree T) {
    if (T!=NULL)
    {
        SqStack S;
        InitStack(S);
        BiTree p = T;
        while (p!= NULL || !IsEmpty(S))
        {
            while(p!=NULL)
            {
                Push(S, p);
                p = p->lchild; //向左访问
            }
            if (!IsEmpty(S))   //访问到最左之后
            {
                Pop(S, p);  //最左开始出栈
                Visit(p);   //访问最左元素
                p = p->rchild;//之后访问最左元素右子树
            }
        }
    }
}
void InitStack(SqStack &S) {
    S.top = -1;
}
bool IsEmpty(SqStack S) {
    return (S.top == -1) ? true : false;
}
bool Push(SqStack &S,BiTree data) {
    if (S.top == MaxSize-1) //栈满
        return false;
    S.data[++S.top] = data;
    return true;
}
bool Pop(SqStack &S, BiTree &data)
{
    if (S.top == -1)    //栈空
        return false;
    data = S.data[S.top--];
    return true;
}