2021-10-12

二叉搜索树

typedef struct bst
{
    int val;
    struct bst *left;
    struct bst *right;
}*BST;
BST Troot;
//创建二叉搜索树
BST creat(BST Troot, int v)
{
    Troot=(BST)malloc(sizeof(struct bst));
    Troot->val=v;
    Troot->left=Troot->right=NULL;
    return Troot;
}
//递归
BST Find(BST Troot, int v)
{
    if(!Troot)return NULL;
    if(v>Troot->val)
        return Find(Troot->right, v);
    else if(v<Troot->val)
        return Find(Troot->left, v);
    else
        return Troot;
}
//非递归
BST Find2(BST Troot, int v)
{
    while(Troot)
    {
        if(v>Troot->val)
            Troot=Troot->right;
        else if(v<Troot->val)
            Troot=Troot->left;
        else
            return Troot;
    }
    return NULL;

}
//找最小值
BST FindMin(BST Troot)
{
    if(!Troot->left)
        return Troot;
    else
        return FindMin(Troot->left);
}
//找最大值
BST FindMax(BST Troot)
{
    if(Troot)
    {
        while(Troot->right) Troot=Troot->right;
    }
    return Troot;
}
//插入递归
BST Insert(int v, BST Troot)
{
    if(!Troot)
    {
        Troot=(BST)malloc(sizeof(struct bst));
        Troot->val=v;
        Troot->left=Troot->right=NULL;
    }else
    {
        if(v>Troot->val)
            Troot->right=Insert(v,Troot->right);
        else if(v<Troot->val)
            Troot->left=Insert(v, Troot->left);
    }
    return Troot;
}
//插入非递归
void Insert2(int v, BST Troot)
{
    if(!Troot)
    {
        Troot->val=v;return;
    }
    BST node=(BST)malloc(sizeof(struct bst));
    node->val=v;
    node->left=node->right=NULL;
    while(Troot)
    {
        if(v>Troot->val)
        {
            if(!Troot->right)
            {
                Troot->right=node;return;
            }

            else
                Troot=Troot->right;
        }else if(v<Troot->left)
        {
            if(!Troot->left)
            {
                Troot->left=node;return;
            }
            else
                Troot=Troot->left;
        }
    }
}
//删除节点
BST Delete(BST Troot, int v)
{
    BST temp;
    if(!Troot)
        printf("要删除的没找到");
    else if(v>Troot->val)
    {
        Troot->right=Delete(Troot->right, v);//右子树递归删除
    }else if(v<Troot->left)
    {
        Troot->left=Delete(Troot->left, v);//左子树递归删除
    }else
    {
        if(Troot->left && Troot->right)//删除的数有俩个节点
        {
            temp=FindMin(Troot->right);//找出右子树的最小值
            Troot->val=temp->val;//替换
            Troot->right=Delete(Troot->right, temp->val);//删除右子树的最小值
        }else
        {
            temp=Troot;
            if(!Troot->left)//有右节点或无节点
                Troot=Troot->right;
            else
                Troot=Troot->left;//有左节点或无节点
            free(temp);

        }
    }
    return Troot;//返回节点给父节点

}

二叉搜索树一般采用递归和非递归实现，但是相对来说递归实现较好。