二叉查找树的建立，删除，非递归和递归查找给定元素，非递归和递归查找最大元素结点和最小元素结点

二叉查找树的建立：

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

typedef int ElementType;
typedef struct TNode* Position;
typedef Position BinSeaTree;
struct TNode {
    ElementType Data;
    BinSeaTree Left;
    BinSeaTree Right;
};

递归查找给定元素

Position FindRec(BinSeaTree BST, ElementType X)
{
    if (!BST)
        return NULL;
    if (X > BST->Data)
        return FindRec(BST->Right, X);        //在右子树中查找
    else if (X < BST->Data)
        return FindRec(BST->Left, X);        //在左子树中查找
    else
        return BST;
}

非递归查找给定元素：

Position FindNoRec(BinSeaTree BST, ElementType X)
{
    while (BST)
    {
        if (X > BST->Data)
            BST = BST->Right;        //向右子树移动，继续查找
        else if (X < BST->Data)
            BST = BST->Left;        //向左子树移动，继续查找
        else
            break;            //找到了则跳出循环

    }
    return BST;        //返回找到的结点地址，或者是NULL
}

递归查找最小元素结点

Position FindMin(BinSeaTree BST)
{
    if (!BST)
        return NULL;            //空的二叉搜索树，返回NULL
    else if (!BST->Left)                //找到最左端并返回
        return BST;
    else
        return FindMin(BST->Left);        //沿左分支继续递归查找

}

非递归查找最大元素结点：

//查找最大元素的非递归实现
Position FindMax(BinSeaTree BST)
{
    if (BST)
    while (BST->Right)
        BST = BST->Right;
    return BST;
}

插入一个结点：

BinSeaTree Insert(BinSeaTree BST, ElementType X)
{
    if (!BST)
    {
        BST = (BinSeaTree)malloc(sizeof(struct TNode));
        BST -> Data  = X;
        BST->Left = BST->Right = NULL;
    }
    else
    {
        if (X < BST -> Data)
            BST->Left = Insert(BST->Left, X);        //递归插入到左子树
        else if (X > BST->Data)
            BST->Right = Insert(BST->Right, X);        //递归插入到右子树
    }
    return BST;
}

删除给定元素的结点：

1.要删除的结点有两个孩子结点 

2.要删除的结点只有一个孩子结点

3.要删除的结点没有孩子结点

//二叉搜索树的删除
BinSeaTree Delete(BinSeaTree BST, ElementType X)
{
    Position tmp;
    if (!BST)
        printf("The element to delte was not found
");
    else
    {
        if (X > BST->Data)
            BST->Right = Delete(BST->Right, X);        //从右子树中递归删除
        else if (X < BST->Data)
            BST->Left = Delete(BST->Left, X);        //从左子树中递归删除
        else
        {
            if (BST->Left && BST->Right)
            {
                tmp = FindMax(BST->Left);            //从左子树中找最大的元素填充删除结点
                BST->Data = tmp->Data;
                BST->Left = Delete(BST->Left, tmp->Data);        //将删除给定元素的左子树绑定到左子树上
            }
            else
            {
                tmp = BST;
                if (!BST->Left)                //只有右孩子或无子节点
                    BST = BST->Right;
                else
                    BST = BST->Left;
                free(tmp);
            }
        }
    }
    return BST;                        //将删除给定元素的二叉树返回回去
}

用来测试的其他函数和主函数：

void printBinTree(BinSeaTree BT, int depth)
{
    for (int i = 0; i < depth; i++)
        printf("  ");
    printf("%d
", BT->Data);
}

void InorderTraversal(BinSeaTree BT, int depth)
{
    if (BT)
    {
        InorderTraversal(BT->Right, depth + 1);
        printBinTree(BT, depth);
        InorderTraversal(BT->Left, depth + 1);
    }
}

int main()
{
    BinSeaTree BST = NULL;
    BinSeaTree node;
    ElementType dt;
    for (int i = 0; i < 7; i++)
    {
        scanf_s("%d", &dt);
        BST = Insert(BST, dt);
        getchar();
    }
    InorderTraversal(BST, 0);
    node = FindMin(BST);
    printf("

%d
", node->Data);
    node = FindMax(BST);
    printf("

%d
", node->Data);

    BST = Delete(BST, 41);
    InorderTraversal(BST, 0);

    return 0;
}