递归和非递归的前序、中序、后序遍历以及层次遍历

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

typedef struct Tree{
    int date;
    struct Tree *lchild;
    struct Tree *rchild; 
}Tree,*BitTree;
//tree类型的别名 
 
//队列 
typedef struct queue{
    Tree arr[50];//定义一个结构体数组 
    int front,rear; //定义前后指针 
}Queue;


 
BitTree CreateLink()
{
    int date;
    int temp;
                //    定义一个指向结构体Tree的指针类型 
    BitTree T;
    
    scanf("%d",&date); //输入数据
    temp=getchar(); //吸收空格
    
    if(date == -1)
    {
        return NULL;
    }else{
        T = (BitTree)malloc(sizeof(Tree)); //分配空间  解释：malloc分配一个连续空间 返回首地址赋值给指针遍历T 
        T->date = date;
        printf("输入%d左子树",date);
        T->lchild = CreateLink();
        printf("输入%d的右子树",date);
        T->rchild = CreateLink();
        return T; 
    }
 } 
 
 //先序遍历-BitTree T;=struct Tree *T;里面是指针 
 void ShowXianXu(BitTree T) //        先序遍历二叉树
 {
    if(T == NULL)  //    递归中遇到NULL，返回上一层节点
    {
        return;    
    }
    
    printf("%d",T->date);
    ShowXianXu(T->lchild); //    递归遍历左子树
    ShowXianXu(T->rchild); //    递归遍历右子树
         
} 

 //中序遍历
  void ShowZhongXu(BitTree T)
 {
    if(T == NULL) //    递归中遇到NULL，返回上一层节点
    {
        return;    
    }
    
    ShowZhongXu(T->lchild); //    递归遍历左子树
    printf("%d",T->date);
    ShowZhongXu(T->rchild); //    递归遍历右子树
    
}

 //后序遍历
  void ShowHouXu(BitTree T) //        先序遍历二叉树
 {
    if(T == NULL) //    递归中遇到NULL，返回上一层节点
    {
        return;    
    }
    
    ShowHouXu(T->lchild); //    递归遍历左子树
    ShowHouXu(T->rchild); //    递归遍历右子树
    printf("%d",T->date);
         
} 
 
 




//层次遍历-层次序非递归遍历
  void initqueue(Queue *q)//初始化 
  {
      q->front=0;
      q->rear=0;
   } 
   
   int enqueue(Queue *q,Tree e)//入队操作 前者事队列的指针，后者是二叉树里面的元素
   {
       
       if((q->rear+1)%50 == q->front)
       {
           return 0;
        }       
    q->arr[q->rear]=e;
    q->rear=(q->rear+1)%50;   
        return 1;
    }
    
    Tree dequeue(Queue *q)//出队操作 
    {
        if(q->front == q->rear)
        {
            exit(0);
        }
        Tree e;
        e=q->arr[q->front];
        q->front=(q->front+1)%50;
        return e; 
     } 
  void levelSort(BitTree T)  //层次遍历操作 
  {
      if(T==NULL)
      return;
    Queue *Q=(Queue*)malloc(sizeof(Queue)) ;
    //初始化
     initqueue(Q);
     enqueue(Q,*T) ;//入队操作 
    while(Q->front != Q->rear)
    {
        Tree x = dequeue(Q);
        printf("%d",x.date);
        if(x.lchild)
        {
            enqueue(Q,*x.lchild);
        }
        if(x.rchild)
        {
            enqueue(Q,*x.rchild);
        }
     } 
       
  }
//栈  
typedef struct SqStack{
    BitTree date[30]; 
    int top; //设置栈顶 
}SqStack,*Stack;
//创建栈
Stack InitStack()
{
    Stack S;
    S=(Stack)malloc(sizeof(SqStack));
    S->top=-1;
    return S;
  }  
//判断栈空
int StackEmpty(SqStack S)
{
    if(S.top == -1) return 1; //top还没有进栈 
    else return 0; //top进了栈 
 } 
//入栈
void Push(Stack S,BitTree p)
{
    S->top++;
    S->date[S->top]=p;
 } 
//出栈
void Pop(Stack S,BitTree* p)
{
    *p = S->date[S->top];
     S->top--;
 }
//非递归先序遍历二叉树 
void PreOrder(BitTree T)
{
    SqStack* S;
    S = InitStack();
    Tree* p;
    p = T;
    
    while(p || !StackEmpty(*S)){
        if(p)
        {
            printf("%d",p->date);//把数里面的值赋给栈 
            Push(S,p);
            p=p->lchild;
        }else
        {
             Pop(S,&p);
             p = p->rchild;
        }
         
    }
             
 } 
//非递归中序遍历二叉树 
void InOrder(BitTree T)
{
    SqStack* S;
    S = InitStack();
    Tree* p;
    p = T;
    
    while(p || !StackEmpty(*S))
    {
        if(p)
        {
            Push(S,p);
            p=p->lchild;
        }
        else
        {
             Pop(S,&p);
             printf("%d",p->date);//把数里面的值赋给栈
             p = p->rchild;
        }
    }
        
}
//非递归的后序遍历
void PostOrder(BitTree T)
{
    SqStack *S;
    S = InitStack();
    Tree* p;
    p=T;
    
    char tag[30]={'0'};
    
    while(p || !StackEmpty(*S))
    {
        if(p){
            Push(S,p);
            tag[S->top]='0';
            p=p->lchild;
        }
        else
        {
            while(tag[S->top]== 1)
            {
                Pop(S,&p);
                printf("%d",p->date);
            }
            if(tag[S->top] == -1) break;
            Pop(S,&p);
            Push(S,p);
            p=p->rchild;
            tag[S->top]=1; 
        }
        
        
    }
 } 
int main()
{
    BitTree S;
    printf("输入第一个节点的数据\n");
    S = CreateLink(); //        接受创建二叉树完成的根节点
    
    printf("先序遍历的结果\n"); //        先序遍历二叉树
    ShowXianXu(S); 
    printf("\n");
    printf("中序遍历的结果\n"); //        中序遍历二叉树
    ShowZhongXu(S);
    printf("\n");
    printf("后序遍历的结果\n");
    ShowHouXu(S);  //        后序遍历二叉树
    printf("\n");
    printf("层次序非递归遍历的结果\n");
    levelSort(S); 
    printf("\n");
    printf("非递归的先序遍历的结果\n");
    PreOrder(S);
    printf("\n");
    printf("非递归的中序遍历的结果\n");
    InOrder(S);
    printf("\n");
    printf("非递归的后序遍历的结果\n");
    PostOrder(S);
    return 0;
 }