二叉树

二叉树操作1

#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);
	}
}

二叉树操作2

#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();
}