二叉树相关上机实验

#include<stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define MAXNUM 20
typedef int Status;
typedef struct bnode
{
    int data;
    struct bnode *lchild,*rchild;
}bnode_type,*blink;
typedef struct Stack
{
    blink data[MAXNUM];
    int top;
}Stack;
Status create(blink &root);
void preorder_1(blink root);
void inorder_1(blink root);
void postorder_1(blink root);
void preorder_2(blink root);
void inorder_2(blink root);
void postorder_2(blink root);
void create_stack(Stack &S);
Status empty(Stack S);
void push(Stack &S, blink BTN);
blink pop(Stack &S);
int treelen(blink tree);
int leaves(blink tree);
int nodes(blink root);
int main()
{
    blink mytree;
    create(mytree);
    printf("\npreorder:\n");
    preorder_1(mytree);
    printf("\ninorder:\n");
    inorder_1(mytree);
    printf("\npostorder:\n");
    postorder_1(mytree);    
    printf("\n----------------\n");
    printf("\npreorder:\n");
    preorder_2(mytree);
    printf("\ninorder:\n");
    inorder_2(mytree);
    printf("\npostorder:\n");
    postorder_2(mytree);    
    printf("\n----------------\n");
    printf("the depth of this tree is: %d",treelen(mytree));
    printf("\nthere are %d leaves in this tree",leaves(mytree));
    printf("\nthere are %d nodes in this tree",nodes(mytree));
}
Status create(blink &root)
{
    blink p,q;
    int k;
    int i,n;
    root=NULL;
    printf("input n:");
    scanf("%d",&n);
    if(n<=0)
    {
        printf("invalid input");
        return ERROR;
    }
    for(i=0;i<n;i++)
    {
        p=(blink)malloc(sizeof(bnode_type));
        p->lchild=NULL;
        p->rchild=NULL;
        printf("input k:");
        scanf("%d",&k);
        p->data=k;
        if(root==NULL)
            root=p;
        else
        {
            q=root;
            while(q!=NULL)
            {
                if(q->data>k)
                {
                    if(q->lchild!=NULL)
                        q=q->lchild;
                    else
                    {
                        q->lchild=p;
                        q=NULL;
                    }
                }
                else
                {
                    if(q->rchild!=NULL)
                        q=q->rchild;
                    else
                    {
                        q->rchild=p;
                        q=NULL;
                    }
                }
            }
        } 
    }
    return OK;    
}
void preorder_1(blink root)
{
    printf("%d ",root->data);
    if(root->lchild!=NULL)
        preorder_1(root->lchild);
    if(root->rchild!=NULL)
        preorder_1(root->rchild);
}
void inorder_1(blink root)
{
    if(root->lchild!=NULL)
        inorder_1(root->lchild);
    printf("%d ",root->data);
    if(root->rchild!=NULL)
        inorder_1(root->rchild);
}
void postorder_1(blink root)
{
    if(root->lchild!=NULL)
        postorder_1(root->lchild);
    if(root->rchild!=NULL)
        postorder_1(root->rchild);
    printf("%d ",root->data);
}
void create_stack(Stack &S)
{
    S.top=0;
}
Status empty(Stack S)
{
    if(S.top==0)
        return OK;
    else
        return ERROR;
}
void push(Stack &S, blink BTN)
{
    S.data[S.top]=BTN;
    S.top++;
}
blink pop(Stack &S)
{
    S.top--;
    return(S.data[S.top]);
}
void preorder_2(blink root)
{
    blink p;
    Stack sta;
    create_stack(sta);
    p=root;
    while(p!=NULL||!empty(sta))    
    {
        if(p!=NULL)
        {
            printf("%d ",p->data);
            push(sta,p);
            p=p->lchild;
        }
        else
        {
            p=pop(sta);
            p=p->rchild;
        }
    }
}
void inorder_2(blink root)
{
    blink p;
    Stack sta;
    create_stack(sta);
    p=root;
    while(p!=NULL||!empty(sta))    
    {
        if(p!=NULL)
        {
            push(sta,p);
            p=p->lchild;
        }
        else
        {
            p=pop(sta);
            printf("%d ",p->data);
            p=p->rchild;
        }
    }    
}
void postorder_2(blink root)
{
    blink p;
    Stack sta1,sta2;
    create_stack(sta1);
    create_stack(sta2);
    if(root!=NULL)
    {
        push(sta1,root);
    }
    while(!empty(sta1))    
    {
        p=pop(sta1);
        push(sta2,p);
        if(p->lchild!=NULL)
        {
            push(sta1,p->lchild);
        }
        if(p->rchild!=NULL)
        {
            push(sta1,p->rchild);
        }
    }
    while(!empty(sta2))
    {
        p=pop(sta2);
        printf("%d ",p->data);
    }        
}
int leaves(blink root)
{
    int n=0;
    blink p;
    Stack sta;
    create_stack(sta);
    p=root;
    while(p!=NULL||!empty(sta))    
    {
        if(p!=NULL)
        {
            if(p->lchild==NULL && p->rchild==NULL)
            {
                n++;
            }
            push(sta,p);
            p=p->lchild;
        }
        else
        {
            p=pop(sta);
            p=p->rchild;
        }
    }
    return n;
}
int treelen(blink root)
{
    blink p=root;
    int n=0,l=0,r=0;
    if(p==NULL)
    {
        return 0;
    }
    if(p->lchild)
    {
        l=treelen(p->lchild);
    }
    if(p->rchild)
    {
        r=treelen(p->rchild);
    }
    n=(l>r)?l:r;
    return (n+1);
}
int nodes(blink root)
{
    int n=0;
    blink p;
    Stack sta;
    create_stack(sta);
    p=root;
    while(p!=NULL||!empty(sta))    
    {
        if(p!=NULL)
        {
            n++;
            push(sta,p);
            p=p->lchild;
        }
        else
        {
            p=pop(sta);
            p=p->rchild;
        }
    }
    return n;
}

非递归的后序遍历用了两个栈 应该还有其他的方法