int BinTreeIsEmpty(ChainBinTree* bt) //检查是否为空
{
    if (bt)
        return 0;
    else
        return 1;
}

int BinTreeDepth(ChainBinTree* bt) //得到深度
{
    int dep1, dep2;
    if(bt==NULL)
        return 0;
    else
    {
        dep1 = BinTreeDepth(bt->left);
        dep2 = BinTreeDepth(bt->right);
        if (dep1 > dep2)
            return dep1 + 1;
        else
            return dep2 + 1;
    }
}

6.二叉树的查找

ChainBinTree* BinTreeFind(ChainBinTree* bt, DATA data)
{
    ChainBinTree* p;
    if(bt==NULL)
      return NULL;
    else
    {
        if (bt->data == data)
            return bt;
        else {
            if (p = BinTreeFind(bt->left, data))
                return p;
            else if (p = BinTreeFind(bt->left, data))
                return p;
            else
                return NULL;
        }
    }
}

7.二叉树的清空

因为是malloc所申请的内存，因此要用free函数来释放所占内存。

void BinTreeClear(ChainBinTree* bt)
{
    if (bt)
    {
        BinTreeClear(bt->left);
        BinTreeClear(bt->right); //清空左右结点
        free(bt); //释放当前结点
        bt = NULL;
    }
    return;
}

五，二叉树的遍历

1.先序遍历

则遵循以下的code原则

void BinTree_DLR(ChainBinTree* bt, void(*poer)(ChainBinTree* p))
{
    if (bt)
    {
        oper(bt); 
        BinTree_DLR(bt->left, oper);
        BinTree_DLR(bt->right, oper);
    }
    return;
}

2.中序遍历

void BinTree_LDR(ChainBinTree* bt, void(*poer)(ChainBinTree* p))
{
    if (bt)       //树不为空
    {
        
        BinTree_LDR(bt->left, oper);//中序遍历
        oper(bt);
        BinTree_LDR(bt->right, oper);
    }
    return;
}

3.后序遍历

void BinTree_LRD(ChainBinTree* bt, void(*poer)(ChainBinTree* p))
{
    if (bt)       //树不为空
    {

        BinTree_LDR(bt->left, oper);//中序遍历
        BinTree_LDR(bt->right, oper);
        oper(bt);
    }
    return;
}

4.按层遍历

void BinTree_level(ChainBinTree* bt, void(*poer)(ChainBinTree* p))
{
    ChainBinTree* p;
    ChainBinTree* q[QUEUE_MAXSIZE];
    int head = 0, tail = 0;
    if (bt)
    {
        tail = (tail + 1) % QUEUE_MAXSIZE; //上一节的那一套
        q[tail] = bt;
    }
    while (head != tail)
    {
        head = (head + 1) % QUEUE_MAXSIZE;
        p = q[head];
        oper(p);
        if (p->left != NULL)
        {
            tail = (tail + 1) % QUEUE_MAXSIZE;
            q[tail] = p->left;
        }
        if (p->right != NULL)
        {
            tail = (tail + 1) % QUEUE_MAXSIZE;
            q[tail] = p->right;
        }
    }
    return;
}

六,全部代码

BinTree函数部分

#include "Bintree.h"

void oper(ChainBinTree* p)
{
    printf("%c ", p->data);
    return;
}

ChainBinTree* BinTreeInit(ChainBinTree* node)
{
    if (node != NULL) //节点不为空
        return node;
    else
    return NULL;
}

int BinTreeAddNode(ChainBinTree* bt, ChainBinTree* node, int n)
{
    if (bt == NULL)
    {
        printf("父节点不存在，请先设置父节点！\n");
        return 0;
    }
    switch (n)
    {
    case 1: if (bt->left) {
        printf("左子树结点不为空！\n");
        return 0;
    }else
        bt->left = node;
        break;
    case 2:  if (bt->right) {
        printf("右子树结点不为空！\n");
        return 0;
    }else
        bt->right = node;
        break;
    default:
        printf("参数错误！\n");
        return 0;
    }
    return 1;
}

ChainBinTree* BinTreeLeft(ChainBinTree* bt)
{
    if (bt)
        return bt->left;
    else
        return NULL;
}

ChainBinTree* BinTreeRight(ChainBinTree* bt)
{
    if (bt)
        return bt->right;
    else
        return NULL;
}

int BinTreeIsEmpty(ChainBinTree* bt)
{
    if (bt)
        return 0;
    else
        return 1;
}

int BinTreeDepth(ChainBinTree* bt)
{
    int dep1, dep2;
    if(bt==NULL)
        return 0;
    else
    {
        dep1 = BinTreeDepth(bt->left);
        dep2 = BinTreeDepth(bt->right);
        if (dep1 > dep2)
            return dep1 + 1;
        else
            return dep2 + 1;
    }
}

ChainBinTree* BinTreeFind(ChainBinTree* bt, DATA data)
{
    ChainBinTree* p;
    if(bt==NULL)
      return NULL;
    else
    {
        if (bt->data == data)
            return bt;
        else {
            if (p = BinTreeFind(bt->left, data))
                return p;
            else if (p = BinTreeFind(bt->left, data))
                return p;
            else
                return NULL;
        }
    }
}

void BinTreeClear(ChainBinTree* bt)
{
    if (bt)
    {
        BinTreeClear(bt->left);
        BinTreeClear(bt->right); //清空左右结点
        free(bt); //释放当前结点
        bt = NULL;
    }
    return;
}

void BinTree_DLR(ChainBinTree* bt, void(*poer)(ChainBinTree* p))
{
    if (bt)
    {
        oper(bt); 
        BinTree_DLR(bt->left, oper);
        BinTree_DLR(bt->right, oper);
    }
    return;
}

void BinTree_LDR(ChainBinTree* bt, void(*poer)(ChainBinTree* p))
{
    if (bt)       //树不为空
    {
        
        BinTree_LDR(bt->left, oper);//中序遍历
        oper(bt);
        BinTree_LDR(bt->right, oper);
    }
    return;
}

void BinTree_LRD(ChainBinTree* bt, void(*poer)(ChainBinTree* p))
{
    if (bt)       //树不为空
    {

        BinTree_LDR(bt->left, oper);//中序遍历
        BinTree_LDR(bt->right, oper);
        oper(bt);
    }
    return;
}

void BinTree_level(ChainBinTree* bt, void(*poer)(ChainBinTree* p))
{
    ChainBinTree* p;
    ChainBinTree* q[QUEUE_MAXSIZE];
    int head = 0, tail = 0;
    if (bt)
    {
        tail = (tail + 1) % QUEUE_MAXSIZE; //上一节的那一套
        q[tail] = bt;
    }
    while (head != tail)
    {
        head = (head + 1) % QUEUE_MAXSIZE;
        p = q[head];
        oper(p);
        if (p->left != NULL)
        {
            tail = (tail + 1) % QUEUE_MAXSIZE;
            q[tail] = p->left;
        }
        if (p->right != NULL)
        {
            tail = (tail + 1) % QUEUE_MAXSIZE;
            q[tail] = p->right;
        }
    }
    return;
}

BinTree.h

#include <stdio.h>
#include <stdlib.h>
#define QUEUE_MAXSIZE 50
typedef char DATA;
typedef struct ChainTree
{
	DATA data;
	struct ChainTree* left;
	struct ChainTree* right;
}ChainBinTree;
void oper(ChainBinTree* p);
ChainBinTree* BinTreeInit(ChainBinTree* node); //初始化
int BinTreeAddNode(ChainBinTree* bt, ChainBinTree* node, int n); //添加到二叉树
ChainBinTree* BinTreeLeft(ChainBinTree* bt); //返回左子节点
ChainBinTree* BinTreeRight(ChainBinTree* bt); //返回左子节点
int BinTreeIsEmpty(ChainBinTree* bt); //检验是否为空
int BinTreeDepth(ChainBinTree* bt); //求深度
ChainBinTree* BinTreeFind(ChainBinTree* bt, DATA data);
void BinTreeClear(ChainBinTree* bt);
//void BinTree_DLR(BinTree);
void BinTree_DLR(ChainBinTree* bt, void(*poer)(ChainBinTree* p));
void BinTree_LDR(ChainBinTree* bt, void(*poer)(ChainBinTree* p));
void BinTree_LRD(ChainBinTree* bt, void(*poer)(ChainBinTree* p));
void BinTree_level(ChainBinTree* bt, void(*poer)(ChainBinTree* p));

BinTree.c（main函数部分）

#include <stdio.h>
#include "Bintree.h"

ChainBinTree* InitRoot()
{
	ChainBinTree* node;
	
	if (node = (ChainBinTree*)malloc(sizeof(ChainBinTree)))
	{
		printf("\n输入根节点数据：");
		scanf("%s", &node->data);
		node->left = NULL;
		node->right = NULL;
		return node;	
	}
	return NULL;
}
void AddNode(ChainBinTree* bt)
{
	ChainBinTree* node, * parent;
	DATA data;
	char select;
	if (node = (ChainBinTree*)malloc(sizeof(ChainBinTree)))
	{
		printf("\n输入二叉树的结点数据：");
		fflush(stdin);
		scanf("%s", &node->data);
		node->left = NULL;
		node->right = NULL;
		printf("输入父结点数据：");
		fflush(stdin);
		scanf("%s", &data);
		parent = BinTreeFind(bt, data);
		if (!parent)
		{
			printf("未找到父结点！\n");
			free(node);
			return;
		}
		printf("1.添加到左子树\n 2.添加到右子树\n");
		do {
			select = getchar();
			select -= '0';
			if (select == '1' || select == '2')
				BinTreeAddNode(parent, node, select);
		} while (select != 1 && select != 2);
	}
	return;
}
int main()
{
	ChainBinTree* root = NULL;
	char select;
	void (*oper1)(ChainTree*); //指向集体的指针
	oper1 = &oper;  //指向具体的操作函数
	do {
		printf("\n1.设置二叉树根元素  2.添加二叉树结点\n");
		printf("3.先序遍历           4.中序遍历\n");
		printf("5.后序遍历           6.按层遍历\n");
		printf("7.二叉树的深度        0.退出\n");
		select = getchar();
		switch (select) {
		case '1': root = InitRoot(); break;
		case '2':AddNode(root); break;
		case '3': 
			printf("\n先遍历的结果：");
			BinTree_DLR(root,oper1);
			printf("\n");
			break;
		case '4':
			printf("\n中序遍历的结果：");
			BinTree_LDR(root, oper1);
			printf("\n");
			break;
		case '5':
			printf("\n中序遍历的结果：");
			BinTree_LRD(root, oper1);
			printf("\n");
			break;
		case '6':
			printf("\n中序遍历的结果：");
			BinTree_level(root, oper1);
			printf("\n");
			break;
		case '7': printf("\n二叉树的深度为：%d\n", BinTreeDepth(root)); break;
		case '0': break;
		}
	} while (select != '0');
	BinTreeClear(root);
	root = NULL;
	getchar();
	return 0;

}

运行

 那个做着做着太累喽，后边就在凑合了，下次要注意我的篇幅和详细和略过的点，我会注意的，我能力有限，只能写道这个部分，谢谢阅读。