二叉搜索树

已于 2024-10-24 07:47:33 修改
阅读量925 收藏 11
点赞数 19
分类专栏： 数据结构 文章标签： c++ 数据结构 1024程序员节
于 2024-07-27 15:37:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65866298/article/details/140735621
版权

目录

1.什么是二叉搜索树？

2.二叉搜索树的查找

2.1尾递归

2.2非尾递归

3.查找最大和最小元素 

3.1尾递归

3.2非尾递归 

4.二叉搜索树的插入

5.二叉搜索树的删除

1.什么是二叉搜索树？

二叉搜索树（BST，Binary Search Tree）， 也称二叉排序树或二叉查找树

二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质：

        1. 非空左子树的所有键值小于其根结点的键值。

        2. 非空右子树的所有键值大于其根结点的键值。

        3. 左、右子树都是二叉搜索树。 

二叉搜索树操作的特别函数：

        Position Find( ElementType X, BinTree BST )：从二叉搜索树BST 中查找元素X，返回其所在结点的地址；

        Position FindMin( BinTree BST )：从二叉搜索树BST中查找并返回 最小元素所在结点的地址；

        Position FindMax( BinTree BST ) ：从二叉搜索树BST中查找并返回 最大元素所在结点的地址。

        BinTree Insert( ElementType X, BinTree BST )

        BinTree Delete( ElementType X, BinTree BST ) 

2.二叉搜索树的查找

查找从根结点开始，如果树为空，返回NULL；

若搜索树非空，则根结点关键字和X进行比较，并进行不同处理：

         若X小于根结点键值，只需在左子树中继续搜索；

         如果X大于根结点的键值，在右子树中进行继续搜索；

         若两者比较结果是相等，搜索完成，返回指向此结点的指针。 

2.1尾递归

Position Find( ElementType X, BinTree BST )
{
    if( !BST ) return NULL; /*查找失败*/
    if( X > BST->Data )
     return Find( X, BST->Right ); /*在右子树中继续查找*/
    else if( X < BST->Data )
     return Find( X, BST->Left ); /*在左子树中继续查找*/
    else /* X == BST->Data */
     return BST; /*查找成功，返回结点的找到结点的地址*/
}

2.2非尾递归

 由于非递归函数的执行效率高，可将“尾递归”函数改为迭代函数

Position IterFind( ElementType X, BinTree BST )
{
 while( BST ) {
     if( X > BST->Data )
         BST = BST->Right; /*向右子树中移动，继续查找*/
     else if( X < BST->Data )
         BST = BST->Left; /*向左子树中移动，继续查找*/
     else /* X == BST->Data */
         return BST; /*查找成功，返回结点的找到结点的地址*/
 }
     return NULL; /*查找失败*/
}

3.查找最大和最小元素 

最大元素一定是在树的最右分枝的端结点上

最小元素一定是在树的最左分枝的端结点上 

3.1尾递归

Position FindMin( BinTree BST )
{
     if( !BST ) return NULL; /*空的二叉搜索树，返回NULL*/
     else if( !BST->Left )
         return BST; /*找到最左叶结点并返回*/
     else
         return FindMin( BST->Left ); /*沿左分支继续查找*/
}

Position FindMax( BinTree BST, Position max )
{
    if( !BST ) return max; /* 空的二叉搜索树，返回当前最大值 */
    else if( !BST->Right )
        return BST; /* 找到最右叶结点并返回 */
    else
        return FindMax( BST->Right, BST->Right ); /* 沿右分支继续查找 */
}

3.2非尾递归 

Position FindMin(BinTree BST)
{
    while (BST && BST->Left)
        BST = BST->Left;
    /* 沿左分支继续查找，直到最左叶结点 */
    return BST;
}

Position FindMax( BinTree BST )
{
     if(BST )
         while( BST->Right ) BST = BST->Right;
         /*沿右分支继续查找，直到最右叶结点*/
     return BST;
}

4.二叉搜索树的插入

关键是要找到元素应该插入的位置， 可以采用与查找类似的方法

/* 插入函数 */
BinTree Insert(ElementType X, BinTree BST) {
    if (!BST) {
        /* 如果树为空，生成并返回一个新的节点 */
        BST = malloc(sizeof(struct TreeNode));
        if (BST == NULL) {
            fprintf(stderr, "Out of memory!\n");
            exit(1);
        }
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    } else if (X < BST->Data) {
        /* 递归插入到左子树 */
        BST->Left = Insert(X, BST->Left);
    } else if (X > BST->Data) {
        /* 递归插入到右子树 */
        BST->Right = Insert(X, BST->Right);
    }
    /* 如果X已经存在于树中，什么都不做 */
    return BST;
}

5.二叉搜索树的删除

 考虑三种情况：

一.        要删除的是叶结点：直接删除，并再修改其父结点指针---置为NULL

〖例〗：删除 35 

二.        要删除的结点只有一个孩子结点: 将其父结点的指针指向要删除结点的孩子结点

〖例〗：删除 33

三.        要删除的结点有左、右两棵子树： 用另一结点替代被删除结点：右子树的最小元素 或者 左子树的最大元素

 〖例〗：删除 41

/* 删除函数 */
BinTree Delete(ElementType X, BinTree BST) {
    Position Tmp;

    if (!BST) {
        printf("要删除的元素未找到\n");
    } else if (X < BST->Data) {
        /* 左子树递归删除 */
        BST->Left = Delete(X, BST->Left);
    } else if (X > BST->Data) {
        /* 右子树递归删除 */
        BST->Right = Delete(X, BST->Right);
    } else {
        /* 找到要删除的结点 */
        if (BST->Left && BST->Right) {
            /* 被删除结点有左右两个子结点 */
            Tmp = FindMin(BST->Right);
            /* 在右子树中找最小的元素填充删除结点 */
            BST->Data = Tmp->Data;
            /* 在删除结点的右子树中删除最小元素 */
            BST->Right = Delete(BST->Data, BST->Right);
        } else {
            /* 被删除结点有一个或无子结点 */
            Tmp = BST;
            if (!BST->Left) {
                /* 有右孩子或无子结点 */
                BST = BST->Right;
            } else if (!BST->Right) {
                /* 有左孩子或无子结点 */
                BST = BST->Left;
            }
            free(Tmp);
        }
    }
    return BST;
}

 完整代码示例

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

/* 定义二叉树节点结构体 */
struct TreeNode {
    int Data;
    struct TreeNode *Left;
    struct TreeNode *Right;
};

typedef struct TreeNode* BinTree;
typedef struct TreeNode* Position;
typedef int ElementType;

/* 查找函数（递归） */
Position Find(ElementType X, BinTree BST) {
    if (!BST) {
        return NULL;
    } else if (X < BST->Data) {
        return Find(X, BST->Left);
    } else if (X > BST->Data) {
        return Find(X, BST->Right);
    } else {
        return BST;
    }
}

/* 查找函数（迭代） */
Position FindIterative(ElementType X, BinTree BST) {
    while (BST) {
        if (X < BST->Data) {
            BST = BST->Left;
        } else if (X > BST->Data) {
            BST = BST->Right;
        } else {
            return BST;
        }
    }
    return NULL;
}

/* 查找最小值节点 */
Position FindMin(BinTree BST) {
    while (BST && BST->Left)
        BST = BST->Left;
    return BST;
}

/* 插入函数 */
BinTree Insert(ElementType X, BinTree BST) {
    if (!BST) {
        BST = malloc(sizeof(struct TreeNode));
        if (BST == NULL) {
            fprintf(stderr, "内存分配失败！\n");
            exit(1);
        }
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    } else if (X < BST->Data) {
        BST->Left = Insert(X, BST->Left);
    } else if (X > BST->Data) {
        BST->Right = Insert(X, BST->Right);
    }
    return BST;
}

/* 删除函数 */
BinTree Delete(ElementType X, BinTree BST) {
    Position Tmp;
    if (!BST) {
        printf("要删除的元素未找到\n");
    } else if (X < BST->Data) {
        BST->Left = Delete(X, BST->Left);
    } else if (X > BST->Data) {
        BST->Right = Delete(X, BST->Right);
    } else {
        if (BST->Left && BST->Right) {
            Tmp = FindMin(BST->Right);
            BST->Data = Tmp->Data;
            BST->Right = Delete(BST->Data, BST->Right);
        } else {
            Tmp = BST;
            if (!BST->Left) {
                BST = BST->Right;
            } else if (!BST->Right) {
                BST = BST->Left;
            }
            free(Tmp);
        }
    }
    return BST;
}

/* 打印树（中序遍历） */
void PrintTree(BinTree BST) {
    if (BST != NULL) {
        PrintTree(BST->Left);
        printf("%d ", BST->Data);
        PrintTree(BST->Right);
    }
}

/* 主函数，测试各种操作 */
int main() {
    BinTree tree = NULL;

    /* 插入节点 */
    tree = Insert(10, tree);
    tree = Insert(5, tree);
    tree = Insert(15, tree);
    tree = Insert(3, tree);
    tree = Insert(7, tree);
    tree = Insert(12, tree);
    tree = Insert(18, tree);

    printf("插入节点后的树（中序遍历）：");
    PrintTree(tree);
    printf("\n");

    /* 查找节点 */
    Position foundNode = Find(7, tree);
    if (foundNode) {
        printf("递归查找，找到节点值为：%d\n", foundNode->Data);
    } else {
        printf("递归查找，节点值为7未找到。\n");
    }

    foundNode = FindIterative(12, tree);
    if (foundNode) {
        printf("迭代查找，找到节点值为：%d\n", foundNode->Data);
    } else {
        printf("迭代查找，节点值为12未找到。\n");
    }

    /* 删除节点 */
    tree = Delete(10, tree);
    printf("删除10后的树（中序遍历）：");
    PrintTree(tree);
    printf("\n");

    tree = Delete(5, tree);
    printf("删除5后的树（中序遍历）：");
    PrintTree(tree);
    printf("\n");

    /* 再次插入和删除以验证 */
    tree = Insert(10, tree);
    tree = Insert(5, tree);
    tree = Insert(20, tree);
    printf("重新插入后的树（中序遍历）：");
    PrintTree(tree);
    printf("\n");

    tree = Delete(14, tree);
    printf("尝试删除14（未找到）的树（中序遍历）：");
    PrintTree(tree);
    printf("\n");

    /* 结束 */
    return 0;
}

 示例结果：

码明
关注
专栏目录
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
节点node[算法导论]二叉排序树(Binary Search Tree)
weixin_33923148的博客
05-30 146
新手发帖，很多方面都是刚入门，有错误的地方请大家见谅，欢迎批评指正     1. 二叉排序树的定义     它或者是一棵空树；或者是拥有下列性子的二叉树：            （1）若左子树不空，则左子树上全部结点的值均小于它的根结点的值；            （2）若右子树不空，则右子树上全部结点的值均大于它的根结点的值；            （3）左、右子树也分别为二叉排序树；...
Binary Search Tree
weixin_43797323的博客
09-28 95
二叉搜索树也称二叉排序树或二叉查找树。 如果不为空，满足以下性质： 非空左子树的所有键值小于其根结点的键值。 非空右子树的所有键值大于其根结点的键值。 左、右子树都是二叉搜索树。 操作： Position Find( ElementType X, BinTree BST )：从二叉搜索树BST 中查找元素X，返回其所在结点的地址； Position FindMin( BinTree BST )...
二叉搜索树详解
2302_79215415的博客
06-25 1912
但对于有n个节点的二叉搜索树，若每个元素的概率相等，则二叉搜索树的平均查找长度是节点在二叉搜索树的深度的函数，节点越深，比较次数就越多。所有在“大佬“的改进下，我们有引入的平衡二叉树和红黑树的概念，使得二叉树的性能有了较大的提升，下一篇内容将会给大家介绍平衡二叉数。2、统计单词的次数，给定一个单词的拼写，就可以快速找到其出现的次数单词由其出现次数就是的一种键值对。情况d、在它的右子树中寻找中序下的第一个节点，用它 的值填补到被删除节点中，再去处理该节点的删除问题----替换删除。
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 9万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
【二叉搜索树】二叉搜索树的用法以及实现
m0_68617301的博客
04-28 1228
二叉搜索树的用法以及实现
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 7069
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
二叉搜索树（BinarySearchTree）
潜心钻研技术
03-05 1722
二叉搜索树（BinarySearchTree） 文章目录二叉搜索树（BinarySearchTree）二叉搜索树的概念如何定义 二叉搜索树的节点 && 二叉搜索树查找插入删除二叉搜索树的缺点二叉搜索树的应用 二叉搜索树的概念 搜索二叉树满足一下条件： 是一棵二叉树 这可树上的任意一个节点满足：若他的右子树不为空，则右子树上的所有节点的值大于该节点的值 这可树上的任意一个节点满足：若他的左子树不为空，则左子树上的所有节点的值小于该节点的值 它的的左子树和右子树也是二叉搜索树 例如下图就是一
java二叉搜索树详解
m0_57180439的博客
02-21 2214
文章目录一、概念二、相关操作1.查找2.插入2.删除实现 提示：以下是本篇文章正文内容，下面案例可供参考 一、概念 二叉搜索树又称二叉排序树 它或者是一棵空树，或者是具有以下性质的二叉树: 1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 3.它的左右子树也分别为二叉搜索树 （图片来自比特就业课） 二、相关操作 1.查找 （图片来自比特就业课） 代码如下（示例）： 2.插入 代码如下（示例）： 2.删除 实现 ....
【数据结构】二叉搜索树
Celia的博客
09-18 1919
左子树所有的值要小于根节点的值，右子树所有的值要大于根节点的值。这样一来，当查找一个值的时候，如果比当前节点的值小，就向左遍历；如果比当前节点的值大，就向右遍历。这样的搜索模式最好的时间复杂度为logN。二叉搜索树举例class BSTNode //每个节点的定义public:K val;
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
C 学习（4）
search7的博客
11-05 767
C语言学习，每个模块来自工作中的？？？
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 80
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
STL set
最新发布
hls0611的博客
11-09 108
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
常用的c++特性--＞day02
m0_69093426的博客
11-06 528
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
c++函数形参 返回两幅IplImage*图像
u012719076的博客
11-05 143
如果在GetImage函数中用cvCreateImage创建 p1 p2，则在调用时发现返回的数据是空的。主要是调用之前要先定义好。
Java实现二叉搜索树实例教程
资源摘要信息: "tree-java.rar_tree_二叉搜索树" 在计算机科学中，二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树结构，它满足以下性质：对于树中的任意节点N，其左子树中的所有元素的值都小于节点N...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值