#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define maxsize 20
typedef struct bi{
    int data;
    struct bi * left,* right;
} bi_node ,*bi_tree;
void init_bitree(bi_tree  & t){
    t=NULL;
}
void creat_bitree(bi_tree & t){
    int a;
    scanf("%d",&a);
    if(a==0){
        t=NULL;
    }
    
       
else
{   if(!(t=(bi_tree) malloc(sizeof(bi_node)))) exit(1);

    t->data=a;
    creat_bitree(t->left);
    creat_bitree(t->right);
}
}



//stack test 
//静态栈
typedef bi_tree datatype;
typedef struct stack_node{
    datatype *top;
    datatype *base;
} stack;
void init_stack(stack &s){
    s.base=(datatype *)malloc(maxsize*sizeof(datatype));
    if(!s.base){
        printf("error init_stack");
        exit(1);
    }
    else
    {
        s.top=s.base;
    }
}
void clear_stack(stack & s){
    s.top=s.base;
}
void destroy_stack(stack & s){
    s.base=NULL;
    s.top=NULL;
}
bool is_empty_stack(stack s){
    return (s.top==s.base);
}
bool is_full_stack(stack s){
    return (s.top>=s.base+maxsize);
}
void push(stack & s,datatype e){
    if(is_full_stack(s)){
        printf(" this stack is full");
        exit(1);
    }
    else
    {
        *(s.top++)=e;
    }
}
void pop(stack &s,datatype & e){
    if(is_empty_stack(s)){
        printf("this stack is empty");
        exit(1);
    }
    else
    {
        e=*(--s.top);
    }
}
void print(stack s){
    datatype * x;
    x=s.top;
    do{
        printf("%4d",*(--x));
    }while(x!=s.base);
    printf("\n");
}
void get_top_stack(stack s, datatype & e){
    if(is_empty_stack(s)){
        printf("error get_top_stack");
        exit(1);
    }
    else
    {
        e=*(s.top-1);
    }
}



//先序遍历
void pre(bi_tree t){
        
    stack s;
    init_stack(s);
    bi_tree mid;
    if(t){
        printf("%4d",t->data);
        push(s,t);
    while(!is_empty_stack(s)){
            get_top_stack(s,mid);
        
        //    printf("%4d",mid->data);
            while(mid->left){
             printf("%4d",mid->left->data);
                push(s,mid->left);
                get_top_stack(s,mid);
            }
            // printf("%4d",mid->data);
             pop(s,mid);
             if(s.top!=s.base)
             (*(s.top-1))->left=NULL;
             if(mid->right)
             {   
                 printf("%4d",mid->right->data);
                 push(s,mid->right);
             }
             
    

    }


    }
    destroy_stack(s);
}
void in(bi_tree t){

        stack s;
        datatype mid;
        init_stack(s);
        push(s,t);
        while(!is_empty_stack(s)){
        get_top_stack(s,mid);
        while( mid){
            push(s,mid->left);
            get_top_stack(s,mid);}
        pop(s,mid);
        if(!is_empty_stack(s)){
            pop(s,mid);
            printf("%4d",mid->data);
            push(s,mid->right);
        }
}
        destroy_stack(s);
}
void post(bi_tree t){
        stack s;
         bi_tree mid;
        init_stack(s);
         push(s,t);
        while(!is_empty_stack(s) ){
            
            get_top_stack(s,mid);
            while(mid){
                push(s,mid->left);
                get_top_stack(s,mid);
            
        }
        pop(s,mid);//退出没有用的节点
        
        if  (!is_empty_stack(s)){
            get_top_stack(s,mid);
        if(mid->right){
            push(s,mid->right);
            if(mid->right->left==NULL && mid->right->right==NULL)
            {
                pop(s,mid);
                printf("%4d",mid->data);
                (*(s.top-1))->right=NULL;
            }

        }
        else
        {   //bi_tree mid1;
            pop(s,mid);
            printf("%4d",mid->data);
        //    get_top_stack(s,mid1);
            if(s.top!=s.base){
                if((*(s.top-1))->right && (*(s.top-1))->right->data==mid->data)
                
                    (*(s.top-1))->right=NULL;
                 else
                (*(s.top-1))->left=NULL;
        }
        
        }
        
        }
        }
        destroy_stack(s);
}

void main(){
    bi_tree t;
    init_bitree(t);
    creat_bitree(t);
    printf("先序遍历：");
    preorder(t);
    printf("\n");
    printf("中序遍历：");
    inorder(t);
    printf("\n");
    printf("后序遍历：");
    postorder(t);
    printf("\n");
    printf("先序遍历：");
    pre(t);
    printf("\n");
    printf("中序遍历：");
    in(t);
    printf("\n");
    printf("后序遍历：");
    post(t);
    printf("\n");
}
为什么在非递归遍历时，如果不执行非递归前序遍历时，中序与后序正确，但是如果执行前序时，后序遍历，中序遍历就遍历不完全了？请问高手是什么原因！谢谢