二叉树的遍历方法

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N 100

typedef char datatype;
void visit(datatype data);

typedef struct bnode
{
    datatype data;
    struct bnode *lchild, *rchild;
} BTNode, *BTree, **B_BTree;

typedef struct stack
{
    BTree node[N];
    //int tag[N];
    int top;
} Stack;

void push(Stack *s, BTree T)
{
    s->node[++s->top] = T;
}

BTree get_top(Stack *s)
{
    return s->node[s->top];
}

BTree pop(Stack *s)
{
    if(s->top != -1)
    {
        s->top--;
        return s->node[s->top + 1];
    }
    else
    {
        return NULL;
    }
}

void visit(datatype data)
{
    printf("%c", data);
}

void preorder(BTree T)
{
    if(T)
    {
        visit(T->data);
        preorder(T->lchild);
        preorder(T->rchild);
    }
}

void inorder(BTree T)
{
    if(T)
    {
        inorder(T->lchild);
        visit(T->data);
        inorder(T->rchild);
    }
}

void postorder(BTree T)
{
    if(T)
    {
        postorder(T->lchild);
        postorder(T->rchild);
        visit(T->data);
    }
}

void cur_preorder(BTree t)
{
    Stack s;
    BTree temp = t;
    s.top = -1;
    while(temp || s.top != -1)
    {
        while(temp)
        {
            visit(temp->data);
            push(&s, temp);
            temp = temp->lchild;
        }
        if(s.top > -1)
        {
            temp = pop(&s);
            temp = temp->rchild;
        }
    }
}

void cur_inorder(BTree t)
{
    Stack s;
    BTree temp = t;
    s.top = -1;
    while(temp || s.top != -1)
    {
        while(temp)
        {
            push(&s, temp);
            temp = temp->lchild;
        }
        if(s.top > -1)
        {
            temp = pop(&s);
            visit(temp->data);
            temp = temp->rchild;
        }
    }
}

void cur_postorder(BTree t)
{
    Stack s;
    BTree temp, pre = NULL;
    temp = t;
    s.top = -1;
    while(temp || s.top != -1)
    {
        while(temp)
        {
            push(&s, temp);
            temp = temp->lchild;
        }
        temp = get_top(&s);
        if(temp->rchild == NULL
           || temp->rchild == pre)
           {
               visit(temp->data);
               pre = temp;
               temp = NULL;
               pop(&s);
           }
           else
           {
               temp = temp->rchild;
           }
    }
}

/*层次遍历*/
typedef struct
{
    BTree node[N];
    int front;
    int rear;
}   queue;

void init_queue(queue *Q)
{
    Q->front = Q->rear = 0;
}

void en_queue(queue *Q, BTree e)
{
    Q->node[Q->rear] = e;
    Q->rear = (Q->rear + 1) % N;
}

void de_queue(queue *Q, B_BTree e)
{
    *e = Q->node[Q->front];
    Q->front = (Q->front + 1) % N;
}

int is_empty(queue *Q)
{
    return Q->rear == Q->front;
}

void level_order(BTree t)
{
    queue Q;
    init_queue(&Q);
    BTree p = t;
    if(p)
    {
        en_queue(&Q, p);
        while(!is_empty(&Q))
        {
            de_queue(&Q, &p);
            visit(p->data);
            if(p->lchild)
            {
                en_queue(&Q, p->lchild);
            }
            if(p->rchild)
            {
                en_queue(&Q, p->rchild);
            }
        }
    }
}

void create_tree(B_BTree T)
{
    char temp;
    temp = getchar();
    if(temp == ' ')
    {
        *T = NULL;
    }
    else
    {
        (*T) = (BTNode *)malloc(sizeof(BTNode));
        (*T)->data = temp;
        create_tree(&(*T)->lchild);
        create_tree(&(*T)->rchild);
    }
}

int main()
{
    BTree T;
    printf("请按次数顺序输入字符：\n");
    create_tree(&T);
    preorder(T);
    printf("\n");
    cur_preorder(T);
    printf("\n");
    inorder(T);
    printf("\n");
    cur_inorder(T);
    printf("\n");
    postorder(T);
    printf("\n");
    cur_postorder(T);
    printf("\n");
    level_order(T);
    printf("\n");
    return 0;
}