二叉树的递归 非递归 先序 中序 后序及层次遍历代码实现

二叉树的递归 非递归 先序 中序 后序及层次遍历代码实现   其实这个代码还是有点缺陷的  如果谁有耐性看完的话  帮我改一下 ，这个二叉树的建立可以自己手动的，只要把main注释里面的一些东西去掉就行了，但是，用了if语句选择之后就不行了  不知道为什么

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


struct Binode
{
  char  data;
  struct Binode * lchild;
  struct Binode * rchild;
}Binode;     //二叉树的结构

typedef struct node
{
 struct Binode * data;
struct node * next;

}node,*pnode;  //定义了链栈的每一个节点元素

typedef struct stack
{
pnode stacktop;//栈顶指针
pnode stackbottom;  //栈底指针
}stack,*pstack;   //栈的基本信息

typedef struct qnode
{
 struct Binode * data;
 struct qnode * next;
}qnode,*queueptr;   // 定义链队列的每个节点的数据结构

typedef struct linkqueue
{
  queueptr front;
  queueptr rear;
}linkqueue;   //层次遍历用的队列

struct Binode * createbitree(void); //创建二叉树
struct Binode * createbitree2(void); //创建二叉树
//递归遍历函数

void preorder(struct Binode * T);  //递归先序遍历二叉树
void inorder(struct Binode * T);  //递归中序遍历二叉树
void postorder(struct Binode * T);//递归后序遍历二叉树
//以下是非递归的函数
void Preorder(struct Binode * T);//非递归先序遍历二叉树
void Inorder(struct Binode * T);//第一种非递归中序遍历二叉树
void Inorder2(struct Binode * T);//第二种非递归中序遍历二叉树
void Postorder(struct Binode * T);//非递归后序遍历二叉树
void Levelorder(struct Binode * T); //层次遍历
void Levelorder2(struct Binode * T); //加一个栈可以实现从下至上，从有右至左层次的遍历

//遍历应用函数
void yellownode(struct Binode * T);//求叶子节点个数
void swapnode(struct Binode * B);//交换二叉树的左右子树
//以下是栈的相关函数

void intistack(pstack s);//初始化栈
bool is_empty(pstack s);
void pop(pstack s,struct Binode **val);
void push(pstack s,struct Binode ** val);
struct Binode * Gettop(pstack s);//获取栈顶元素
void visit(struct Binode * p);  //访问节点的值

//以下是队列的函数
void initqueue(linkqueue *);  //初始化队列
void dequeue(linkqueue *,struct Binode **); //删除队头元素   并返回删除的值
void enqueue(linkqueue *,struct Binode **);  //在对尾插入元素 
bool Is_empty(linkqueue q);  //判断队列是否为空

void call(struct Binode * B);  //调用操作函数


void main(void)
{  struct Binode * B;
  //int i;
  /*printf("自己生成树输入         1  (按先序遍历生成，子树为空的输入空格符)\n\n");
  printf("自动生成树请输入       2\n\n");

*/
  //scanf("%d",&i);
  
 /* if(1==i)
  {
      B=createbitree2();
          call(B);          
  }
  else if(2==i)
  {*/
    B=createbitree();
        call(B);
        
  //}
  /*else if(3==i)
  {
    swapnode(B);
  }*/
  
  //else
  //{
        //  printf("选择有误\n\n");
  //}
  

}



void call(struct Binode * B)
{     
          printf("递归先序遍历\n");
  preorder(B);   //递归先序遍历
  printf("\n");
   /* 求得当前时间 */
  
  printf("递归中序遍历\n");
  inorder(B);  //递归中序递归遍历
  printf("\n");
  printf("递归后序遍历\n");
  postorder(B);  //递归后序递归遍历
  printf("\n");
  printf("非递归先序遍历\n");
  Preorder(B);
  printf("\n");
  printf("第一种非递归中序遍历\n");
  Inorder(B);//非递归中序遍历
  printf("\n");
  printf("第二种非递归中序遍历\n");
  Inorder2(B);
  printf("\n");
  printf("非递归后序遍历二叉树\n");
  Postorder(B);
  printf("\n");
  printf("层次遍历\n");
  Levelorder(B);
  printf("\n");
  printf("加一个栈实现从下至上，从右至左层次的遍历\n");
  Levelorder2(B);
   printf("\n");
   printf("\n");
  yellownode(B);
  printf("\n");
  
}



struct Binode * createbitree(void) //创建二叉树
{
struct Binode *  A=(struct Binode *)malloc(sizeof(Binode));
struct Binode *  B=(struct Binode *)malloc(sizeof(Binode));
struct Binode *  C=(struct Binode *)malloc(sizeof(Binode));
struct Binode *  D=(struct Binode *)malloc(sizeof(Binode));
struct Binode *  E=(struct Binode *)malloc(sizeof(Binode));
struct Binode *  F=(struct Binode *)malloc(sizeof(Binode));

A->data='1';
A->lchild=B;
A->rchild=C;
B->data='2';
B->lchild=D;
B->rchild=NULL;
C->data='3';
C->lchild=E;
C->rchild=F;
D->data='4';
D->lchild=NULL;
D->rchild=NULL;
E->data='5';
E->lchild=NULL;
E->rchild=NULL;
F->data='6';
F->lchild=NULL;
F->rchild=NULL;

return A;
}

struct Binode * createbitree2(void) //创建二叉树
{ struct Binode * T;
  char i;
  scanf("%c",&i);
  if(i==' ')T=NULL;
  else
  { T=(struct Binode *)malloc(sizeof(struct Binode));
    if(!T) exit(-1);
        T->data=i;
   T->lchild= createbitree2();
    T->rchild=createbitree2();
  }
          return T;
}

void preorder(struct Binode * T)  //先序递归遍历
{if(NULL!=T)
{ printf("%c ",T->data);
 if(NULL!=T->lchild)
 {
         
         preorder(T->lchild);

 }

  if(NULL!=T->rchild)
  {
          
          preorder(T->rchild);
         
  }

}
}

void inorder(struct Binode * T)  //中序递归遍历
{
  if(NULL!=T)
{ 
 if(NULL!=T->lchild)
 {
         
         inorder(T->lchild);
    
 }
 printf("%c ",T->data);
  if(NULL!=T->rchild)
  {
          
          inorder(T->rchild);
         
  }

}
}

void postorder(struct Binode * T)//后序递归遍历
{
  if(NULL!=T)
{ 
 if(NULL!=T->lchild)
 {
         
         postorder(T->lchild);
    
 }
 
  if(NULL!=T->rchild)
  {
          
          postorder(T->rchild);
         
  }
 printf("%c ",T->data);
}
}

void Preorder(struct Binode * T)//非递归先序遍历二叉树  这是自己写的 代码有点冗长
{   struct Binode * p=T;
    stack s;
    intistack(&s);
        while(p||!is_empty(&s))
        {
                if(p)
                {
                        visit(p);
                        push(&s,&p);
                        p=p->lchild;
                }//if
                else
                {
                        pop(&s,&p);
                        p=p->rchild;
                        if(p)
                        {
                                visit(p);
                                push(&s,&p);
                                p=p->lchild;
                        }//if
                        else if(!is_empty(&s))
                                {
                                        pop(&s,&p);
                                        p=p->rchild;
                                }//else if
                            else
                                { 
                    p=NULL; //退出循环的条件
                                } //else
                        }//外层的else
                
        }//while
}


void Inorder(struct Binode * T)//第一种非递归中序遍历
{   struct Binode * p=T;
    stack s;
        intistack(&s);
        push(&s,&T);
        while(!is_empty(&s))
        {  p=Gettop(&s);
        while(p) 
        {    push(&s,&(p->lchild));          
                   p=Gettop(&s);
        }

          pop(&s,&p);
          if(!is_empty(&s))
          {
                  pop(&s,&p);
                   visit(p);
                  push(&s,&(p->rchild));
          }
        }
}

void Inorder2(struct Binode * T)  //第二种非递归中序遍历  相对第一种进出栈的次数减少了 
{   
        struct Binode *p=T;
        stack s;
        intistack(&s);
        while(p||!is_empty(&s))
        {
                if(p){push(&s,&p);p=p->lchild;}
                else
                {
                        pop(&s,&p);
                        visit(p);
                        p=p->rchild;
                }
        }
}


void Postorder(struct Binode * T) //非递归后序遍历二叉树 参照王道书籍
{   struct Binode *p=T;
    struct Binode *r=NULL;
    stack s;
        intistack(&s);
        while(p||!is_empty(&s))
        {
                if(p)
                {
                        push(&s,&p);
                        p=p->lchild;
                }
                else
                { 
          p=Gettop(&s);
                 
                  if(p->rchild&&p->rchild!=r)
                  {   p=p->rchild;
                          push(&s,&p);
                          p=p->lchild;
                  }
                  else
                  {
                    pop(&s,&p);
                        visit(p);
                        r=p;
                        p=NULL;
                  }
                }
        }//while
}

void Levelorder(struct Binode * T) //层次遍历
{
        struct Binode *p=T;
    linkqueue q;
        initqueue(&q);
        enqueue(&q,&p);
        while(!Is_empty(q))
        {
       dequeue(&q,&p);
           visit(p);
          
           if(p->lchild!=NULL)
           enqueue(&q,&(p->lchild));
            if(p->rchild!=NULL)
           enqueue(&q,&(p->rchild));
           

        }

}

void Levelorder2(struct Binode * T) //加一个栈可以实现从下至上，从有右至左层次的遍历
{
        struct Binode *p=T;
         stack s;
        intistack(&s);
    linkqueue q;
        initqueue(&q);
        enqueue(&q,&p);
        while(!Is_empty(q))
        {
       dequeue(&q,&p);
           push(&s,&p);
          
           
           
                if(p->lchild!=NULL)
           enqueue(&q,&(p->lchild));
                 if(p->rchild!=NULL)
           enqueue(&q,&(p->rchild)); 
                
           

        }
        while(!is_empty(&s))
        {
                pop(&s,&p);
                visit(p);
        }

}


//将层次遍历该一下就可以得到叶子节点个数

void yellownode(struct Binode * T) //计算叶子节点的个数 叶子节点的个数为度为2的节点个数加1
{   int i;  //计算节点的度数
    int n=0;  //计算度为2的节点数
        struct Binode *p=T;
    linkqueue q;
        initqueue(&q);
        enqueue(&q,&p);
        while(!Is_empty(q))
        {  i=0;
       dequeue(&q,&p);
           
           
           if(p->lchild!=NULL)
           {
                   enqueue(&q,&(p->lchild));
                   i++;
           }
            if(p->rchild!=NULL)
                {
               enqueue(&q,&(p->rchild));
                   i++;
                }
      if(i==2)
          {
                  ++n;
          }
        }
 printf("叶子节点个数为%d \n",n+1);
}
void swapnode(struct Binode * B)//交换二叉树的左右子树
{  struct Binode *T=B;
   struct Binode * temp;
   if(T)
   {
   swapnode(T->lchild);
   swapnode(T->rchild);
   temp=T->lchild;
   T->lchild=T->rchild;
   T->rchild=temp;
   }

}

void intistack(pstack s)  //初始化一个栈，栈底元素为无用元素 ，用来判断栈是否为空，相当于链表中的头元素
{
   s->stacktop=(pnode)malloc(sizeof(node));  //生成一个节点  用作栈的头结点用，栈底指针指向该节点
  if(NULL==s->stacktop)
   {
      //printf("初始化失败\n\n");
          exit(-1);
   }
   else
   {
   s->stackbottom=s->stacktop;
   s->stackbottom->next=NULL;
   }


}
//更多资源  访问我的博客   http://www.17xuexiba.com

void push(pstack s,struct Binode ** val)   //元素进栈  val 为进栈的元素
{  

   pnode p=(pnode)malloc(sizeof(node));
   if(NULL==p)
   {
     //printf("压栈失败\n\n");
         exit(-1);
   
   }
   else
   {
   p->data=*val;
   p->next=s->stacktop;
   s->stacktop=p;

   }
   


}



void pop(pstack s,struct Binode ** val)  //数据出栈，用val值返回出栈数据
{
   pnode p=s->stacktop;
  if(s->stackbottom==s->stacktop)
  {
          //printf("栈中值为空，操作失败");
          exit(-1);
  }
  else
  {
     *val=p->data;
         s->stacktop=p->next;
         free(p);
  }

//printf("出栈的值为  %c  ",*val);
//printf("\n\n");
}


bool is_empty(pstack s)   //判栈是否为空
{
        if(s->stackbottom==s->stacktop)
                return true;
        else 
                return false;
}

struct Binode * Gettop(pstack s)  //获取栈顶元素
{
  struct Binode * p=s->stacktop->data;
 
  return p;
}

void visit(struct Binode * p)  //访问节点的值
{
 printf("%c  ",p->data);

}



//以下是队列的相关函数
void initqueue(linkqueue * q)  //初始化队列
{
  q->front=q->rear=(queueptr)malloc(sizeof(qnode));
  if(NULL==q->front)

  {
    //printf("初始化失败\n\n");
        exit(-1);
  }
  q->front->next=NULL;

}


void enqueue(linkqueue * q,struct Binode ** val)  //在对尾插入元素
{
  queueptr newptr=(queueptr)malloc(sizeof(qnode));
  if(NULL==newptr)
  {
          //printf("加入失败\n");
          exit(-1);
  }
  newptr->data=*val;
  newptr->next=NULL;
  
  q->rear->next=newptr;
  q->rear=newptr;
  
  
  

}


void dequeue(linkqueue * q,struct Binode ** val) //删除队头元素   并返回删除的值
{   queueptr p;
    if(q->front==q->rear)
        {
          //printf("队列为空");
          exit(-1);
        }
        p=q->front->next;
        *val=p->data;
        q->front->next=p->next;
        if(q->rear==p)
        q->front=q->rear;    //如果队列中删除元素后为空则要进行初始化的处理
        

        //printf("删除的元素为  %c  \n",*val);
        //free(p);
}


bool Is_empty(linkqueue q)  //判断队列是否为空
{
  if(q.rear==q.front)
  {
          return true;
  }
  else 
          return false;

}