#include<stdio.h> //‘ ‘空格代表树的元素为空
#include<stdlib.h>
#define OVERFLOW -1
typedef char TElemType;
typedef struct BitNode
{
    TElemType data;
    struct BitNode *lchild,*rchild;
}BitNode,*BitTree;
typedef struct QNode
{
    BitNode data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;
void BinTreeInit(BitNode **BT)  //初始化二叉树
{
    *BT=NULL;
}
BitNode *BinTreeCreat(BitNode *BT) //按先序次序构造二叉树
{
    char c;
    scanf("%c",&c);
    if(c==‘ ‘)BT=NULL;
    else
    {
        if(!(BT=(BitTree)malloc(sizeof(BitNode))))
            exit(OVERFLOW);
        BT->data=c;
        BT->lchild=BinTreeCreat(BT->lchild); //注意因为有返回值，必须有左值
        BT->rchild=BinTreeCreat(BT->rchild);
    }
    return BT;
}
int BinTreeEmpty(BitNode *BT)//检查二叉树是否为空
{
    if(BT==NULL)return 1;
    else return 0;    
}
void visit(BitNode *BT) //visit函数
{
    printf("%c",BT->data);    
}
void PreOrderTraverse(BitNode *BT)//先序遍历树
{
    if(BT)
    {
    visit(BT);
    PreOrderTraverse(BT->lchild);
    PreOrderTraverse(BT->rchild);
    }
}
void InOrderTraverse(BitNode *BT)//中序遍历树
{
    if(BT)
    {
    InOrderTraverse(BT->lchild);
    visit(BT);
    InOrderTraverse(BT->rchild);
    }
}
void PostOrderTraverse(BitNode *BT)//后序遍历树
{    
    if(BT)
    {
    PostOrderTraverse(BT->lchild);
    PostOrderTraverse(BT->rchild);
    visit(BT);
    }
}
void InitQueue(LinkQueue *Q) //构造一个空的队列
{
    Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q->front)exit(OVERFLOW);
    Q->front->next=NULL;
}
int QueueEmpty(LinkQueue *Q)
{
    if(Q->rear==Q->front)return 1;
    else return 0;
}
void EnQueue(LinkQueue *Q,BitNode e) //入队
{
    QNode *p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    Q->rear->next=p;
    Q->rear=p;
}
void DeQueue(LinkQueue *Q,BitNode *e)//出队
{
    QNode *p;
    p=Q->front->next;
    *e=p->data;
    Q->front->next=p->next;
    if(Q->rear==p)Q->rear=Q->front;
    free(p);
}
void BFSTraverse(BitNode *BT)//层次遍历树
{
    BitNode m;
    LinkQueue Q;
    InitQueue(&Q);
    EnQueue(&Q,*BT);
    while(!QueueEmpty(&Q))
    {
        DeQueue(&Q,&m);
        visit(&m);
        if(m.lchild)EnQueue(&Q,*(m.lchild));
        if(m.rchild)EnQueue(&Q,*(m.rchild));
    }    
}
int BinTreeDepth(BitNode *BT)//求二叉树的深度
{
    int dep1,dep2;
    if(BT==NULL)return 0;
    else 
    {
        dep1=BinTreeDepth(BT->lchild);
        dep2=BinTreeDepth(BT->rchild);
        if(dep1>dep2)return 1+dep1;
        else return 1+dep2;
    }
}
void BinCountleaf(BitNode *BT,int *count)//求二叉树的叶子节点的个数
{
    if(BT)
    {
        if(!BT->lchild&&!BT->rchild)(*count)++;
        BinCountleaf(BT->lchild,count);
        BinCountleaf(BT->rchild,count);
    }        
}
void BinTreeClear(BitNode **BT)//清除二叉树
{
    if(*BT)
    {
        BinTreeClear(&(*BT)->lchild);
        BinTreeClear(&(*BT)->rchild);
        free(*BT);
        *BT=NULL;
    }
}
int main()
{
    int count=0;
    BitNode *BT=NULL;
    BinTreeInit(&BT); //初始化二叉树
    BT=BinTreeCreat(BT);//构造二叉树
    printf("执行创建树操作后: ");
    if(BinTreeEmpty(BT))printf("树空\n");//判空
    else printf("树不空\n");
    printf("先序遍历二叉树: ");
    PreOrderTraverse(BT);printf("\n");
    printf("中序遍历二叉树: ");
    InOrderTraverse(BT);printf("\n");
    printf("后序遍历二叉树: ");
    PostOrderTraverse(BT);printf("\n");
    printf("层次遍历二叉树: ");
    BFSTraverse(BT);printf("\n");
    printf("二叉树的深度为:%d\n",BinTreeDepth(BT));//求二叉树的深度
    BinCountleaf(BT,&count);//求二叉树中的节点个数
    printf("二叉树的叶子节点个数为:%d\n",count);
    BinTreeClear(&BT);//清空树
    printf("执行清空树操作后: ");
    if(BinTreeEmpty(BT)==1)printf("树空\n");//判空
    else printf("树不空\n");

    return 0;
}　　　　　　　　　　


 或者将构造二叉树的操作改为，main函数里对此函数的调用扫做修改即可：

void BinTreeCreat(BitNode **BT) //按先序次序构造二叉树
{
	char c;
	scanf("%c",&c);
	if(c==‘ ‘)*BT=NULL;//此处曾把‘*‘漏掉
	else
	{
		if(!((*BT)=(BitTree)malloc(sizeof(BitNode))))
			exit(OVERFLOW);
		(*BT)->data=c;
		printf("%c",(*BT)->data);
		BinTreeCreat(&(*BT)->lchild); 
		BinTreeCreat(&(*BT)->rchild);
	}
}

#include "string.h"  
#include "stdio.h"      
#include "stdlib.h"     
#include "io.h"    
#include "math.h"    
#include "time.h"  
  
#define OK 1  
#define ERROR 0  
#define TRUE 1  
#define FALSE 0  
#define MAXSIZE 100                             /* 存储空间初始分配量 */  
  
typedef int Status;                             /* Status是函数的类型,其值是函数结果状态代码，如OK等 */  
  
/**********定义二叉树的存储结构************/  
typedef char TElemType;  
TElemType Nil=‘ ‘;                              /* 字符型以空格符为空 */  
  
typedef struct BinTreeNode                      /* 结点结构 */  
{  
    TElemType data;                             /* 结点数据 */  
    struct BinTreeNode *lchild,*rchild;         /* 左右孩子指针 */  
}BinTreeNode,*BinTree;  
/*****************************************/  
  
/***********用于构造二叉树************** */  
int index=1; 
//自定义了一个字符数组类型 
typedef char charArray[24];                     /*声明一个char类型数组,charArray是数组名也是一个指针*/  
charArray str;									//str字符数组类型的数组名，charArray等价于char *  
  
Status AssignStr(charArray T,char *chars)		//char *chars是字符类型的指针变量
{   
    int i;  
    if(strlen(chars)>MAXSIZE) return ERROR;     /*输入字符的长度超过存储空间最大值*/  
    else  
    {  
        T[0]=strlen(chars);                     /*0号单元存放字符串长度*/  
        for(i=1;i<=T[0];i++)  
        {  
            T[i]=*(chars+i-1);					//先将数据进行存储               
        }   
        return OK;
    }  
}  
/* ************************************* */  
  
/*构造二叉树*/  
void CreateBinTree(BinTree *T)  
{   
    TElemType ch;  
    ch=str[index++];  

    if(ch==‘#‘)   
        *T=NULL;  
    else  
    {  
        *T=(BinTree)malloc(sizeof(BinTreeNode));  
        if(!*T)  
            exit(OVERFLOW);  
        (*T)->data=ch;                            /* 生成根结点 */  
        CreateBinTree(&(*T)->lchild);             /* 构造左子树 */  
        CreateBinTree(&(*T)->rchild);             /* 构造右子树 */  
    }  
}  
  
/* 构造空二叉树*/  
Status InitBinTree(BinTree *T)  
{   
    *T=NULL;  
    return OK;  
}  
  
/*清空二叉树*/  
void ClearBinTree(BinTree *T)  
{   
    if(*T)   
    {  
        if((*T)->lchild)                           /* 有左孩子 */  
            ClearBinTree(&(*T)->lchild);           /* 销毁左孩子子树 */  
        if((*T)->rchild)                           /* 有右孩子 */  
            ClearBinTree(&(*T)->rchild);           /* 销毁右孩子子树 */  
        free(*T);                                  /* 释放根结点 */  
        *T=NULL;                                   /* 空指针赋0 */  
    }  
}  
  
/*判断二叉树是否为空*/  
Status IsBinTreeEmpty(BinTree T)  
{   
    if(T)  
        return FALSE;  
    else  
        return TRUE;  
}  
  
/*计算二叉树的深度*/  
int GetDepth(BinTree T)  
{  
    int i,j;  
    if(!T)  
        return 0;  
    if(T->lchild)  
        i=GetDepth(T->lchild);  
    else  
        i=0;  
    if(T->rchild)  
        j=GetDepth(T->rchild);  
    else  
        j=0;  
    return i>j?i+1:j+1;  
}  
  
/*获取二叉树的根节点*/  
TElemType GetRoot(BinTree T)  
{   
    if(IsBinTreeEmpty(T))  
        return Nil;                                 /*Nil表示空字符*/  
    else  
        return T->data;  
}  
  
/*前序遍历 
思路：访问根节点--->前序遍历左子树--->前序遍历右子树 
*/  
void PreOrderTraverse(BinTree T)  
{   
    if(T==NULL) return;  
  
    printf("%c ",T->data);                           /* 显示结点数据，可以更改为其它对结点操作 */  
    PreOrderTraverse(T->lchild);                     /* 再先序遍历左子树 */  
    PreOrderTraverse(T->rchild);                     /* 最后先序遍历右子树 */  
}  
  
/*中序遍历 
思路：中序遍历左子树--->访问根节点--->中序遍历右子树 
*/  
void InOrderTraverse(BinTree T)  
{   
    if(T==NULL) return;  
  
    InOrderTraverse(T->lchild);                       /* 中序遍历左子树 */  
    printf("%c ",T->data);                            /* 显示结点数据，可以更改为其它对结点操作 */  
    InOrderTraverse(T->rchild);                       /* 最后中序遍历右子树 */  
}  
  
/*后序遍历 
思路：后序遍历左子树--->后序遍历右子树--->访问根节点 
*/  
void PostOrderTraverse(BinTree T)  
{  
    if(T==NULL) return;  
  
    PostOrderTraverse(T->lchild);                      /* 先后序遍历左子树  */  
    PostOrderTraverse(T->rchild);                      /* 再后序遍历右子树  */  
    printf("%c ",T->data);                             /* 显示结点数据，可以更改为其它对结点操作 */  
}  
  
  
int main()  
{  
    int i;  
    BinTree T;  
    TElemType e1;  
  
    /*初始化二叉树为一棵空树*/  
    InitBinTree(&T);  
  
    /*设置字符数组用于构造二叉树*/  
    AssignStr(str,"ABDH#K###E##CFI###G#J##"); 
	
    /*创建二叉树*/  
    CreateBinTree(&T);  
    printf("创建二叉树后,树空否？%d(1:是 0:否) 树的深度为：%d\n",IsBinTreeEmpty(T),GetDepth(T));  
  
    /*获取二叉树的根节点*/  
    e1=GetRoot(T);  
    printf("\n二叉树的根为: %c\n",e1);  
  
    /*前序遍历*/  
    printf("\n前序遍历二叉树:");  
    PreOrderTraverse(T);  
  
    /*中序遍历*/  
    printf("\n中序遍历二叉树:");  
    InOrderTraverse(T);  
  
    /*后序遍历*/  
    printf("\n后序遍历二叉树:");  
    PostOrderTraverse(T);  
  
    /*清空二叉树*/  
    ClearBinTree(&T);  
    printf("\n\n清除二叉树后,树空否？%d(1:是 0:否) 树的深度为：%d\n",IsBinTreeEmpty(T),GetDepth(T));  
    i=GetRoot(T);  
    if(!i) printf("树空，无根\n");  
  
    getchar();  
}