深度，节点完成；复制检验未完成

#include
#include

typedef struct BinaryTree{
    struct BinaryTree* left;//左指针指向左孩子 
    struct BinaryTree* right;//右指针指向右孩子 
    int data;//二叉树节点的数据域 
}BT;//给二叉树类型名重定义为BT 

//创建一个二叉树
BT* CreatTree(){
    //动态开辟所需要的节点
    BT* n1=(BT*)malloc(sizeof(BT));
    BT* n2=(BT*)malloc(sizeof(BT));
    BT* n3=(BT*)malloc(sizeof(BT));
    BT* n4=(BT*)malloc(sizeof(BT));
    BT* n5=(BT*)malloc(sizeof(BT));
    BT* n6=(BT*)malloc(sizeof(BT));
    BT* n7=(BT*)malloc(sizeof(BT)); 
    
    //给各个节点赋值
    n1->data = 1;
    n2->data = 2;
    n3->data = 3;
    n4->data = 4;
    n5->data = 5;
    n6->data = 6;
    n7->data = 7;
    //让每个节点的左右指针指明方向，创建一个二叉树
    n1->left=n2;
    n1->right=n3;
    n2->left=n4;
    n2->right=n5;
    n3->left=n6;
    n3->right=NULL;
    n4->left=n7; 
    n4->right=NULL;
    n5->left=NULL;
    n5->right=NULL;
    n6->left=NULL;
    n6->right=NULL;
    n7->left=NULL;
    n7->right=NULL;
    //形成二叉树后，返回让指针返回根节点
    return n1;
}

//先序遍历,先遍历根，再遍历左子树，最后遍历右子树 
void PreOrderTraverse(BT* root){
    if(!root)
    {return ;
    }
    else{
        printf("%d",root->data);
        PreOrderTraverse(root->left);
        PreOrderTraverse(root->right);
    }
}

//中序遍历，先遍历左子树，再遍历根，最后遍历右子树 
void InOrderTraverse(BT* root){
    if(!root)
    {return ;
    }
    else{
        InOrderTraverse(root->left);
        printf("%d",root->data);
        InOrderTraverse(root->right);
    }    
} 

//后序遍历，先遍历左子树，再遍历右子树，最后遍历根 
void PostOrderTraverse(BT* root){
    if(!root)
    {return ;
    }
    else{
        PostOrderTraverse(root->left);
        PostOrderTraverse(root->right);
        printf("%d",root->data);
    }
} 
//求二叉树中结点数
int size=0;//每次调用size都要+1，所以要全局变量 
void TreeSize(BT* root)//求二叉树结点个数
{
    if (root == NULL)
    {
        return;
    }
    else
    {    
    size++;
    }
    TreeSize(root->left);
    TreeSize(root->right);
    return ;
}

//二叉树深度 
int TreeDepth(BT* root)
{    
    int m,n;
    if(root==NULL){
        return 0;
    }
    else{
        m=TreeDepth(root->left);//左子树的深度 
        n=TreeDepth(root->right);//右子树的深度 
        return m>n ? m+1 :n+1;
    }        
}
//复制一颗二叉树  判断两棵二叉树是否相等

copyTree(BT *root) //二叉树copy
{
    if (root == NULL)
        return NULL;
    BT *copyRoot = root;//本质为前序遍历的递归方法
    copyRoot->left = copyTree(root->left);
    copyRoot->right = copyTree(root->right);
    return copyRoot;
}

int main(){
    BT* root=CreatTree();
    printf("前序遍历：");
    PreOrderTraverse( root);
    printf("\n");
    printf("中序遍历：");
    InOrderTraverse( root);
    printf("\n");
    printf("后序遍历：");
    PostOrderTraverse( root);
    printf("\n");
    printf("二叉树的叶子结点数为："); 
    TreeSize( root);
    printf("%d\n",size); 
    printf("二叉树的深度为：");
    printf("%d",TreeDepth(root));
    copyTree(root);
    printf("复制树的先序遍历为：") ;
    PreOrderTraverse(copyRoot);
    return 0;
}