#include<bits/stdc++.h>
using namespace std;
#define TRUE        1
#define FALSE       0
#define ERROR       0
#define OVERFLOW    -1
#define OK          1
typedef int Status;
typedef int TElemType;
Status CreateBiTree(BiTree &T);
int GetDepthOfBiTree(BiTree T);
int LeafCount(BiTree T);
typedef struct BiTNode{
    TElemType data;
    struct BiTNode *lchild, *rchild;
}BiTNode, * BiTree;


Status CreateBiTree(BiTree &T){
    TElemType e;
    scanf("%d",&e);
    if(e==0){
        T=NULL;
    }
    else{
        T=(BiTNode*)malloc(sizeof(BiTNode));
        if(T==NULL)exit(OVERFLOW);
        T->data=e;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
}
int GetDepthOfBiTree(BiTree T){
    if(T==NULL){
        return 0;
    }
    int ldepth=0,rdepth=0;
    else {
        ldepth=1+GetDepthOfBiTree(T->lchild);
        rdepth=1+GetDepthOfBiTree(T->rchild);
    }
    if(ldepth>rdepth){
        return ldepth;
    }
    else{
        return rdepth;
    }
}//getdepth



int main(){
    BiTree T;
    int depth,numberOfleaves;
    CreateBiTree(T);
    depth= GetDepthOfBiTree(T);
    numberOfLeaves=LeafCount(T);
    printf("%d %d\n",depth,numberOfLeaves);
    return 0;
}


**

**# ///**二叉树求深度******
int GetDepthOfBiTree ( BiTree T){
    int d1=0, d2=0, d; 
    if(!T)
        return 0;
    else{
        d1=GetDepthOfBiTree(T->lchild)+1;
        d2=GetDepthOfBiTree(T->rchild)+1;
    }
     if(d1>d2)
            d=d1;
        else
            d=d2;
    return d;
}

///后序输出第i个结点
void PrintNode(BiTree T){
    if(!T){
        return 0;
    }
    PrintNode(T->lchild);
    PrintNode(T->rchild);
    n--;
    if(!n){
        printf("%c",T->data);
    }    
}


///统计二叉树中指定元素节点的个数
int XNodeCountOfBiTree( BiTree T, TElemType x ){
    int cnt=0;
    if(T==NULL){
        cnt = 0;
    }
    else{
        if(T->data==x){
            cnt=1+XNodeCountOfBiTree(T->lchild, x)+XNodeCountOfBiTree(T->rchild, x);
        }
        else{
            cnt=XNodeCountOfBiTree(T->lchild, x)+XNodeCountOfBiTree(T->rchild, x);
        }
    }
    return cnt;
}


///二叉树求结点数
int NodeCountOfBiTree(BiTree T){
    if(T==NULL){
        return 0;
    }
    else{
        return 1+NodeCountOfBiTree(T->lchild)+NodeCountOfBiTree(T->rchild);
    }
}
///二叉树求叶子数
int LeafCount(BiTree T){
    int cnt=0;
    if(T==NULL){
        return 0;
    }
    else{
        if( T->lchild==NULL && T->rchild==NULL ){
            cnt++;
        }
        else{
            cnt=LeafCount(T->lchild)+LeafCount(T->rchild);
        }
    }
    return cnt;
}

```cpp


typedef int  Status;
typedef int  ElemType; //假设线性表中的元素均为整型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

Status ListCreate_L(LinkList &L,int n)
{
    LNode *rearPtr,*curPtr;   //一个尾指针，一个指向新节点的指针
    L=(LNode*)malloc(sizeof (LNode));
    if(!L)exit(OVERFLOW);
    L->next=NULL;               //先建立一个带头结点的单链表
    rearPtr=L;  //初始时头结点为尾节点,rearPtr指向尾巴节点
    for (int i=1;i<=n;i++){  //每次循环都开辟一个新节点，并把新节点拼到尾节点后
        curPtr=(LNode*)malloc(sizeof(LNode));//生成新结点
        if(!curPtr)exit(OVERFLOW);
        scanf("%d",&curPtr->data);//输入元素值
        curPtr->next=NULL;  //最后一个节点的next赋空
        rearPtr->next=curPtr;
        rearPtr=curPtr;
    }
    return OK;
}
//下面是需要实现的函数的声明
int ListLocate_L(LinkList L, ElemType x);

int main()
{
    LinkList L;
    int n;
    int x,k;   
    scanf("%d",&n);  //输入链表中元素个数
    if(ListCreate_L(L,n)!= OK) {
          printf("表创建失败！！！\n");
          return -1;
    }
   scanf("%d",&x); //输入待查找元素
   k=ListLocate_L(L,x);
   printf("%d\n",k);
   return 0;
}

/* 请在这里填写答案 */


///单链表元素定位
int ListLocate_L( LinkList L, ElemType x ){
    LNode *p=L;//创建一个指向头结点的指针
    int cnt=1;
    while( p->next!=NULL ){
        p=p->next;//只要p的下一个结点不为空，就可以更新p
        if( p->data==x ){return cnt;}
        else{cnt++;}
    
    }
    return 0;
}

///删除单链表中最后一个与给定值相等的结点
void ListLocateAndDel_L(LinkList L, ElemType x){
    //思路：先定位,用指针px记录最新出现的与x相等的结点的上一个结点，如果后面还有x便继续更新px
    //注意：表空？？
    LNode *p=L;//创建一个指向头结点的指针
    LNode *prior=L;//设置p的前驱指针
    LNode *px=L;//设置x结点的前驱节点
    while( p->next ){///遍历表中元素，只要表不空就前进，即当前结点的next不空就前进
        if(p->next->data==x){///若找到x，则把当前x结点的前驱节点px更新，
            px=p;/就是把x所在结点的下一个结点直接连接到x的上一个结点上
        }
        p=p->next;
    }
    if(px!=L){//只要最终px更新过，即并非没有更新，并非表中没有x
        px->next=px->next->next;
    }
}


///带头结点的单链表就地逆置
void ListReverse_L( LinkList &L ){
    LNode *p=L->next, *postP;  ///设置指针指向新结点
    L->next=NULL;
    while(p){
        postP=p;
        p=p->next;
        postP->next=L->next;
        L->next=postP;
    }
}


///两个有序链表序列的合并
/*
//思路：设计创建链表的函数creatList_L,生成两个链表后，
    //注意：S1或S2为空，？
    //      元素相同

Status creatList_L( LinkList &L ){      //创建链表
    LNode *rearPtr, *curPtr;            //定义一个尾指针，一个指向当前新结点的指针
    L=(LNode*)malloc(sizeof(LNode));    //开辟空间
    if(!L)  {exit(OVERFLOW);}           //检测是否开辟成功

    //对开辟好的链表的初始化
    L->next=NULL;   //把头结点L赋空
    rearPtr=L;      //初始时头结点就是尾结点，rearPtr指向尾结点
    int x;       //输入的data
    //scanf("%d",&x);
    while( scanf("%d",&x)!=EOF && x!=-1 ){          ///每次循环都会开辟一个新结点，并把它拼到尾结点之后
        curPtr=(LNode*)malloc(sizeof(LNode));       //每输入一个data便新开辟一个新结点
        if(!L)  {exit(OVERFLOW);}      //检测开辟了么？
        curPtr->data=x;                //当前输入的值赋给新开辟的结点的数值域
        curPtr->next=NULL;             //把新结点后面的赋空，方便其作为尾结点时能确保尾结点指针为空
        rearPtr->next=curPtr;          //把新结点连接到之前的尾结点后面
        rearPtr=curPtr;                //更新尾结点，把当前结点作为尾结点
    }
    return OK;
}
//设计把两个链表归并的函数
void mergeList_L( LinkList &La, LinkList &Lb, LinkList &Lc ){///实现两个链表融合成表L_mer
    //设置指针pa,pb,pc遍历三个表，比较当前最小元素，小的插入表Lc中pc后的位置
    LNode *pa=La->next;
    LNode *pb=Lb->next;     //让pa，pb分别指向各自头结点的后一个结点
    LNode *pc=Lc=La;        //让pc指向La的头结点，即把La的头结点作为Lc的头结点，
                            //La和Lc共用La的头结点
    while( pa&&pb ){
        if( pa->data < pb->data ){
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
        else{
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
    }
    if(pa)  pc->next=pa;
    if(pb)  pc->next=pb;
    free(Lb);//释放Lb
}

void printList_L(LinkList L){//输出链表的一个函数
    LNode *p=L->next;
    if(!p){
        printf("NULL");
        return;
    }
    while(p){
        if(p->next)     printf("%d ",p->data);
        else    printf("%d",p->data);
        p=p->next;
    }
}

int main(){
    LinkList s1, s2;
    LinkList L;
    creatList_L(s1);
    creatList_L(s2);
    mergeList_L(s1,s2,L);
    printList_L(L);

    return 0;
}
*/