二叉搜索树的详细实现(C++)

最新推荐文章于 2024-07-18 22:05:06 发布
最新推荐文章于 2024-07-18 22:05:06 发布
阅读量1.2k 收藏 11
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/code_peak/article/details/120581884
版权
本文详细介绍了二叉搜索树的概念，包括其特性及在搜索、插入、删除操作上的实现。二叉搜索树是一种特殊二叉树，通过中序遍历能按升序排列节点。文章提供了C++实现的二叉搜索树节点结构及插入、删除、搜索算法，并通过示例展示了如何在已有的二叉搜索树中进行这些操作。
摘要由CSDN通过智能技术生成

二叉搜索树概念

二叉搜索树（Binary Search Tree），又称为二叉查找树。

之前已经说过了二叉树的概念和实现，而二叉搜索树是一种特殊的二叉树。假设 x 为二叉树中的任意一个结点，x 结点包含包含关键字 key，结点 X 的 key 值记为 key[x]，如果 y 是 x 的左子树中的一个结点，则 key[y] <= key[x]；如果 y 是 x 的右子树的一个结点，则 key[y] >= key[x]。那么，这棵树就是二叉查找树，如下图所示：

二叉搜索树的详细实现-图1

在二叉搜索树中：

(01) 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值。

(02) 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值。

(03) 任意节点的左、右子树也分别为二叉查找树。

(04) 没有键值相等的节点（no duplicate nodes）。

从上面的性质中可以看出，如果对一颗二叉树进行中序遍历，可以按从小到大的顺序，将各结点关键码排列起来，所以也称二叉搜索树为二叉排序树（Binary Sorting Tree）。

除此之外，因为二叉搜索树就是一种特殊的二叉树，其其他操作和二叉树相同，但是因为它是搜索树，就需要有自己的插入、删除、搜索算法。下面将会逐个介绍。

二叉搜索树的实现

二叉搜索树结点定义

//二叉搜索树结点类型
template<typename T>
struct BSTNode
{
    T data;    //数据域
    BSTNode<T> *left, *right;    //左子女、右子女
    BSTNode() :left(NULL), right(NULL) {}    //构造函数
    //构造函数
    BSTNode(const T d, BSTNode<T>* L = NULL, BSTNode<T>* R = NULL) :data(d), left(L), right(R) {}
};

二叉搜索树的插入

为了向二叉搜索树中插入一个新元素，必须先检查这个元素是否在树中已经存在。所以在插入之前，先使用搜索算法在树中检查要插入元素有还是没有。如果搜索成功，说明树中已经有这个元素，不再插入；如果搜索不成功，说明树中原来没有关键码等于给定值的结点，把新元素加到搜索操作停止的地方。当ptr != NULL时，它一定指向一棵子树的根，可用它所包含的关键码与给定值比较继续搜索插入位置；如果 ptr=NULL，一定是递归到空树的位置，此时将创建的新结点地址送给ptr，因为ptr是引用，新结点的地址自然送入上述某一个指针域，自动将新结点作为叶结点链入二叉搜索树中了。每次结点的插入，都要从根结点出发搜索插入位置，然后把新结点作为叶结点插入。这样不需移动结点，只需修改某个已有树中结点的一个空指针即可。

//以ptr为根的二叉搜索树中插入所含值为e1的结点
bool Insert(const T& e1, BSTNode<T>* &ptr)    //第二个参数是指针的引用
{
    if (ptr == NULL)
    {
        ptr = new BSTNode<T>(e1);    //构造新结点
        if (ptr == NULL)
        {
            cout << "Memory allocation failed!" << endl;
            exit(1);
        }
        return true;
    }
    else if (e1 < ptr->data)    //小于，插入左子树
    {
        Insert(e1, ptr->left);
    }
    else if (e1 > ptr->data)    //大于，插入右子树
    {
        Insert(e1, ptr->right);
    }
    else    //x已在树中，不插入
    {
        return false;
    }
}

二叉树的搜索

从根结点开始，沿某一个分支逐层向下进行比较判等的过程。它可以是一个递归的过程。假设想要在二叉搜索树中搜索关键码为 x 的元素，搜索过程从根结点开始。

如果根指针为 NULL，则搜索不成功。

否则用给定值 x 与根结点的关键码进行比较：

如果给定值等于根结点的关键码，则搜索成功，返回搜索成功信息，并报告搜索到的结点地址。

如果给定值小于根结点的关键码，则继续递归搜索根结点的左子树，否则，递归搜索根结点的右子树。

//在ptr为根的二叉搜索树中搜索含x的结点。若找到，返回该结点地址，否则返回NULL
BSTNode<T>* Search(T x, BSTNode<T>* ptr)
{
    if (ptr == NULL)
    {
        return NULL;
    }
    else if (x < ptr->data)
    {
        return Search(x, ptr->left);
    }
    else if (x > ptr->data)
    {
        return Search(x, ptr->right);
    }
    else
    {
        return ptr;
    }
}

二叉搜索树的删除

在二叉搜索树中删除一个结点时，必须将因删除结点而断开的二叉链表重新链接起来，同时确保二叉搜索树的性质不会失去。此外，为了保证在执行删除后，树的搜索性能不至于降低，还需要防止重新链接后树的高度不能增加。

二叉搜索树的详细实现-图2

如果想要删除叶结点，只需将其父结点指向它的指针清零，再释放它即可。

如果被删结点右子树为空，可以拿它的左子女结点顶替它的位置，再释放它。

如果被删结点左子树为空，可以拿它的右子女结点顶替它的位置，再释放它。

如果被删结点左、右子树都不空，可以在它的右子树中寻找中序下的第一个结点（关键码最小），用它的值填补到被删结点中，再来处理这个结点的删除问题，这是一个递归处理。例如，在上图中想要删除关键码为 78 的结点，它的左、右子树都不空。在它的右子树中找中序下的第一个结点，其关键码为 81。把它的值填补到被删结点中去，下面的问题就是删除关键码为 81 的结点了。这个结点左子树为空，用它的右子女（关键码为 88）代替它的位置就可以了。

//以ptr为根的二叉搜索树中删除含x的结点
bool Remove(T x, BSTNode<T>* &ptr)
{
    BSTNode<T>* temp;
    if (ptr != NULL) //ptr不为空进行操作
    {
        if (x < ptr->data)
        {
            Remove(x, ptr->left);
        }
        else if (x > ptr->data)
        {
            Remove(x, ptr->right);
        }
        //找到了要删除的结点
        //1.要删除的结点ptr同时有左右子树
        else if (ptr->left != NULL&&ptr->right != NULL)
        {
            temp = ptr->right;    //在右子树中搜索中序下的第一个结点
            while (temp->left != NULL)
            {
                temp = temp->left;
            }
            //用右子树中序下的第一个结点的值填充要删除的结点
            ptr->data = temp->data;
            //然后再新填充值ptr的右子树中删除temp的data值
            Remove(ptr->data, ptr->right);
        }
        else //不同时有左右子树
        {
            temp = ptr;        //temp记住要删除的ptr结点
            if (ptr->left == NULL) //只有右子树
            {
                ptr = ptr->right;
            }
            else    //只有左子树
            {
                ptr = ptr->left;
            }
            delete temp;    //删除结点
            temp = NULL;
            return true;
        }
    }
    else //ptr为空直接返回false
    {
        return false;
    }
}

注：其他的一些方法和二叉树是相同的，不再赘述。

详细代码实现

//二叉搜索树结点类型
template<typename T>
struct BSTNode
{
    T data;    //数据域
    BSTNode<T> *left, *right;    //左子女、右子女
    BSTNode() :left(NULL), right(NULL) {}    //构造函数
    //构造函数
    BSTNode(const T d, BSTNode<T>* L = NULL, BSTNode<T>* R = NULL) :data(d), left(L), right(R) {}
};

//二叉搜索树的定义
template <class T>
class BST
{
public:
    //普通构造函数
    BST() :root(NULL) {}
    //构造BST
    BST(T value) :root(NULL), RefValue(value)
    {
        T x;
        cin >> x;
        while (x != RefValue)
        {
            Insert(x, root);    //新建一个结点，调用Insert插入到树中
            cin >> x;
        }
    }
    //析构
    ~BST() { Destroy(root); }
    //插入
    bool Insert(T x) { return Insert(x, root); }
    //删除
    bool Remove(T x) { return Remove(x, root); }
    //搜索
    bool Search(T x) { return (Search(x, root) != NULL) ? true : false; }
    //中序遍历
    void InOrder() { InOrder(root); }

protected:

    //以ptr为根的二叉搜索树中插入所含值为e1的结点
    bool Insert(const T& e1, BSTNode<T>* &ptr)    //第二个参数是指针的引用
    {
        if (ptr == NULL)
        {
            ptr = new BSTNode<T>(e1);    //构造新结点
            if (ptr == NULL)
            {
                cout << "Memory allocation failed!" << endl;
                exit(1);
            }
            return true;
        }
        else if (e1 < ptr->data)    //小于，插入左子树
        {
            Insert(e1, ptr->left);
        }
        else if (e1 > ptr->data)    //大于，插入右子树
        {
            Insert(e1, ptr->right);
        }
        else    //x已在树中，不插入
        {
            return false;
        }
    }

    //以ptr为根的二叉搜索树中删除含x的结点
    bool Remove(T x, BSTNode<T>* &ptr)
    {
        BSTNode<T>* temp;
        if (ptr != NULL) //ptr不为空进行操作
        {
            if (x < ptr->data)
            {
                Remove(x, ptr->left);
            }
            else if (x > ptr->data)
            {
                Remove(x, ptr->right);
            }
            //找到了要删除的结点
            //1.要删除的结点ptr同时有左右子树
            else if (ptr->left != NULL&&ptr->right != NULL)
            {
                temp = ptr->right;    //在右子树中搜索中序下的第一个结点
                while (temp->left != NULL)
                {
                    temp = temp->left;
                }
                //用右子树中序下的第一个结点的值填充要删除的结点
                ptr->data = temp->data;
                //然后再新填充值ptr的右子树中删除temp的data值
                Remove(ptr->data, ptr->right);
            }
            else //不同时有左右子树
            {
                temp = ptr;        //temp记住要删除的ptr结点
                if (ptr->left == NULL) //只有右子树
                {
                    ptr = ptr->right;
                }
                else    //只有左子树
                {
                    ptr = ptr->left;
                }
                delete temp;    //删除结点
                temp = NULL;
                return true;
            }
        }
        else //ptr为空直接返回false
        {
            return false;
        }
    }

    //在ptr为根的二叉搜索树中搜索含x的结点。若找到，返回该结点地址，否则返回NULL
    BSTNode<T>* Search(T x, BSTNode<T>* ptr)
    {
        if (ptr == NULL)
        {
            return NULL;
        }
        else if (x < ptr->data)
        {
            return Search(x, ptr->left);
        }
        else if (x > ptr->data)
        {
            return Search(x, ptr->right);
        }
        else
        {
            return ptr;
        }
    }

    //中序遍历
    void InOrder(BSTNode<T>* root)
    {
        if (root != NULL)
        {
            InOrder(root->left);
            cout << root->data << " ";
            InOrder(root->right);
        }
    }

    //销毁以root为根的二叉树搜索树函数
    void Destroy(BSTNode<T>* &root)
    {
        if (root == NULL)
        {
            return;
        }
        if (root->left != NULL)
        {
            Destroy(root->left);
        }
        if (root->right != NULL)
        {
            Destroy(root->right);
        }
        delete root;
        root = NULL;
    }
private:
    BSTNode<T>* root;    //根指针
    T RefValue;    //输入结束标识
};

int main(int argc, char* argv[])
{
    //g a e d f h j i l k #
    BST<char> tree('#');
    tree.InOrder();
    cout << endl;
    cout << tree.Search('e') << endl;
    cout << tree.Insert('z') << endl;
    tree.InOrder();
    cout << endl;
    cout << tree.Remove('z') << endl;
    cout << tree.Remove('j') << endl;
    tree.InOrder();
    cout << endl;
    return 0;
}
code_peak
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
【二叉搜索树】的详细实现(C++)
dielu7895的博客
05-20 367
二叉搜索树的概念 　　从前面讨论折半搜索的性能中可知，如果每次从搜索序列的中间进行搜索，把区间缩小一半，通过有限次迭代，很快就能通近到所要寻找的元素。进一步，如果我们直接输入搜索序列，构造出类似于折半搜索的判定树那样的树形结构，就能实现快速搜索。这种树形结构就是二又搜索树。 二又搜索树（binary search tree）或者是一棵空树，或者是具有下列性质的二又树： 　　（1）每...
C++之搜索二叉树
一只小卷毛的博客
04-05 1119
本文介绍了二叉搜索树的相关概念，主要介绍了如何使用和实现搜索二叉树以及搜索二叉树具体的例题练习。
C++数据结构——二叉搜索树（详细图解，详细代码实现）
最新发布
Zfox的博客
07-18 1071
详细讲解了C++数据结构的二叉搜索树的实现
数据结构之二叉搜索树（C++实现）
CHAKMING1的博客
01-12 525
介绍了二叉树中的二叉搜索树，从概念到具体实现，是使用C++完成的。最后，对二叉搜索树的效率进行分析已经响应的二叉树的练习题目。
二叉搜索树详解（C++实现）
沐白白的博客
04-14 1238
二叉搜索树的定义 二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节点的左、右子树也分别为二叉查找树。 没有键值相等的节点。 二叉搜索数中序遍历为有序数组 一、查找二叉搜索树中的某个元素 在二叉搜索树b中查找x的过程为： 若b是空树，则搜索失败，否则： 若x等于b的根节点的数据域之值，则查找成功；否则： 若x小于b的根节点的
【C++】二叉搜索树
m0_62179366的博客
10-24 2056
二叉搜索树的简单应用及实现。
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
二叉搜索树的实现与应用
11-04
本资源是博文【数据结构】二叉搜索树的完整源代码文件，包含K模型搜索树的递归、非递归实现；KV模型搜索树的递归和非递归实现。以及两种模型的测试和应用，主要体现在单词翻译、统计次数、检查单词拼写。可结合以下...
二叉树-基于C++实现的二叉搜索树.zip
04-26
在C++中实现二叉搜索树，我们需要定义一个节点结构，包含节点的值、左子节点和右子节点的指针。例如： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
二叉搜索树（BST-Tree）(C++全)
weixin_48560325的博客
04-28 5035
目录 二叉搜索树基本概念 1，什么是根节点 2、什么是二叉搜索树 3、二叉搜索树结构 4、二叉搜索树的性质 5、复杂度 算法实现 1、创建一个二叉搜索树节点 2、打印二叉搜索树 3、二叉搜索树的插入 4、其他操作 （1）查找二叉搜索树的最大值 （2）查找二叉搜索树的最小值 （3）查找某一节点的前驱 （4）查找某一节点的后继 5、删除二叉搜索树的某一节点 步骤： 代码： 性能分析 二叉搜索树基本概念 1，什么是根节点 根结点（root）是树的一个组成部分，也
二叉搜索树(C++实现)
qq_56628506的博客
08-22 2817
二叉搜索树初探
【数据结构】二叉搜索树/搜索二叉树(C++实现)
Brant_zero的博客
11-05 2277
二叉搜索树的概念、二叉搜索树的实现，二叉搜索树的插入、二叉搜索树的删除、二叉搜索树的查找、二叉搜索树性能分析，二叉搜索树key模型、二叉搜索树key-value模型
C++【搜索二叉树】
芊樱烛渊的博客
10-23 1323
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树（每一棵子树都满足上面的特征）（这样我们的搜索二叉树就非常利于我们的搜索）比方说我们查找8,8比6大，找右子树，8比9小，找9的左子树，7比8小，找7的右子树，找到了。最多的查找次数是树的高度！这样就不是暴力查找了，而是利用了二叉树的特性。
【 C++ 】二叉搜索树
bit_zyx的博客
09-03 1222
目录 1、二叉搜索树的概念 2、二叉搜索树的实现 ①、结点类 ②、二叉搜索树的类 2.1、默认成员函数 构造函数 拷贝构造函数 赋值运算符重载函数 析构函数 2.2、中序遍历 2.3、Insert插入函数 ............
C++实现二叉搜索树
Ly的博客
04-30 1207
二叉搜索树是一种特别有用的数据结构，AVL树，红黑树的原型都是二叉搜索树。本文将会对二叉搜索树进行初步介绍，从而入门二叉搜索树，为以后深入学习AVL树和红黑树打下基础。
C++二叉搜索树BinarySearchTree
学习C++的小陈同学
11-03 144
本章介绍了搜索二叉树的特性，并且用C++模拟实现，详细分析了代码思路
C++搜索二叉树
RXY24601的博客
05-27 1343
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
二叉搜索树的删除c++实现
02-16
二叉搜索树的删除操作可以分为以下几步： 1. 首先找到要删除的节点，可以使用二叉搜索树的查找方法，从根节点开始递归查找。 2. 如果要删除的节点是叶子节点，直接删除即可。 3. 如果要删除的节点只有一个子节点，将该子节点接替要删除的节点即可。 4. 如果要删除的节点有两个子节点，需要找到要删除节点的中序遍历后继节点（也就是比要删除的节点大的最小节点），将其值复制到要删除的节点中，然后再将中序遍历后继节点删除。 以下是一个示例代码实现： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class Solution: def deleteNode(self, root: TreeNode, key: int) -> TreeNode: if not root: return None # 找到要删除的节点 if key < root.val: root.left = self.deleteNode(root.left, key) elif key > root.val: root.right = self.deleteNode(root.right, key) else: # 叶子节点或只有一个子节点 if not root.left: return root.right elif not root.right: return root.left # 有两个子节点 else: successor = root.right while successor.left: successor = successor.left root.val = successor.val root.right = self.deleteNode(root.right, successor.val) return root ``` 在这个实现中，我们首先使用递归找到要删除的节点，然后根据节点的情况进行删除操作。如果节点是叶子节点或只有一个子节点，直接将其删除或将其子节点接到父节点上。如果节点有两个子节点，找到中序遍历后继节点，将其值复制到要删除的节点上，然后再将中序遍历后继节点删除。最后返回删除操作后的根节点即可。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

code_peak

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值