C语言创建二叉树数据结构, 以及各种遍历

　　RT,上数据结构课时写的, 注释后面再补上.
　　上课时, 听得不是很认真, 先放在这里, 等后面再来慢慢理解.
　　使用时, 首先会创建根结点, 依次创建左孩子, 左孩子.
　　输入0表示该结点为空.
　　创建左/右孩子的时候, 又把左/右孩子当作根结点, 递归创建属于它们的左右孩子.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct BiTree{
    int data;
    struct BiTree* lchild;
    struct BiTree* rchild;
}BiTree, *PBiTree;

typedef struct Stack{
    BiTree* data[128];
    int top;
}Stack;

void stack_init(Stack* pStack)
{
    memset(pStack, 0, sizeof(Stack));
    pStack->top = -1;
}

BiTree* stack_pop(Stack* pStack)
{
    if(pStack->top == -1)
        return NULL;
    return pStack->data[pStack->top--];
}

BiTree* stack_get_top(Stack* pStack)
{
    if(pStack->top == -1)
        return NULL;
    else
        return pStack->data[pStack->top];
}

int stack_push(Stack* pStack, BiTree* pBiTree)
{
    if(pStack->top == 127)
        return 0;
    pStack->data[++pStack->top] = pBiTree;
    return 1;
}

int stack_is_empty(Stack* pStack)
{
    return pStack->top == -1;
}

int bitree_create(BiTree** ppBiTree)
{
    int data;
    for(;;){
        printf("输入节点的值:");
        if(scanf("%d", &data) == 1)
            break;
        fflush(stdin);
    }
    if(data == 0){
        (*ppBiTree) = NULL;
        return 1;
    }else{
        (*ppBiTree) = (PBiTree)malloc(sizeof(BiTree));
        if(!*ppBiTree){
            perror("内存分配失败");
            return 0;
        }else{
            memset(*ppBiTree, 0, sizeof(BiTree));
            (*ppBiTree)->data = data;
            bitree_create(&(*ppBiTree)->lchild);
            bitree_create(&(*ppBiTree)->rchild);
        }
    }
    return 1;
}

//释放二叉树
void bitree_free(BiTree* pBiTree)
{
    if(pBiTree){
        bitree_free(pBiTree->lchild);
        bitree_free(pBiTree->rchild);
        free(pBiTree);
        pBiTree = NULL;
    }
}

/*先序遍历非递归算法*/
void PreOrderTraverse(BiTree* pBiTree)
{
    Stack stk;
    BiTree* pb = pBiTree;
    stack_init(&stk);
    while(pb || !stack_is_empty(&stk)){
        while(pb){
            printf("%d ", pb->data);
            stack_push(&stk, pb);
            pb = pb->lchild;
        }
        pb = stack_pop(&stk);   
        pb = pb->rchild;
    }
}
/*先序遍历递归算法*/
void PreOrderTraverse2(BiTree* pBiTree)
{
    if(pBiTree){
        printf("%d ", pBiTree->data);//显示数据
        PreOrderTraverse2(pBiTree->lchild);//访问左孩子
        PreOrderTraverse2(pBiTree->rchild);//访问右孩子
    }
}

/* 中序遍历递归算法 */
void InOrderTraverse2(BiTree* pBiTree)
{
    if(pBiTree){
        InOrderTraverse2(pBiTree->lchild);
        printf("%d ", pBiTree->data);
        InOrderTraverse2(pBiTree->rchild);
    }
}

/* 中序遍历递归算法2 */
void InOrderTraverse3(BiTree* pBiTree)
{
    Stack stk;
    BiTree* pb = NULL;
    stack_init(&stk);
    pb = pBiTree;
    while(pb || !stack_is_empty(&stk)){
        if(pb){
            stack_push(&stk, pb);//根指针进栈
            pb = pb->lchild;//遍历左子树
        }else{
            //根指针出栈, 访问根结点, 遍历右子树
            pb = stack_pop(&stk);
            printf("%d ", pb->data);
            pb = pb->rchild;
        }
    }
}

/* 中序遍历非递归算法 */
void InOrderTraverse(BiTree* pBiTree)
{
    Stack stk;
    BiTree* pb = NULL;
    stack_init(&stk);//保存结点的栈
    stack_push(&stk, pBiTree);//根指针进栈
    while(!stack_is_empty(&stk)){
        while((pb=stack_get_top(&stk)))
            stack_push(&stk, pb->lchild);//向左走到尽头
        pb = stack_pop(&stk);//最后一个空指针出栈
        if(!stack_is_empty(&stk)){
            pb = stack_pop(&stk);//得到最后一个结点/左孩子
            printf("%d ", pb->data);
            stack_push(&stk, pb->rchild);//访问右孩子
        }
    }
}

/* 后序遍历非递归算法 */
void PostOrderTraverse(BiTree* pBiTree)
{
    Stack stk;
    BiTree* pb = NULL;
    BiTree* pre = NULL;
    stack_init(&stk);
    while(pBiTree || !stack_is_empty(&stk)){
        while(pBiTree){
            stack_push(&stk, pBiTree);
            pBiTree = pBiTree->lchild;
        }
        pBiTree = stack_get_top(&stk);
        if(!pBiTree->rchild || pBiTree->rchild == pre){
            printf("%d ", pBiTree->data);
            stack_pop(&stk);
            pre = pBiTree;
            pBiTree = NULL;
        }else{
            pBiTree = pBiTree->rchild;
        }
    }
}

/* 后序遍历递归算法 */
void PostOrderTraverse2(BiTree* pBiTree)
{
    if(pBiTree){
        PostOrderTraverse(pBiTree->lchild);
        PostOrderTraverse(pBiTree->rchild);
        printf("%d ", pBiTree->data);
    }
}


int main(void)
{
    BiTree* pbt = NULL;
    bitree_create(&pbt);
    printf("\n");
    printf("先序遍历非递归算法:\t");
    PreOrderTraverse(pbt);
    printf("\n");
    printf("先序遍历递归算法:\t");
    PreOrderTraverse2(pbt);
    printf("\n");
    printf("中序遍历非递归算法:\t");
    InOrderTraverse(pbt);
    printf("\n");
    printf("中序遍历递归算法:\t");
    InOrderTraverse2(pbt);
    printf("\n");
    //printf("中序遍历递归算法2:\t");
    //InOrderTraverse3(pbt);
    //printf("\n");
    printf("后序遍历非递归算法:\t");
    PostOrderTraverse(pbt);
    printf("\n");
    printf("后序遍历递归算法:\t");
    PostOrderTraverse2(pbt);
    printf("\n");
    printf("\n");
    bitree_free(pbt);
    system("pause");
    return 0;
}