19版考研数据结构王道课后习题代码-树 下【未完】

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define maxSize 101
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define maxSize 101


/*
 //后序遍历二叉树的非递归算法  P123.3
typedef struct Tree
{
    int data;
    Tree *lchild,*rchild;
};
void PostTraval(Tree *t)
{
    Tree *stack[maxSize];
    int top=-1;
    Tree *r=NULL;
    while(top!=-1||t)
    {
        while(t)
        {
            stack[++top]=t;
            t=t->lchild;
        }
        t=stack[top];
        if(t->rchild&&t->rchild!=r)
        {
            t=t->rchild;
        }
        else
        {
            t=stack[top--];
            cout<data<<" ";
            r=t;
            t=NULL;
        }
    }
}
Tree *Create(Tree *&t,int ch)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=ch;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    else if(ch<=t->data)
        t->lchild=Create(t->lchild,ch);
    else if(ch>t->data)
        t->rchild=Create(t->rchild,ch);
    return t;
}
int main()
{
    Tree *t=NULL;
    int n,a[maxSize];
    cin>>n;
    for(int i=0;i>a[i];
        t=Create(t,a[i]);
    }
    PostTraval(t);
}
 
5
3 4 2 1 3
1 3 2 4 3
*/

/*
 //给出自下而上从右到左的层次遍历算法 P123 4  先把从上到下从左到右的层次遍历结果存到栈中，再从栈中输出
 typedef struct Tree{
     int data;
     Tree *lchild,*rchild;
 }Tree;
int s[maxSize];
int top=-1;
void LayerTraval(Tree *t)
{
    Tree *queue[maxSize];
    int front=1;
    int rear=1;
    queue[rear++]=t;
    while(front!=rear)
    {
        Tree *q=queue[front];
        s[++top]=q->data;
        front++;
        if(q->lchild)
        {
            queue[rear++]=q->lchild;
        }
        if(q->rchild)
        {
            queue[rear++]=q->rchild;
        }
    }
}
Tree *insert(Tree *&t,int ch)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=ch;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    if(chdata)
    {
        t->lchild=insert(t->lchild,ch);
    }
    else if(ch>t->data)
    {
        t->rchild=insert(t->rchild,ch);
    }
    return t;
}
int main()
{
    Tree *t=NULL;
    int n,a[maxSize];
    cin>>n;
    for(int i=0;i>a[i];
        t=insert(t,a[i]);
    }
    LayerTraval(t);
    while(top!=-1)
    {
        cout<data=ch;
        t->lchild=t->rchild=NULL;
    }
    else if(chdata)
    {
        insert(t->lchild,ch);
    }
    else if(ch>t->data)
    {
        insert(t->rchild,ch);
    }
    return t;
}
void DFS(Tree *t,int &max)
{
    Tree *stack[maxSize];
    int top=-1;
    int h=0;
    while(t||top!=-1)
    {
        while(t)
        {
            stack[++top]=t;
            t=t->lchild;
            h++;
            if(h>max)
                max=h;
        }
        if(top!=-1)
        {
            t=stack[top--];
            h--;
            t=t->rchild;
        }
    }
}
int main()
{
    Tree *t=NULL;
    int n;
    int a[maxSize];
    cin>>n;
    for(int i=0;i>a[i];
        t=insert(t,a[i]);
    }
    int max=0;
    DFS(t,max);
    cout<lchild=NULL;
        p->rchild=NULL;
        p->data=pre[preL];
        int k;
        for(int i=inL;i<=inR;i++)
        {
            if(in[i]==pre[preL])
            {
                k=i;
                break;
            }
        }
        p->lchild=CreatTree(pre,in,preL+1,preL+(k-inL),inL,k-1);
        p->rchild=CreatTree(pre,in,preL+(k-inL)+1,preR,k+1,inR);
        return p;
    }
    return NULL;
}
void postTraval(Tree *t)
{
    if(t)
    {
        postTraval(t->lchild);
        postTraval(t->rchild);
        cout<data<<" ";
    }
}
int main()
{
    int pre[maxSize],in[maxSize];
    int n;
    cin>>n;
    for(int i=0;i>pre[i];
    }
    for(int i=0;i>in[i];
    }
    Tree *t=NULL;
    t=CreatTree(pre,in,0,n-1,0,n-1);
    postTraval(t);
}

//6
//5 3 2 1 6 8
//1 2 3 5 6 8
//1 2 3 8 6 5
*/


/*
 //链表形式，判断二叉树是否是完全二叉树 P123 7  //检查每一层的节点数
typedef struct Tree{
    int data,lev;
    Tree *lchild,*rchild;
}Tree;
Tree *insert(Tree *&t,int ch)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=ch;
        t->lchild=t->rchild=NULL;
    }
    else if(chdata)
    {
        insert(t->lchild,ch);
    }
    else if(ch>t->data)
    {
        insert(t->rchild,ch);
    }
    return t;
}
int BFS (Tree *t)
{
    Tree *queue[maxSize];
    int front=0;
    int rear=0;
    int l;
    queue[rear]=t;
    queue[rear]->lev=1;
    rear++;
    while(front!=rear)
    {
        Tree *p=queue[front];
        l=queue[front]->lev;
        front++;
        if(p->lchild)
        {
            queue[rear]=p->lchild;
            queue[rear]->lev=l+1;
            rear++;
        }
        if(p->rchild)
        {
            queue[rear]=p->rchild;
            queue[rear]->lev=l+1;
            rear++;
        }
    }
    for(int i=1;ilev==i)
            {
                cnt++;
            }
        }
        if(cnt!=pow(2,i-1))
            return 0;
    }
    return 1;
}
int main()
{
    Tree *t=NULL;
    int n;
    int a[maxSize];
    cin>>n;
    for(int i=0;i>a[i];
        t=insert(t,a[i]);
    }
    int d=BFS(t);
    cout<lchild&&t->rchild)
        {
            n++;
        }
        PreTraval(t->lchild,n);
        PreTraval(t->rchild,n);
    }
}
void *insert(Tree *&t,int x)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=x;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    else if(xdata)
    {
        insert(t->lchild,x);
    }
    else if(x>=t->data)
    {
        insert(t->rchild,x);
    }
    return NULL;
}
int main()
{
    Tree *t;
    int n,c;
    cin>>n;
    for(int i=0;i>c;
        insert(t,c);
    }
    int k=0;
    PreTraval(t,k);
    cout<lchild=PreTraval(t->lchild);
        t->rchild=PreTraval(t->rchild);
        Tree *u;
        u=t->lchild;
        t->lchild=t->rchild;
        t->rchild=u;
        return t;
    }
    return NULL;
}
void *insert(Tree *&t,int x)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=x;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    else if(xdata)
    {
        insert(t->lchild,x);
    }
    else if(x>=t->data)
    {
        insert(t->rchild,x);
    }
    return NULL;
}
void postTraval(Tree *t)
{
    if(t)
    {
        postTraval(t->lchild);
        postTraval(t->rchild);
        cout<data<<" ";
    }
}
int main()
{
    Tree *t=NULL;
    int n;
    cin>>n;
    int c;
    for(int i=0;i>c;
        insert(t,c);
    }
    t=PreTraval(t);
    postTraval(t);
}
 
// 6
// 5 3 1 4 9 7
// 7 9 4 1 3 5
//
 */



 //求先序遍历序列中第k个节点的值 P123 10
//typedef struct Tree
//{
//    int data;
//    struct Tree *lchild,*rchild;
//}Tree;
//void *insert(Tree *&t,int x)
//{
//    if(t==NULL)
//    {
//        t=(Tree*)malloc(sizeof(Tree));
//        t->data=x;
//        t->lchild=NULL;
//        t->rchild=NULL;
//    }
//    else if(xdata)
//    {
//        insert(t->lchild,x);
//    }
//    else if(x>=t->data)
//    {
//        insert(t->rchild,x);
//    }
//    return NULL;
//}
//int d=0;
//void preTraval(Tree *t,int k)
//{
//    if(t)
//    {
//        d++;
//        //cout<data;
//            return;
//        }
//        preTraval(t->lchild,k);
//        preTraval(t->rchild,k);
//    }
//}
//int main()
//{
//    Tree *t=NULL;
//    int n;
//    cin>>n;
//    int c,k;
//    for(int i=0;i>c;
//        insert(t,c);
//    }
//    cin>>k;
//    preTraval(t,k);
//}
//
// 6
// 5 3 1 4 9 7
// 5
// 9



 //删除元素值为x的元素为根的子树 P123 11
//typedef struct Tree
//{
//    int data;
//    struct Tree *lchild,*rchild;
//}Tree;
//void *insert(Tree *&t,int x)
//{
//    if(t==NULL)
//    {
//        t=(Tree*)malloc(sizeof(Tree));
//        t->data=x;
//        t->lchild=NULL;
//        t->rchild=NULL;
//    }
//    else if(xdata)
//    {
//        insert(t->lchild,x);
//    }
//    else if(x>=t->data)
//    {
//        insert(t->rchild,x);
//    }
//    return NULL;
//}
//void Delete(Tree *&t,int x)
//{
//    if(t)
//    {
//        if(t->data==x)
//        {
//            t->lchild=NULL;
//            t->rchild=NULL;
//            t=NULL;
//            return;
//        }
//        Delete(t->lchild,x);
//        Delete(t->rchild,x);
//    }
//    return;
//}
//void PostTravel(Tree *t)
//{
//    if(t)
//    {
//        PostTravel(t->lchild);
//        PostTravel(t->rchild);
//        cout<data<<" ";
//    }
//}
//int main()
//{
//    Tree *t=NULL;
//    int n;
//    cin>>n;
//    int c,k;
//    for(int i=0;i>c;
//        insert(t,c);
//    }
//    int x;
//    cin>>x;
//    Delete(t,x);
//    PostTravel(t);
//}
//
//6
//5 3 1 4 9 7
//9
//1 4 3 5
//



////找出值为x的节点的所有祖先 P123 12  用parent指针指向祖先节点！注意点：根节点的parent要赋值为NULL！
////标准答案的方法：非递归后序遍历！栈中存储的是本节点所有的祖先节点！！
//typedef struct Tree
//{
//    int data;
//    struct Tree *lchild,*rchild,*parent;
//}Tree;
//void *insert(Tree *&t,int x)
//{
//    if(t==NULL)
//    {
//        t=(Tree*)malloc(sizeof(Tree));
//        t->data=x;
//        t->lchild=NULL;
//        t->rchild=NULL;
//    }
//    else if(xdata)
//    {
//        insert(t->lchild,x);
//    }
//    else if(x>=t->data)
//    {
//        insert(t->rchild,x);
//    }
//    return NULL;
//}
//void PreTraval(Tree *t)
//{
//    if(t)
//    {
//        if(t->lchild)
//        {
//            t->lchild->parent=t;
//        }
//        if(t->rchild)
//        {
//            t->rchild->parent=t;
//        }
//        PreTraval(t->lchild);
//        PreTraval(t->rchild);
//    }
//}
//void PostTravel(Tree *t,int x)
//{
//    if(t)
//    {
//        PostTravel(t->lchild,x);
//        PostTravel(t->rchild,x);
//        if(t->data==x)
//        {
//            while(t->parent!=NULL)
//            {
//                t=t->parent;
//                cout<data<>n;
//    int c;
//    for(int i=0;i>c;
//        insert(t,c);
//    }
//    t->parent=NULL;
//    int x;
//    cin>>x;
//    PreTraval(t);
//    PostTravel(t,x);
//}

/*
//找p,q最近公共祖先节点 P123 13
typedef struct Tree
{
    int data;
    struct Tree *lchild,*rchild,*parent;
    int lev;
}Tree;
void *insert(Tree *&t,int x)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=x;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    else if(xdata)
    {
        insert(t->lchild,x);
    }
    else if(x>=t->data)
    {
        insert(t->rchild,x);
    }
    return NULL;
}
void PreOrder(Tree *t)
{
    Tree *stack[maxSize];
    t->parent=NULL;
    int top=-1;
    while(top!=-1||t)
    {
        while(t)
        {
            stack[++top]=t;
            if(t->lchild)
                t->lchild->parent=t;
            t=t->lchild;
        }
        t=stack[top--];
        if(t->rchild)
        {
            t->rchild->parent=t;
        }
        t=t->rchild;
    }
}

void Ancestor(Tree *t,Tree *p,Tree *q,Tree *&r)
{
    while(p)
    {
        Tree *s=q;
        while(s)
        {
            if(p==s)
            {
                r=p;
                return;
            }
            s=s->parent;
        }
        p=p->parent;
    }
}

int main()
{
    Tree *t=NULL;
    int n;
    cin>>n;
    int c;
    for(int i=0;i>c;
        insert(t,c);
    }
    PreOrder(t);
    Tree *p=t->rchild->rchild;
    Tree *q=t->rchild->lchild->lchild;
    Tree *r=NULL;
    Ancestor(t,p,q,r);
    cout<data;
}
    
//7
//4 3 1 7 9 6 5
//7
*/


 //求二叉树的宽度 P123 14
//typedef struct Tree
//{
//    int data;
//    struct Tree *lchild,*rchild;
//    int lev;
//}Tree;
//void *insert(Tree *&t,int x)
//{
//    if(t==NULL)
//    {
//        t=(Tree*)malloc(sizeof(Tree));
//        t->data=x;
//        t->lchild=NULL;
//        t->rchild=NULL;
//    }
//    else if(xdata)
//    {
//        insert(t->lchild,x);
//    }
//    else if(x>=t->data)
//    {
//        insert(t->rchild,x);
//    }
//    return NULL;
//}
//int BFS(Tree *t)
//{
//    Tree *queue[maxSize];
//    int front=0;
//    int rear=0;
//    int l=0;
//    queue[rear]=t;
//    queue[rear]->lev=0;
//    rear++;
//    while(front!=rear)
//    {
//        t=queue[front++];
//        l=t->lev;
//        if(t->lchild)
//        {
//            queue[rear]=t->lchild;
//            queue[rear]->lev=l+1;
//            rear++;
//        }
//        if(t->rchild)
//        {
//            queue[rear]=t->rchild;
//            queue[rear]->lev=l+1;
//            rear++;
//        }
//    }
//    int max=0;
//    for(int i=0;i<=l;i++)
//    {
//        int cnt=0;
//        for(int j=0;jlev==i)
//            {
//                cnt++;
//            }
//        }
//        if(cnt>max)
//            max=cnt;
//    }
//    return max;
//}
//int main()
//{
//    Tree *t=NULL;
//    int n;
//    cin>>n;
//    int c;
//    for(int i=0;i>c;
//        insert(t,c);
//    }
//    int d=BFS(t);
//    cout<>n;
//    for(int i=1;i<=n;i++)
//        cin>>pre[i];
//    PreTraval(pre,post,1,n,1,n);
//    for(int i=1;i<=n;i++)
//        cout<data=x;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    else if(xdata)
    {
        insert(t->lchild,x);
    }
    else if(x>=t->data)
    {
        insert(t->rchild,x);
    }
    return NULL;
}
void PreOrder(Tree *t,Tree *p)
{
    if(t)
    {
        if(t->lchild==NULL&&t->rchild==NULL)
        {
            p->rchild=t;
            p=t;
            p->rchild=NULL;
        }
        PreOrder(t->lchild,p);
        PreOrder(t->rchild,p);
    }
}
void preTraval(Tree *t,Tree *&head)
{
    Tree *p=head;
    Tree *stack[maxSize];
    int top=-1;
    while(top!=-1||t)
    {
        while(t)
        {
            stack[++top]=t;
            if(t->lchild==NULL&&t->rchild==NULL)
            {
                p->rchild=t;
                p=t;
                p->rchild=NULL;
            }
            t=t->lchild;
        }
        t=stack[top--];
        t=t->rchild;
    }
}
int main()
{
    Tree *t=NULL;
    int n;
    cin>>n;
    int c;
    for(int i=0;i>c;
        insert(t,c);
    }
    Tree *head=(Tree*)malloc(sizeof(Tree));
    preTraval(t,head);
    while(head->rchild)
    {
        cout<rchild->data<<" ";
        head=head->rchild;
    }
}
//
//7
//4 2 6 1 3 5 7
//1 3 5 7
*/

//
////判断两棵二叉树是否相识 P124 17
//typedef struct Tree
//{
//    int data;
//    struct Tree *lchild,*rchild;
//}Tree;
//void *insert(Tree *&t,int x)
//{
//    if(t==NULL)
//    {
//        t=(Tree*)malloc(sizeof(Tree));
//        t->data=x;
//        t->lchild=NULL;
//        t->rchild=NULL;
//    }
//    else if(xdata)
//    {
//        insert(t->lchild,x);
//    }
//    else if(x>=t->data)
//    {
//        insert(t->rchild,x);
//    }
//    return NULL;
//}
//int Judge(Tree *t1,Tree *t2)
//{
//    if(t1&&t2)
//    {
//        if(t1->data!=t2->data)
//        {
//            return 0;
//        }
//        int l1=Judge(t1->lchild,t2->lchild);
//        int l2=Judge(t1->rchild,t2->rchild);
//        return l1&&l2;
//    }
//    else if(t1==NULL&&t2==NULL)
//    {
//        return 1;
//    }
//    return 0;
//}
//int main()
//{
//    Tree *t1=NULL;
//    int n;
//    cin>>n;
//    int c;
//    for(int i=0;i>c;
//        insert(t1,c);
//    }
//    Tree *t2=NULL;
//    for(int i=0;i>c;
//        insert(t2,c);
//    }
//    int d=Judge(t1,t2);
//    cout<data=x;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    else if(xdata)
    {
        insert(t->lchild,x);
    }
    else if(x>=t->data)
    {
        insert(t->rchild,x);
    }
    return NULL;
}
Tree *Find(Tree *t)
{
    if(t->rtag==0)
    {
        return t->rchild;
    }
    if(t->ltag==0)
    {
        return t->lchild;
    }
    return t->lchild->lchild;
}
void InThread(Tree *&t,Tree *&pre)
{
    if(t)
    {
        InThread(t->lchild,pre);
        if(t->lchild==NULL)
        {
            t->ltag=1;
            t->lchild=pre;
        }
        if(pre!=NULL&&pre->rchild==NULL)
        {
            pre->rtag=1;
            pre->rchild=t;
        }
        pre=t;   //易忽视的点，有pre的话一定记得推进pre的前进！！！
        InThread(t->rchild,pre);
    }
}
void CreateThread(Tree *&t)
{
    Tree *pre=NULL;
    if(t)
    {
        InThread(t,pre);
        pre->rchild=NULL;
        pre->rtag=1;
    }
}
int main()
{
    Tree *t=NULL;
    int n;
    cin>>n;
    int c;
    for(int i=0;i>c;
        insert(t,c);
    }
    CreateThread(t);
    Tree *s=Find(t->lchild->rchild);
    cout<data;
}
*/


//
//
////求二叉树的带权路径长度 P124 19
//typedef struct Tree
//{
//    int weight;
//    struct Tree *lchild,*rchild;
//}Tree;
//void *insert(Tree *&t,int x)
//{
//    if(t==NULL)
//    {
//        t=(Tree*)malloc(sizeof(Tree));
//        t->weight=x;
//        t->lchild=NULL;
//        t->rchild=NULL;
//    }
//    else if(xweight)
//    {
//        insert(t->lchild,x);
//    }
//    else if(x>=t->weight)
//    {
//        insert(t->rchild,x);
//    }
//    return NULL;
//}
//int BFS(Tree *t)
//{
//    Tree *queue[maxSize];
//    int front=0;
//    int rear=0;
//    queue[rear++]=t;
//    int sum=0;
//    Tree *newNode=t;
//    Tree *lastNode=t;
//    int deep=0;
//    while(front!=rear)
//    {
//        t=queue[front++];
//        if(t->lchild==NULL&&t->rchild==NULL)
//        {
//            sum+=t->weight*deep;
//        }
//        if(t->lchild)
//        {
//            queue[rear++]=t->lchild;
//            newNode=t->lchild;
//        }
//        if(t->rchild)
//        {
//            queue[rear++]=t->rchild;
//            newNode=t->rchild;
//        }
//        if(t==lastNode)
//        {
//            deep++;
//            lastNode=newNode;
//        }
//    }
//    return sum;
//    return sum;
//}
//int main()
//{
//    Tree *t1=NULL;
//    int n;
//    cin>>n;
//    int c;
//    for(int i=0;i>c;
//        insert(t1,c);
//    }
//    int d=BFS(t1);
//    cout<lchild);
//        for(int i=0;t->data[i]!='0';i++)
//            seq[n++]=t->data[i];
//        seq[n++]=')';
//        InOrder(t->rchild);
//    }
//}
//int main()
//{
//    Tree *t1=(Tree*)malloc(sizeof(Tree));
//    strcpy(t1->data,"*");
//    Tree *t2=(Tree*)malloc(sizeof(Tree));
//    strcpy(t2->data,"+");
//    Tree *t3=(Tree*)malloc(sizeof(Tree));
//    strcpy(t3->data,"a");
//    t3->lchild=NULL;
//    t3->rchild=NULL;
//    Tree *t4=(Tree*)malloc(sizeof(Tree));
//    strcpy(t4->data,"b");
//    t4->lchild=NULL;
//    t4->rchild=NULL;
//    t1->lchild=t2;
//    t2->lchild=t3;
//    t2->rchild=t4;
//    Tree *t5=(Tree*)malloc(sizeof(Tree));
//    strcpy(t5->data,"*");
//    t1->rchild=t5;
//    Tree *t6=(Tree*)malloc(sizeof(Tree));
//    strcpy(t6->data,"c");
//    t5->lchild=t6;
//    t6->lchild=NULL;
//    t6->rchild=NULL;
//    Tree *t7=(Tree*)malloc(sizeof(Tree));
//    strcpy(t7->data,"-");
//    t5->rchild=t7;
//    Tree *t8=(Tree*)malloc(sizeof(Tree));
//    strcpy(t8->data,"d");
//    t8->lchild=NULL;
//    t8->rchild=NULL;
//    t7->rchild=t8;
//    InOrder(t1);
//    for(int i=0;ifirstchild==NULL)
//    {
//        return 1+Count(t->nextsibling);
//    }
//    if(t)
//    {
//        return 0;
//    }
//    return Count(t->firstchild)+Count(t->nextsibling);
//}
//
//
//
//
////以孩子兄弟表示法为存储结构，递归求树的深度 P148 6
//typedef struct CSNode
//{
//    int data;
//    struct CSNode *firstchild,*nextsibling;
//}CSNode;
//int height(CSNode *t)
//{
//    if(t==NULL)
//    {
//        return 0;
//    }
//    return max(1+height(t->firstchild),height(t->nextsibling));
//}
//
//
//
//
////已知一棵树的层次序列和每个节点的度，构造此树的孩子兄弟链表 P148 7
//typedef struct CSNode
//{
//    int data;
//    struct CSNode *firstchild,*nextsibling;
//}CSNode;
////用一个辅助数组存储树的各节点的地址
//void CreateTree(CSNode *&t,int level[],int cnt[],int n)
//{
//    CSNode *point[maxSize];
//    int i,j,d=0,k=0;
//    for(i=0;idata=level[i];
//        point[i]->firstchild=NULL;
//        point[i]->nextsibling=NULL;
//    }
//    for(i=0;ifirstchild=point[k];
//            for(j=2;j<=d;j++)
//            {
//                point[j-1]->nextsibling=point[j];
//            }
//        }
//    }
//    t=point[0];
//}
//int Count(CSNode *t)
//{
//    if(t->firstchild==NULL)
//    {
//        return 1+Count(t->nextsibling);
//    }
//    if(t)
//    {
//        return 0;
//    }
//    return Count(t->firstchild)+Count(t->nextsibling);
//}
//void Traval(CSNode *t)
//{
//    while(t)
//    {
//        cout<data<<" ";
//        t=t->firstchild;
//    }
//}
//int main()
//{
//    CSNode *t;
//    int n;
//    int level[maxSize],cnt[maxSize];
//    cin>>n;
//    for(int i=0;i>level[i];
//    }
//    for(int i=0;i>cnt[i];
//    }
//    CreateTree(t,level,cnt,n);
//    Traval(t);
//    int d=Count(t);
//    cout<