二叉排序树

1.和次优查找树相对，二叉排序树是一种动态树表。

2.二叉排序树的结构通常不是一次生成的，而是在查找过程中，当树中不存在关键字等于给定值的结点时再进行插入。

3.含有n条记录的二叉查找树平均查找长度：

4.实现：

二叉排序树的查找

int SearchBST(BTree T, BTree* P, int key)//非递归查找二叉排序树
{
    BTree Pre = NULL;
    (*P) = T;
    while (*P)
    {
        if ((*P)->data == key)
        {
            return 1;
        }
        else if ((*P)->data < key)//右子树
        {
            Pre = (*P);
            (*P) = (*P)->Rchild;
        }
        else//左子树
        {
            Pre = (*P);
            (*P) = (*P)->Lchild;
        }
    }
    (*P) = Pre;
    return 0;
}

二叉排序树的插入

void InsertBST(BTree* T, int key)
{
    BTree P = NULL, S = NULL;
    if (!SearchBST((*T), &P, key))
    {
        BTree S = (BTree)calloc(1, sizeof(BTNode));
        S->data = key;
        S->Lchild = S->Rchild = NULL;
        if (!P)//二叉排序树T中一个记录都没有
        {
            (*T) = S;
        }
        else if (P->data < key)
        {
            P->Rchild = S;
        }
        else
        {
            P->Lchild = S;
        }
    }
}

二叉排序树的删除

实现步骤：

①查找关键字等于key的结点，保存指向待删结点的指针P和其双亲结点F；

②当指针P为空，则不存在该记录、无需删除；

③当P没有左孩子且其双亲结点F为空，说明二叉排序树中只有待删除的结点，直接置空树；

④当P没有左孩子且其双亲结点F存在，若P是F的左孩子时，令F的左孩子指向P的右孩子；若P是F的右孩子时，令F的右孩子指向P的右孩子；

⑤当P有左孩子，令指针S指向P的前驱结点、指针F指向S的双亲结点，再把S指向的记录域赋给P的记录域，最后把F的右子树指向S的左子树。

void DeleteBST(BTree* T, int key)
{
    BTree P = NULL, F = NULL, S = NULL;
    //查找
    P = (* T);
    while (P)
    {
        if (P->data == key)
        {
            break;
        }
        else if (P->data < key)
        {
            F = P;
            P = P->Rchild;
        }
        else
        {
            F = P;
            P = P->Lchild;
        }
    }
    if (!P)//查找失败
    {
        return;
    }

    if (!P->Lchild)//待删除结点没有左孩子
    {
        if (!F)
        {
            (*T) = P->Rchild;
        }
        else if (F->Lchild == P)
        {
            F->Lchild = P->Rchild;
        }
        else
        {
            F->Rchild = P->Rchild;
        }
        free(P);
    }
    else//待删除结点有左孩子，用待删除结点P的前继结点S替代P
    {
        F = P;
        S = P->Lchild;
        while (S->Rchild)
        {
            F = S;
            S = S->Rchild;
        }
        P->data = S->data;
        if (F != P)
        {
            F->Rchild = S->Lchild;
        }
        else
        {
            F->Lchild = S->Lchild;
        }
        free(S);
    }
}

5.源代码

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

typedef struct Node
{
    int data;
    struct Node *Lchild, *Rchild;
}BTNode, *BTree;

int SearchBST(BTree T, BTree* P, int key)//非递归查找二叉排序树
{
    BTree Pre = NULL;
    (*P) = T;
    while (*P)
    {
        if ((*P)->data == key)
        {
            return 1;
        }
        else if ((*P)->data < key)//右子树
        {
            Pre = (*P);
            (*P) = (*P)->Rchild;
        }
        else//左子树
        {
            Pre = (*P);
            (*P) = (*P)->Lchild;
        }
    }
    (*P) = Pre;
    return 0;
}

void InsertBST(BTree* T, int key)
{
    BTree P = NULL, S = NULL;
    if (!SearchBST((*T), &P, key))
    {
        BTree S = (BTree)calloc(1, sizeof(BTNode));
        S->data = key;
        S->Lchild = S->Rchild = NULL;
        if (!P)//二叉排序树T中一个记录都没有
        {
            (*T) = S;
        }
        else if (P->data < key)
        {
            P->Rchild = S;
        }
        else
        {
            P->Lchild = S;
        }
    }
}

void InitBST(BTree* T)
{
    int key = 0;
    FILE* fp = fopen("D:\\C\\数据结构与算法\\7.查找\\test case.txt", "r"); 
    while (EOF != fscanf(fp, "%d", &key))
    {
        InsertBST(&(*T), key);
    }
}

void DeleteBST(BTree* T, int key)
{
    BTree P = NULL, F = NULL, S = NULL;
    //查找
    P = (* T);
    while (P)
    {
        if (P->data == key)
        {
            break;
        }
        else if (P->data < key)
        {
            F = P;
            P = P->Rchild;
        }
        else
        {
            F = P;
            P = P->Lchild;
        }
    }
    if (!P)//查找失败
    {
        return;
    }

    if (!P->Lchild)//待删除结点没有左孩子
    {
        if (!F)
        {
            (*T) = P->Rchild;
        }
        else if (F->Lchild == P)
        {
            F->Lchild = P->Rchild;
        }
        else
        {
            F->Rchild = P->Rchild;
        }
        free(P);
    }
    else//待删除结点有左孩子，用待删除结点P的前继结点S替代P
    {
        F = P;
        S = P->Lchild;
        while (S->Rchild)
        {
            F = S;
            S = S->Rchild;
        }
        P->data = S->data;
        if (F != P)
        {
            F->Rchild = S->Lchild;
        }
        else
        {
            F->Lchild = S->Lchild;
        }
        free(S);
    }
}

int main(void)
{
    int key = 0;
    BTree T = NULL, P = NULL;
    InitBST(&T);

    printf("请输入待查找的关键字：");
    scanf("%d", &key);
    if (SearchBST(T, &P, key))
    {
        printf("查找成功\n");
    }
    else
    {
        printf("查找失败\n");
    }

    printf("请输入待删除记录的关键字：");
    scanf("%d", &key);
    DeleteBST(&T, key);

    printf("请输入待查找的关键字：");
    scanf("%d", &key);
    if (SearchBST(T, &P, key))
    {
        printf("查找成功");
    }
    else
    {
        printf("查找失败");
    }
    return 0;
}