二叉搜索树（遍历，查找，插入，删除）

二叉搜索树就类似于二分查找，根节点的左边都比根结点小，右边都比根结点大。

#include<stdio.h>
#include<stdlib.h>

typedef int TElemType;
typedef int ElemType;
#define OK 1
#define ERROR -1

typedef struct BiTNode
{
    TElemType data;
    struct BiTNode* lchild;
    struct BiTNode* rchild;
}BiTNode,*BiTree;
//前序遍历创建二叉树
void PreOrderCreatBiTree(BiTree *T)
{
    int ch;
    scanf("%d", &ch);
    if (ch == 0)
    {
        *T = NULL;
    }
    else
    {
        *T = (BiTNode *)malloc(sizeof(BiTNode));
        (*T)->data = ch;
        PreOrderCreatBiTree(&(*T)->lchild);
        PreOrderCreatBiTree(&(*T)->rchild);
    }
}
//前序遍历
void PreOrderTarverse(BiTree T)
{
    if (T)
    {
        printf("%d", T->data);
        PreOrderTarverse(T->lchild);
        PreOrderTarverse(T->rchild);
    }
}
//查找元素
int Find(ElemType x, BiTree T)
{
    if (!T)  //如果树为空
        return ERROR;
    if (x > T->data)
    {
        return Find(x, T->rchild);
    }
    else if (x < T->data)
    {
        return Find(x, T->lchild);
    }
    else if(x == T->data)
    {
        return OK;
    }
    return ERROR;
}
//查找最小值并返回值
int FindMin(BiTree T)
{
    if (!T)  //如果树为空
    {
        return ERROR;
    }
    else if (!T->lchild)
    {
        return T->data;
    }
    else
    {
        return FindMin(T->lchild);
    }
}
//查找最小值并返回地址
BiTree FindMinAddress(BiTree T)//删除使用到
{
    if (!T)  //如果树为空
    {
        return NULL;
    }
    else if (!T->lchild)
    {
        return T;
    }
    else
    {
        return FindMin(T->lchild);
    }
}
//查找最大值并返回值
int FindMax(BiTree T)
{
    if (T)
    {
        while (T->rchild)
        {
            T = T->rchild;
        }
    }
    return T->data;
}
//插入
BiTree Insert(BiTree *T, ElemType x)
{
    if (!(*T))  //数为空，则生成并返回一个结点的搜索二叉树
    {
        *T = (BiTNode *)malloc(sizeof(BiTNode));
        (*T)->data = x;
        (*T)->lchild = (*T)->rchild = NULL;
    }
    else  //开始找要插入元素的位置
    {
        if (x < (*T)->data)
        {
            (*T)->lchild = Insert(&(*T)->lchild, x);  //递归插入左子树
        }
        else if (x > (*T)->data)
        {
            (*T)->rchild = Insert(&(*T)->rchild, x);  //递归插入右子树    
        }
        //else x已经存在，什么都不做
    }
    return *T;
}
//删除
BiTree Delete(BiTree* T, ElemType x)
{
    BiTree Tmp;

    if (!(*T))
    {
        printf("要删除的元素未找到");
    }
    else
    {
        if (x < (*T)->data) //递归左子树
        {
            (*T)->lchild = Delete(&(*T)->lchild, x);
        }
        else if (x > (*T)->data) //递归右子树
        {
            (*T)->rchild = Delete(&(*T)->rchild, x);
        }
        else  //递归到要删除的结点
        {
            if ((*T)->lchild && (*T)->rchild)  //被删除结点有两个子树
            {
                Tmp = FindMinAddress((*T)->rchild);
                (*T)->data = Tmp->data;
                (*T)->rchild = Delete(&(*T)->rchild, (*T)->data);
            }
            else
            {
                Tmp = *T;
                if (!(*T)->lchild) //只有右孩子或者没有子结点
                {
                    *T = (*T)->rchild;
                }
                else
                {
                    *T = (*T)->lchild;
                }
                free(Tmp);
            }

        }
    }
    return *T;
}

int main()
{
    BiTree T = NULL;
    int FindNum;
    int temp;
    int min,max;
    int InsertNum;
    int DeleteNum;

    printf("请输入数据，0表示空
");
    PreOrderCreatBiTree(&T);
    printf("前序遍历二叉树并打印：
");
    PreOrderTarverse(T);

    printf("
请输入你想要查找的元素:");
    scanf("%d", &FindNum);
    temp = Find(FindNum,T);
    if (temp == 1)
    {
        printf("查找成功！你所要查找的数据在树中
");
    }
    else if(temp == -1)
    {
        printf("查找失败!你所要查找的数据不在树中
");
    }

    min = FindMin(T);
    printf("树中的最小值是：%d
", min);
    max = FindMax(T);
    printf("树中的最大值是：%d
", max);

    printf("请输入你想要插入的数据：");
    scanf("%d", &InsertNum);
    Insert(&T, InsertNum);
    printf("插入后遍历树并打印:
");
    PreOrderTarverse(T);

    printf("
请输入你想要删除的数据：");
    scanf("%d", &DeleteNum);
    Delete(&T, DeleteNum);
    printf("删除后遍历树并打印：
");
    PreOrderTarverse(T);

    return 0;
}