二叉排序树插入，查找，删除操作

最新推荐文章于 2024-05-13 11:13:07 发布
最新推荐文章于 2024-05-13 11:13:07 发布
阅读量2.1k 收藏 48
点赞数 5
分类专栏： 数据结构一些算法实现 文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Powerking666/article/details/118881652
版权

二叉排序树

二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树
性质：左子树<根<右子树。（比较的是值）。
中序遍历结果是有序的。

示例图

在这里插入图片描述
（图来自小甲鱼学习视频）

插入操作

1：若二叉树为空，首先单独生成根节点。
2：插入值与根值比较，若前者小插入到左子树当中。若前者大，插入到右子树当中。
代码：

void insert(BiTree* tree, int value)//创建树
{
    BiTNode* node=(BiTNode*)malloc(sizeof(BiTNode));//创建一个节点
    node->data = value;
    node->left = NULL;
    node->right = NULL;
    if (tree->root == NULL)//判断树是不是空树
    {
        tree->root = node;
    }
    else {//不是空树
        BiTNode* temp = tree->root;//从树根开始
        while (temp != NULL)
        {
            if (value < temp->data)//小于就进左儿子
            {
                if (temp->left == NULL)
                {
                    temp->left = node;
                    return;
                }
                else {//继续判断
                    temp = temp->left;
                }
            }
            else {//否则进右儿子
 
                if (temp->right == NULL)
                {
                    temp->right = node;
                    return;
                }
                else {//继续判断
                    temp = temp->right;
                }
            }
        }
    }
    return;
}

查找操作

1：若查找值等于根节点值，查找成功。
2：若小于根节点值，递归查左子树。
3：若大于根节点值，递归查右子树。
4：若子树为空，查找不成功。
代码：

// 递归查找二叉排序树T中是否存在key
// 指针F指向T的双亲，其初始值调用值为NULL
// 若查找成功，则指针P指向该数据元素结点，并返回TRUE
// 否则指针P指向查找路径上访问的最后一个结点，并返回FALSE
Status SearchBST(BiTNode* T,int key,BiTNode *f,BiTNode *p)
{
    if(!T)//查找不成功
    {
        p = f;
        return false;
    }
    else if (key == T->data)//查找成功
    {
        p = T;
        return true;
    }
    else if(key <T->data)
    {
        return SearchBST(T->left,key,T,p);//在左子树上继续查找
    }
    else
    {
        return SearchBST(T->right,key,T,p);//在右子树上继续查找
    }
}

删除操作

1：若删除结点右子树为空，将左子树接上去就行了。
2：若删除结点左子树为空，将右子树接上去就行了。
3：若删除结点左右子树都不为空。
这里选择，用直接前驱（中序遍历）替换删除结点，然后删除直接前驱结点。
删除时，为保证二叉排序树性质不变，需要作出判断。若删除结点左子树是一颗斜树，则将直接前驱的左子树接上已经变换的删除结点上。若删除结点左子树中包含包含右子树，则将直接前驱结点的左子树接到直接前驱结点父节点右子树上。
代码：

//删除结点
Status DeleteBST(BiTNode* T,int key)
{
    if(T == NULL)
    {
        printf("该树为空，不能删除。");
        return false;
    }
    else
    {
        if(key == T->data)
        {
            return Delete(T);
        }
        else if(key < T->data)
        {
            return DeleteBST(T->left,key);
        }
        else
        {
            return DeleteBST(T->right,key);
        }
    }
}

Status Delete(BiTNode* p)
{
    BiTNode* q;
    BiTNode* s;
    if(p->right == NULL)
    {
        //右子树为空的时候，将左子树接上去就行了。
        q = p;
        p = p->left;
        free(q);
    }
    else if(p->left == NULL)
    {
        //左子树为空的时候，将右子树接上去就行了。
        q = p;
        p = p->right;
        free(q);
    }
    else
    {
        //直接前驱data替换要删除结点data
        //直接前驱的左子树接到原直接前驱那里
        q = p;
        s = p->left;
        while(s->right)
        {
            //通过迭代，找出，s子树的最大值，即最右子树。
            q = s;
            s = s->right;
        }

        p->data = s->data;
        if(q != p)
        {
            //若删除结点左子树是一颗斜树。
            q->right = s->left;
        }
        else
        {
            //若删除结点左子树中包含包含右子树，则将直接前驱结点的左子树接到直接前驱结点父节点右子树上。
            q->left = s->left;  
        }
        free(s);
    }
    return true;
}

测试结果

在这里插入图片描述

完整代码

/* BST:Binary Sort Tree二叉排序树  */
/* 二叉排序树的插入，查找，删除  */


/*测试例子： 
*请先输入树的结点个数：12
*请先输入树的结点数值：70 67 46 105 100 99 104 103 115 110 108 112
*中序遍历结果：46 67 70 99 100 103 104 105 108 110 112 115
*请先输入要查找的数值：70
*查找成功！

*请先输入要删除的数值：105
*删除成功！
*中序遍历结果：46 67 70 99 100 103 104 108 110 112 115 请按任意键继续. . .
 */
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;

#define Status bool

//树的结点
typedef struct BiTNode
{
    ElemType data;
    struct  BiTNode *left,*right;
}BiTNode;

//声明树根
typedef struct 
{
   BiTNode* root;
}BiTree;


Status Delete(BiTNode* p);//声明一下

//构建二叉树，插入
void insert(BiTree* tree, int value)//创建树
{
    BiTNode* node=(BiTNode*)malloc(sizeof(BiTNode));//创建一个节点
    node->data = value;
    node->left = NULL;
    node->right = NULL;
    if (tree->root == NULL)//判断树是不是空树
    {
        tree->root = node;
    }
    else {//不是空树
        BiTNode* temp = tree->root;//从树根开始
        while (temp != NULL)
        {
            if (value < temp->data)//小于就进左儿子
            {
                if (temp->left == NULL)
                {
                    temp->left = node;
                    return;
                }
                else {//继续判断
                    temp = temp->left;
                }
            }
            else {//否则进右儿子
 
                if (temp->right == NULL)
                {
                    temp->right = node;
                    return;
                }
                else {//继续判断
                    temp = temp->right;
                }
            }
        }
    }
    return;
}




// 递归查找二叉排序树T中是否存在key
// 指针F指向T的双亲，其初始值调用值为NULL
// 若查找成功，则指针P指向该数据元素结点，并返回TRUE
// 否则指针P指向查找路径上访问的最后一个结点，并返回FALSE
Status SearchBST(BiTNode* T,int key,BiTNode *f,BiTNode *p)
{
    if(!T)//查找不成功
    {
        p = f;
        return false;
    }
    else if (key == T->data)//查找成功
    {
        p = T;
        return true;
    }
    else if(key <T->data)
    {
        return SearchBST(T->left,key,T,p);//在左子树上继续查找
    }
    else
    {
        return SearchBST(T->right,key,T,p);//在右子树上继续查找
    }
}

void inorder(BiTNode* node)//树的中序遍历
{
    if (node != NULL)
    {
        inorder(node->left);
        printf("%d ",node->data);
        inorder(node->right);
    }
}

// bool SearchBST(BiTNode* T,int key)
// {
//     if(T == NULL)//查找不成功
//     {
//         return false;
//     }
//     else if (key == T->data)//查找成功
//     {
//         return true;
//     }
//     else if(key <T->data)
//     {
//         return SearchBST(T->left,key);//在左子树上继续查找
//     }
//     else
//     {
//         return SearchBST(T->right,key);//在右子树上继续查找
//     }
// }



//删除结点
Status DeleteBST(BiTNode* T,int key)
{
    if(T == NULL)
    {
        printf("该树为空，不能删除。");
        return false;
    }
    else
    {
        if(key == T->data)
        {
            return Delete(T);
        }
        else if(key < T->data)
        {
            return DeleteBST(T->left,key);
        }
        else
        {
            return DeleteBST(T->right,key);
        }
    }
}

Status Delete(BiTNode* p)
{
    BiTNode* q;
    BiTNode* s;
    if(p->right == NULL)
    {
        //右子树为空的时候，将左子树接上去就行了。
        q = p;
        p = p->left;
        free(q);
    }
    else if(p->left == NULL)
    {
        //左子树为空的时候，将右子树接上去就行了。
        q = p;
        p = p->right;
        free(q);
    }
    else
    {
        //直接前驱data替换要删除结点data
        //直接前驱的左子树接到原直接前驱那里
        q = p;
        s = p->left;
        while(s->right)
        {
            //通过迭代，找出，s子树的最大值，即最右子树。
            q = s;
            s = s->right;
        }

        p->data = s->data;
        if(q != p)
        {
            //若删除结点左子树是一颗斜树。
            q->right = s->left;
        }
        else
        {
            //若删除结点左子树中包含包含右子树，则将直接前驱结点的左子树接到直接前驱结点父节点右子树上。
            q->left = s->left;  
        }
        free(s);
    }
    return true;
}

int main()
{

    BiTree tree;
    tree.root = NULL;//创建一个空树
    int n,key;
    bool flag,flag2;

    BiTNode *f,*p;
    printf("请先输入树的结点个数：");
    scanf("%d",&n);
    printf("请先输入树的结点数值：");
    for(int i=0;i<n;i++)//输入n个数并创建这个树
    {
        int temp;
        scanf("%d",&temp);
        insert(&tree,temp);
    }
    printf("中序遍历结果：");
    inorder(tree.root);//中序遍历

    printf("\n请先输入要查找的数值：");
    scanf("%d",&key);
    flag = SearchBST(tree.root,key,f,p);
    // flag = SearchBST(tree.root,key);
    if(flag == true)
    {
        printf("查找成功！\n");
    }
    else
    {
        printf("查找失败！\n");
    }
  

    printf("\n请先输入要删除的数值：");
    scanf("%d",&key);
    flag2 = DeleteBST(tree.root,key);
    if(flag == true)
    {
        printf("删除成功！\n");
    }
    else
    {
        printf("删除失败！\n");
    }

    printf("中序遍历结果：");
    inorder(tree.root);//中序遍历

    system("pause");
    return 0;
}
向往的地中海
关注
  • 5
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
二叉排序树_插入+删除+查找
laymenISmouse的专栏
02-01 512
原本是想写关于android分享功能的博客，但是没真机不好去测试，大白天的手机被3岁娃娃，拿去看少儿频道了，，悲催撒！好啊，我还是总结下我学的C/C++相关的知识。 关于二叉排序树的定义是 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右
25 二叉排序树的插入和删除（严 9.35、9.36 和 9.37）
voice34的博客
06-18 832
题目 description： 假设二叉排序树以后继线索链表作存储结构，编写程序，满足以下要求： 1. 输出该二叉排序树中所有大于 a 小于 b 的关键字； 2. 在二叉排序树中插入一个关键字； 3. 在二叉排序树中删除一个关键字。 input： 第一行按先序输入二叉排序树各结点（结点值大于 0），其中-1 表示取消建立子树结点； 第二行输入要求 1 中 a、b，用空格隔开； 第三行输入要求 2 中要插入的关键字； 第四行输入要求 3 中要删除的关键字。 output： 按照中序序列，分三行输出要求 1、
数据结构和算法-二叉排序树（定义 查找 插入 删除 时间复杂度）
llovewuzhengzi的博客
12-21 520
我们也可以用递归实现但递归的最坏情况可能需要有h个函数调用栈帧，或者说h个函数同时执行但循环的实现一直都是一个函数在执行。
【数据结构】二叉排序树（查找+插入+删除+效率分析）完整代码+解析
最新发布
m0_61628700的博客
05-13 1136
二叉排序树的定义又称二叉查找树（BST，Binary Search Tree）左子树结点值
数据结构（8-3）二叉排序树（查找、插入删除）
great_yzl的博客
08-14 906
一、基础理论 1、特点： (1) 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； (2) 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； (3) 它的左、右子树又分别为二叉排序树。 2、结构： 二叉树 参考资料 https://blog.csdn.net/kexuanxiu1163/article/details/106168677?ops_request_misc=%257B%2522request%25...
C语言实现 二叉排序树 的插入、删除、查找（详细图解）
热门推荐
jakercl的博客
01-26 1万+
1 二叉排序树： 如果它的左子树不为空，那么左子树上所有节点的值均小于它的根节点的值 如果它的右子树不为空，那么右子树上所有节点的值均大于它的根节点的值 根节点的左子树和右子树均是二叉排序树 （二叉排序树可能退化为链表，所以有平衡二叉树的概念） ...
二叉排序树操作详解
CXR_XC的博客
12-06 1703
C++详解二叉排序树及其相关操作
C++搜索二叉树的查找、插入、删除
MilkLeong的博客
02-15 2320
以一年十二月的英文缩写为键值而产生二叉搜索树，查找其中的Feb值，及输出最小、最大值： 红框以内为输出，红框以外为输入。
二叉排序树的建立、插入、查找和删除
08-04
代码里有二叉排序树插入操作递归算法，二叉排序树插入操作非递归算法，二叉排序树删除操作，创建二叉排序树，二叉排序树查找递归算法，二叉排序树查找非递归算法
二叉排序树插入
08-25
二叉排序树插入算法 二叉排序树插入是指在二叉排序树中插入新的数据元素的过程。...二叉排序树插入算法是二叉排序树操作的基础，它能够确保树的结构满足二叉排序树的性质，并且能够快速地查找和插入新的数据元素。
二叉排序树的实现与基本操作
08-31
二叉排序树的实现通常包括节点的创建、插入、删除以及遍历等操作。在提供的代码中，实现了以下功能： **二叉树的构建**： 通过`insert`方法，可以向二叉排序树中插入新节点。当树为空时，新节点直接成为根节点。...
C++二叉排序树的创建、插入、删除、查找
09-30
二叉排序树，用前序遍历是就是增序排列，的创建删、插入、查询
数据结构实验：二叉排序树的插入和删除算法
10-17
因此，在插入之前，首先在二叉排序树中检查待插入的数据元素，如果查找成功，说明树中已经存在这个数据元素，则不再插入:如果查找不成功，说明树中不存在关键字等于给定值的数据元素。 在二叉排序树中删除一个数据...
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
1.构造一棵二叉排序树并对其进行中序遍历输出；2．在二叉排序树中查找某一关键字，若存在，显示查找成功；若不存在，将其插入到二叉排序树中，再中序遍历输出。
二叉排序树的查找、插入、创建和删除
m0_51769031的博客
06-23 4721
二叉排序树的特性：1、若左子树非空，则左子树上所有结点的值均小于根节点的值；2、若右子树非空，则右子树上所有结点的值均大于根节点的值；3、左右子树又分别是一颗二叉排序树；综上，左子树结点的值......
二叉排序树的查找、插入、删除
u013728021的博客
11-20 957
我们知道，二分查找可以缩短查找的时间，但是有个要求就是 查找的数据必须是有序的。每次查找、操作时都要维护一个有序的数据集，于是有了二叉排序树这个概念。 上篇文章 我们介绍了 二叉树 的概念，二叉树有左右子树之分，想必在区分左右子树时有一定的规则。 现在我们来介绍二叉树的一种特殊形式 — 二叉排序树，了解它的区分策略及常用操作。 二叉排序树的定义 什么是二叉排序树 Binary Sort Tree,...
二叉排序树（新建，插入，查找，删除）（C语言编写）
半岛落枫的博客
11-23 7316
#include #include typedef struct BSTNode{         int data;         struct BSTNode *lchild,*rchild; }BSTNode,*BSTree; BSTree InsertBST(BSTree T,int data); BSTree CreatBST(BSTree T)
二叉搜索树的插入、查找、删除
m0_55752775的博客
01-14 936
二叉搜索树的插入、查找、删除
二叉排序树（概念，查找，插入，删除）
Hao_09的专栏
05-09 1681
查找基本概念 查找表：由同一类型的数据元素构成的集合。对查找表的常用操作：查询元素是否存在、查询元素属性、插入一个数据元素、删除一个数据元素。 查找：也叫检索，是根据给定的某个值，在表中确定一个关键字等于给定值的数据元素。 关键字：可以标识一个数据元素的某个数据项。 主关键字：可以唯一地识别一个数据元素的关键字。 静态查找表：只进行查询某元素在表中与否或检索某元素的各种属性操作的表。
实现二叉排序树查找，步骤是1、定义二叉排序树的查找算法函数。 2、二叉排序树的插入算法函数。 3、建立二叉排序树的插入算法。 4、二叉排序树删除一个结点的操作实现。 5、 打印二叉排序树。
05-30
好的，我来为您解答如何实现二叉排序树的查找。 1. 定义二叉排序树的查找算法函数 二叉排序树的查找算法函数可以使用递归或迭代方式实现，以下是一个递归实现的示例代码： ```python def search_bst(root, val): if not root or root.val == val: return root elif root.val > val: return search_bst(root.left, val) else: return search_bst(root.right, val) ``` 2. 二叉排序树的插入算法函数 二叉排序树的插入算法函数也可以使用递归或迭代方式实现，以下是一个递归实现的示例代码： ```python def insert_bst(root, val): if not root: return TreeNode(val) elif root.val > val: root.left = insert_bst(root.left, val) else: root.right = insert_bst(root.right, val) return root ``` 3. 建立二叉排序树的插入算法 建立二叉排序树的插入算法可以使用一个循环来不断插入新的节点，以下是一个示例代码： ```python def build_bst(nums): if not nums: return None root = TreeNode(nums[0]) for i in range(1, len(nums)): insert_bst(root, nums[i]) return root ``` 4. 二叉排序树删除一个结点的操作实现 二叉排序树删除一个结点的操作需要考虑多种情况，包括删除的节点有无子节点、删除的节点只有一个子节点、删除的节点有两个子节点等，以下是一个示例代码： ```python def delete_bst(root, val): if not root: return None if root.val == val: if not root.left: return root.right if not root.right: return root.left if root.left and root.right: temp = root.right while temp.left: temp = temp.left root.val = temp.val root.right = delete_bst(root.right, temp.val) elif root.val > val: root.left = delete_bst(root.left, val) else: root.right = delete_bst(root.right, val) return root ``` 5. 打印二叉排序树 二叉排序树的打印可以使用中序遍历来实现，以下是一个示例代码： ```python def inorder_traversal(root): if not root: return [] res = [] stack = [] while root or stack: while root: stack.append(root) root = root.left root = stack.pop() res.append(root.val) root = root.right return res ``` 可以使用以上函数来打印二叉排序树的所有节点值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值