swust oj 987

输出用先序遍历创建的二叉树是否为完全二叉树的判定结果

1000(ms)

10000(kb)

2553 / 5268

利用先序递归遍历算法创建二叉树并判断该二叉树是否为完全二叉树。完全二叉树只能是同深度的满二叉树缺少最后一层倒数连续个叶子结点。先序递归遍历建立二叉树的方法为：按照先序递归遍历的思想将对二叉树结点的抽象访问具体化为根据接收的数据决定是否产生该结点从而实现创建该二叉树的二叉链表存储结构。约定二叉树结点数据为单个大写英文字符。当接收的数据是字符"#"时表示该结点不需要创建，否则创建该结点。最后判断创建完成的二叉树度是否为完全二叉树。需要注意输入数据序列中的"#"字符和非"#"字符的序列及个数关系，这会最终决定创建的二叉树的形态。

输入

输入为接受键盘输入的由大写英文字符和"#"字符构成的一个字符串（用于创建对应的二叉树）。

输出

对应的二叉树是否为完全二叉树的判断结果。若是输出"Y"，否则输出"N"。

样例输入

A##
ABC####
AB##C##
ABCD###EF##G###
A##B##
ABC##D##EG###

样例输出

Y
N
Y
N
Y
Y 

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<cstdlib>
 #include<cstdio>
 typedef char Datetype;
 using namespace std;
 Datetype value;
 int x;

 typedef struct link{
     Datetype date;
     struct link *lchild;
     struct link *rchild;
 }tree;

 typedef struct queue{
     tree *data;
     struct queue *next;
 }que;

 typedef struct {
     que *front;
     que *rear;
 }lin;

 void Initqueue(lin *&L)
 {
     L=(lin *)malloc(sizeof(lin));
     L->front=L->rear=NULL;
 }

 void destroyed(lin *&L)
 {
     que *p=NULL,*r=NULL;
     p=L->front;
     while(p!=NULL)
     {
         r=p;
         p=p->next;
         free(r);
     }
     free(L);
 }

 bool pop(lin *&L, tree *&e)
 {
     que *p;
     if(L->rear==NULL)
         return false;
     p=L->front;
     if(L->rear==L->front)
         L->front=L->rear=NULL;
     else
         L->front=p->next;
     e=p->data;
     free(p);
     return true;
 }

 int empty(lin *&L)
 {
     return (L->rear==NULL);
 }

 void push(lin *&L,tree *e)
 {
     que *p;
     p = (que *)malloc(sizeof(que));
     p->data=e;
     p->next=NULL;
     if(L->rear==NULL)
     {
         L->front=p;
         L->rear=p;
     }
     else
     {
         L->rear->next=p;
         L->rear=p;
     }
 }

 void creattree(tree *&L) //先序建立二叉树
 {
     char c;
     cin>>c;
     if(c=='#')
         L=NULL;
     else
     {
         L = (tree *)malloc(sizeof(tree)) ;
         L->date=c;
         creattree(L->lchild);
         creattree(L->rchild);
     }
 }

 void find(tree *L) //找树的棵树
 {
     if(L!=NULL)
     {
         x++;
         find(L->rchild);
     }
 }

 void destroytree(tree *&L) //销毁树
 {
     if(L!=NULL)
     {
         destroytree(L->lchild);
         destroytree(L->rchild);
         free(L);
     }
 }

 int deep(tree *L) //深度
 {
     int ldep,rdep,max;
     if(L!=NULL)
     {
         ldep=deep(L->lchild);
         rdep=deep(L->rchild);
         max=ldep>rdep?ldep+:rdep+;
         return max;
     }
     else
         return ;
 }

 void finddegree(tree *&L, int n) //找最大度数
 {
     if(L!=NULL)
     {
         if(x<n)
             x=n;
         finddegree(L->lchild,n);
         finddegree(L->rchild,n+);
     }

 }

 void run(tree *L)  //层次遍历
 {
     tree *p=L;
     lin *qu;
     Initqueue(qu);
     if(L!=NULL)
         push(qu,p);
     while(!empty(qu))
     {
         pop(qu,p);
         cout<<p->date;
         if(p->lchild!=NULL)
             push(qu,p->lchild);
         if(p->rchild!=NULL)
             push(qu,p->rchild);
     }
     destroyed(qu);
 }

 void displayhou(tree *&L) //后序输出
 {
     if(L!=NULL)
     {
         displayhou(L->lchild);
         displayhou(L->rchild);
         cout<<L->date;
     }
 }

 void displaypre(tree *&L) //先序输出
 {
     if(L!=NULL)
     {
         cout<<L->date;
         displaypre(L->lchild);
         displaypre(L->rchild);
     }
 }

 void creatinpre(tree *&L ,char *in,char *pre,int x)//根据中先序确定后序
 {
     int k=;
     char *p;
     if(x<=)
     {
         L=NULL;
         return ;
     }
     L=(tree *)malloc(sizeof(tree));
     L->date = *pre;
     for(p=in ; p<in+x; p++)
     {
         if(*p==*pre)
             break;
     }
     k=p-in;
     creatinpre(L->lchild,in,pre+,k);
     creatinpre(L->rchild,p+,pre+k+,x-k-);
 }

 void creatinhou(tree *&L ,char *in,char *pre,int x)  //根据中后序确定先序
 {
     int k=;
     char *p;
     if(x<=)
     {
         L=NULL;
         return ;
     }
     L=(tree *)malloc(sizeof(tree));
     L->date = *pre;
     for(p=in ; p>in-x; p--)
     {
         if(*p==*pre)
             break;
     }
     k=in-p;
     creatinhou(L->rchild,in,pre-,k);
     creatinhou(L->lchild,p-,pre-k-,x-k-);
 }

 void findson(tree *&L)  //找指定节点的儿子
 {
     if(L!=NULL)
     {
         if(L->date==x)
         {
             if(L->lchild==NULL)
                 cout<<"L:#";
             else
                 cout<<"L:"<<L->lchild->date;
             if(L->rchild==NULL)
                 cout<<",R:#";
             else
                 cout<<",R:"<<L->rchild->date;
             return ;
         }
         findson(L->lchild);
         findson(L->rchild);
     }
 }

 void finddad(tree *&L)  //找指定节点的父亲节点
 {
     if(L!=NULL)
     {
         if(L->lchild!=NULL&&L->lchild->date==x||L->rchild!=NULL&&L->rchild->date==x)
         {
             cout<<L->date;
             return ;
         }

         finddad(L->lchild);
         finddad(L->rchild);
     }
 }

 int find_the_one_degree(tree *&L)  //找寻某指定节点的度
 {
     if(L!=NULL)
     {
         if(L->date==value)
         {
             if(L->lchild!=NULL&&L->rchild==NULL||L->lchild==NULL&&L->rchild!=NULL)
                 return ;
             else if(L->lchild==NULL&&L->rchild==NULL)
                 return ;
             else
                 return ;
         }
         find_the_one_degree(L->lchild);
         find_the_one_degree(L->rchild);
     }
 }

 void exchange(tree *&L)  //交换左右儿子的值
 {
     if(L!=NULL)
     {
         tree *p;
         p=L->lchild;
         L->lchild=L->rchild;
         L->rchild=p;
         exchange(L->lchild);
         exchange(L->rchild);
     }
 }

 void displayin(tree *&L)  //中序输出
 {
     if(L!=NULL)
     {
         displayin(L->lchild);
         cout<<L->date;
         displayin(L->rchild);
     }
 }

 bool banlancetree(tree *&L)   //平衡树
 {
     if(L==NULL)
         return true;
     int left=deep(L->lchild);
     int right=deep(L->rchild);
     int gas=left-right;
     if(gas>||gas<-)
         return false;
     return banlancetree(L->lchild)&&banlancetree(L->rchild);
 }

 bool perfecttree(tree *&L,int deepth)  //完全二叉树的判定
 {
     if(L==NULL)
         return true;
     if(L->rchild!=NULL&&L->lchild==NULL)
         return false;
     if(x-deepth>&&L->rchild==NULL)
         return false;
     return perfecttree(L->lchild,deepth+)&&perfecttree(L->rchild,deepth+);
 }

 int main()
 {
     tree *L = NULL;
     creattree(L);
     x=deep(L);
     if(perfecttree(L,))
         cout<<"Y";
     else
         cout<<"N";
     destroytree(L);
     return ;
 }