二叉搜索树讲解及其C++代码实现

最新推荐文章于 2024-03-19 07:30:07 发布
最新推荐文章于 2024-03-19 07:30:07 发布
阅读量983 收藏 11
点赞数 2
分类专栏： C/C++ 数据结构 文章标签： c++ b树 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56745306/article/details/125119635
版权

文章概述：本文介绍了二叉搜索树的概念、一般操作和其C++代码实现。不是很了解二叉搜索树请先看教材和讲解然后参照代码自己动手试一试；如果只是需要实现代码&测试代码，请直接查看第四节。

参考教材：清华大学《数据结构》第2版教材（殷人昆主编）
编程语言：C++

文章目录

一、二叉搜索树的概念

二叉搜索树（Binary search tree）或者是一颗空树，或者是具有下列性质的二叉树：
（1）每个结点都有一个作为搜索依据的关键码（key），所有结点的关键码互不相同。
（2）左子树（如果存在）上所有结点的关键码都小于根结点的关键码。
（3）右子树（如果存在）上所有结点的关键码都大于根结点的关键码。
（4）左子树和右子树也是二叉搜索树。
下面是二叉搜索树的一些例子：
在这里插入图片描述

二、二叉搜索树的基本操作

2.1 二叉搜索树上的搜索

在二叉搜索树上进行搜索，是一个从根结点开始，沿某一个分支逐层向下进行比较判等的过长，它可以是一个递归的过程。假设想要在二叉搜索树中搜索关键码为 x x x的元素，搜索过程从根节点开始。如果根指针为NULL，则搜索不成功；否则用给定的值 x x x与根结点的关键码进行比较：

  • 如果给定值等于根结点的关键码，则搜索成功，返回搜索成功信息。
  • 如果给定值小于根结点的关键码，则继续递归搜索根结点的左子树。
  • 否则（大于），递归搜索根结点的右子树。

下面给出一个在二叉搜索树中进行搜索的例子：
在这里插入图片描述
上图中查找到了23，但没找到88。可以看到，若设二叉搜索树的高度为h，则比较次数不超过h。

2.2 二叉搜索树的插入

为了向二叉搜索树中插入一个元素，必须先检查这个元素是否在树中已经存在。所以在插入之前，先使用搜索算法在树中检查要插入元素有还是没有。如果搜索成功，说明树中已经有这个元素，不再插入；如果搜索不成功，说明树中原来没有关键码等于给定值的结点，把新元素加到搜索操作停止的地方。一个插入的例子如下图所示：
在这里插入图片描述

2.3 二叉搜索树的删除

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

  • 如果想要删除叶结点，只需将其父结点指向它的指针清零，再释放它即可。如果被删除结点右子树为空，则可以拿它的左子女结点顶替它的位置，再释放它；如果被删结点左子树为空，可以拿它的右子女结点顶替它的位置，再释放它。
    在这里插入图片描述
  • 如果被删结点的左、右子树都不空，可以在它的右子树中寻找中序下的第一个结点（关键码最小），用它的值填补到被删结点中，再来处理这个结点的删除问题。当然也可以在被删结点的左子树中找到中序下的最后一个结点（关键码最大），用它来填补被删结点。
    在这里插入图片描述

三、二叉搜索树的一些其他相关操作

这部分内容是为了完善二叉搜索树功能而讲解。

3.1 二叉搜索树取最大元素和最小元素

由二叉搜索树性质知道：递归取二叉搜索树的**左子树（左下角结点）便得到了树中所有元素的最小元素；递归取二叉搜索树的右子树（右下角结点）**便得到了树中所有元素的最小元素；
在这里插入图片描述
如上图，最小值为左下角结点09，最大值为右下角结点94。

3.2 二叉树的序列化

将一棵二叉搜索树中序遍历，并记录遍历过程中的数据，便得到二叉搜索树中所有元素的升序排列。（相当于不断地取最小）
如3.1节图，前序遍历该搜索二叉树，得到序列：09 17 23 45 53 65 78 81 87 88 94即为所有元素的一个升序排列。

3.3 打印搜索二叉树

可以采取前序遍历的做法，每个结点占一行，并记录当前结点层数进行打印。（把整个二叉树“横过来”）算法伪代码如下：

//level的初值为-1
PrintTree(ptr,level):
if ptr == nullptr then:
	return;
level ++;
PrintTree(ptr->right,level);
level --;

level ++;
for (int i = 0; i < level; i++)
        cout << "\t";//打印分隔符表明层数
cout << ptr->data << endl;
PrintTree(ptr->left, level);
level--;

3.4 二叉搜索树的删除

采取中序遍历的方法，递归删除结点即可。

四、C++实现二叉搜索树代码

4.1 对教材伪代码框架的改动说明

  1. 与原版教材不同的是，我这里使用模板时省去了关键字key，因为我认为进行比较时，对于一般的数据类型（如int,double,char）等，键值即它本身；而对于结构体类型，完全可以重载它的比较函数，自定义比较键值。
  2. 另外添加了size成员变量及其方法获取树中元素个数。
  3. 添加了GetSeq函数获取二叉搜索树的序列化。

4.2 代码实现

#include <iostream>
#include <assert.h>
using namespace std;
template <class E>
struct BSTNode
{
    E data;
    BSTNode<E> *left, *right;
    BSTNode() : left(nullptr), right(nullptr) {}
    BSTNode(const E d, BSTNode<E> *L = nullptr, BSTNode<E> *R = nullptr) : data(d), left(L), right(R) {}
    ~BSTNode() {}
    void setData(E d) { data = d; }
    E getData() { return data; }
};

template <class E>
class BST
{
public:
    BST() : root(nullptr), size(0) {}
    BST(const BST<E> &R);
    BST(E *Eles, size_t sz);
    ~BST() { makeEmpty(); };
    size_t Size() { return size; }
    bool Search(const E x) const
    {
        return (Search(x, root) != nullptr) ? true : false;
    }
    BST<E> &operator=(const BST<E> &R);
    void makeEmpty()
    {
        makeEmpty(root);
        root = nullptr;
        size = 0;
    }
    void PrintTree()
    {
        int level = -1;
        PrintTree(root, level);
    };
    E Min()
    {
        if (root == nullptr)
        {
            cerr << "BST is empty." << endl;
            exit(-1);
        }
        return Min(root)->data;
    }
    E Max()
    {
        if (root == nullptr)
        {
            cerr << "BST is empty." << endl;
            exit(-1);
        }
        return Max(root)->data;
    }
    bool Insert(const E &el) { return Insert(el, root); }
    bool Remove(const E x) { return Remove(x, root); }
    E *GetSeq(); //将二叉搜索树中所有结点按升序排列，返回到seq中
private:
    size_t size;
    BSTNode<E> *root;                                     //二叉搜索树根节点                                      //输入停止标志，用于输入
    BSTNode<E> *Search(const E x, BSTNode<E> *ptr) const; //递归：搜索
    void makeEmpty(BSTNode<E> *&ptr);                     //递归：置空
    void PrintTree(BSTNode<E> *ptr, int level) const;     //递归：打印
    BSTNode<E> *Copy(const BSTNode<E> *ptr) const;        //递归：复制
    BSTNode<E> *Min(BSTNode<E> *ptr) const;               //递归：求最小
    BSTNode<E> *Max(BSTNode<E> *ptr) const;               //递归：求最大
    bool Insert(const E &el, BSTNode<E> *&ptr);           //递归：插入
    bool Remove(const E x, BSTNode<E> *&ptr);             //递归：删除
    void GetSeq(E *x, int &cnt, BSTNode<E> *&ptr);
};

//建立二叉搜索树
template <class E>
BST<E>::BST(E *Eles, size_t sz)
{
    //输入一个元素序列，建立一棵二叉搜索树
    E x;
    root = nullptr;
    size = 0;
    for (int i = 0; i < sz; i++)
    {
        x = Eles[i];
        Insert(x, root);
    }
}

template <class E>
BSTNode<E> *BST<E>::Search(const E x, BSTNode<E> *ptr) const
{
    //私有递归函数，在以ptr为根的二叉搜索树中搜索含x的结点。若找到，则函数返回该结点的地址，否则返回nullptr。
    if (ptr == nullptr)
        return nullptr;
    else if (x < ptr->data)
        return Search(x, ptr->left);
    else if (x > ptr->data)
        return Search(x, ptr->right);
    else
        return ptr;
}

template <class E>
bool BST<E>::Insert(const E &el, BSTNode<E> *&ptr)
{
    if (ptr == nullptr)
    {
        ptr = new BSTNode<E>(el);
        if (ptr == nullptr)
        {
            cerr << "Out of space." << endl;
            exit(-1);
        }
        size += 1;
        return true;
    }
    else if (el < ptr->data)
        return Insert(el, ptr->left);
    else if (el > ptr->data)
        return Insert(el, ptr->right);
    else
        return false; //值相等，插入失败
    return true;
}

template <class E>
bool BST<E>::Remove(const E x, BSTNode<E> *&ptr)
{
    BSTNode<E> *temp;
    if (ptr != nullptr)
    {
        if (x < ptr->data)
            Remove(x, ptr->left);
        else if (x > ptr->data)
            Remove(x, ptr->right);
        else if (ptr->left != nullptr && ptr->right != nullptr)
        {
            temp = ptr->right;
            while (temp->left != nullptr)
                temp = temp->left;
            ptr->data = temp->data;
            Remove(ptr->data, ptr->right);
        }
        else
        {
            temp = ptr;
            if (ptr->left == nullptr)
                ptr = ptr->right;
            else
                ptr = ptr->left;
            delete temp;
            size -= 1;
            return true;
        }
    }
    return false;
}

template <class E>
void BST<E>::makeEmpty(BSTNode<E> *&ptr)
{
    if (ptr == nullptr)
        return;
    if (ptr->left != nullptr)
    {
        makeEmpty(ptr->left);
    }
    else if (ptr->right != nullptr)
    {
        makeEmpty(ptr->right);
    }
    delete ptr;
    ptr = nullptr;
    return;
}

template <class E>
void BST<E>::PrintTree(BSTNode<E> *ptr, int level) const
{
    if (ptr == nullptr)
    {
        return;
    }

    level++;
    PrintTree(ptr->right, level);
    level--;

    level++;
    for (int i = 0; i < level; i++)
        cout << "\t";
    cout << ptr->data << endl;
    PrintTree(ptr->left, level);
    level--;
}

template <class E>
BST<E>::BST(const BST<E> &R)
{
    if (this != &R)
    {
        this->root = R.Copy(R.root);
        this->size = R.size;
    }
}
template <class E>
BST<E> &BST<E>::operator=(const BST<E> &R)
{
    if (this != &R)
    {
        this->makeEmpty(); //防止内存泄漏，先释放原来的空间
        this->root = R.Copy(R.root);
        this->size = R.size;
    }
    return *this;
}
template <class E>
BSTNode<E> *BST<E>::Copy(const BSTNode<E> *ptr) const
{
    if (ptr == nullptr)
        return nullptr;
    BSTNode<E> *ret = new BSTNode<E>(ptr->data);
    ret->left = Copy(ptr->left);
    ret->right = Copy(ptr->right);
    return ret;
}

template <class E>
BSTNode<E> *BST<E>::Min(BSTNode<E> *ptr) const
{
    if (ptr->left != nullptr)
        return Min(ptr->left);
    return ptr;
}

template <class E>
BSTNode<E> *BST<E>::Max(BSTNode<E> *ptr) const
{
    if (ptr->right != nullptr)
        return Max(ptr->right);
    return ptr;
}

template <class E>
E *BST<E>::GetSeq()
{
    E *seq = new E(size);
    int cnt = 0;
    GetSeq(seq, cnt, root);
    return seq;
}

template <class E>
void BST<E>::GetSeq(E *x, int &cnt, BSTNode<E> *&ptr)
{
    if (ptr == nullptr || cnt >= size)
        return;
    GetSeq(x, cnt, ptr->left);
    E e = ptr->data;
    x[cnt] = e;
    cnt++;
    GetSeq(x, cnt, ptr->right);
}

原理已经在上面的讲解中说明清楚了，如果有看不懂的地方，请参照教材和图例，或者在评论区提问。

4.3 使用及测试代码

为了检验实现的正确性，我实现了一些检测功能的demo函数：

//需要包含头文件"assert.h"
void Test_Init()
{
    int a[5] = {1, 2, 3, 4, 5};
    BST<int> bst(a, 5);
    assert(bst.Size() == 5);
    cout << "Test_Init passed." << endl;
}

void Test_Insert()
{
    BST<int> bst;
    for (int i = 0; i <= 10; i += 2)
        bst.Insert(i);
    for (int i = 1; i <= 9; i += 2)
        bst.Insert(i);

    bst.Insert(9); //插入已经存在的元素应该失败
    assert(bst.Size() == 11);
    cout << "Test_Insert passed." << endl;
}

void Test_Remove()
{
    BST<int> bst;
    for (int i = 0; i < 10; i++)
        bst.Insert(i);
    assert(bst.Size() == 10);
    bst.Remove(11); //删除不存在的元素应该失败
    assert(bst.Size() == 10);
    for (int i = 0; i < 10; i++)
    {
        bst.Remove(i);
        assert(bst.Size() == 9 - i);
    }
    cout << "Test_Remove passed." << endl;
}

void Test_Print()
{
    BST<int> bst;
    bst.Insert(3);
    bst.Insert(2);
    bst.Insert(4);
    bst.PrintTree();
    cout << "Test_Print passed." << endl;
}

void Test_Seq()
{
    BST<int> bst;
    bst.Insert(3);
    bst.Insert(5);
    bst.Insert(1);
    bst.Insert(4);
    bst.Insert(2);
    bst.Insert(0);

    int *seq = bst.GetSeq();
    for (int i = 0; i < bst.Size(); i++)
        assert(seq[i] == i);
    cout << "Test_Seq passed." << endl;
}

void Test_Min_Max()
{
    BST<int> bst;
    bst.Insert(3);
    bst.Insert(5);
    bst.Insert(1);
    bst.Insert(4);
    bst.Insert(2);
    bst.Insert(0);

    assert(bst.Max() == 5);
    assert(bst.Min() == 0);
    cout << "Test_Min_Max passed." << endl;
}

void Test_Copy()
{
    BST<int> bst;
    bst.Insert(1);
    bst.Insert(0);
    bst.Insert(2);

    BST<int> bst2 = bst; //拷贝构造函数
    assert(bst2.Size() == bst.Size());
    int *seq2 = bst2.GetSeq();
    for (int i = 0; i < 3; i++)
        assert(seq2[i] == i);

    BST<int> bst3; //赋值重载函数
    bst3 = bst;
    assert(bst3.Size() == bst.Size());
    int *seq3 = bst3.GetSeq();
    for (int i = 0; i < 3; i++)
        assert(seq3[i] == i);

    cout << "Test_Copy passed." << endl;
}

void Test_Empty()
{
    BST<int> bst;
    bst.Insert(1);
    bst.Insert(0);
    bst.Insert(2);
    assert(bst.Size() == 3);

    bst.makeEmpty();
    assert(bst.Size() == 0);

    for (int i = 0; i < 3; i++)
    {
        bst.Insert(i);
        assert(bst.Size() == i + 1);
    }

    cout << "Test_Empty passed." << endl;
}

void Test_All()
{
    Test_Init();
    Test_Insert();
    Test_Remove();
    Test_Print();
    Test_Seq();
    Test_Copy();
    Test_Min_Max();
    Test_Empty();

    cout << "All Test Passed." << endl;
}
int main()
{
    Test_All();
}

运行效果：
在这里插入图片描述
大家可以先大致看下讲解（如果不懂的话），然后根据需求自取代码。

宇航员写代码
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++编写二叉树源代码
11-18
欢迎大家来访问C++编写二叉树源代码121111111111
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
c++二叉树详解（附基本操作代码版）
Yoyo的博客
07-10 4204
二叉树可以说是树形数据结构中最基础的，且在多种领域都有应用（比如语法树，二值决策树），熟悉其各种操作是必须的。char data;}BT;// 根据输入二点中序表达式和前序表达式创建一颗二叉树// 展示一颗二叉树，以A(B, C(D, E))这样加了括号的前序遍历来实现// 销毁二叉树// 判断这颗树是不是完全二叉树// 计算树的高度// 计算叶子的数量// 计算树的宽度// 层次遍历// 前序遍历// 中序遍历// 后序遍历。
C++实现搜索二叉树(Binary Search Tree)
2301_81261654的博客
03-19 308
对只有一个key的二叉搜索树稍加改造，这样一个key,value模型就完成了，这种KV模型存在的意义便是，可以通过找到key所在的位置从而找到该位置的val，这个模型的运用场景有很多，以下有一段示例代码。另外还可以利用KV模型进行计数操作，记录key出现的次数，示例代码如下所示。以上便是关于搜素二叉树的实现和运用，希望能够班帮助到大家。
二叉搜索树详解及代码实现
qzt__l0ve的博客
05-18 1210
二叉搜索树代码详解 增删查操作 递归非递归的实现--c++ 二叉搜索树K模型 KV模型
C++实现树 - 02 二叉树
Newin2020的博客
05-04 4992
写在前面： 这一讲我们来看看二叉树的实现，还不清楚树的结构的小伙伴建议先看看上面一讲关于树的定义。 二叉树的定义 二叉树是每个结点最多有两个子树的树结构。也就是说二叉树不允许存在度大于2的树。它有五种最基本的形态：二叉树可以是空集。根可以有空的左自树或者右子树；或者左右子树都是空。其中只有左子树或者右子树的叫做斜树。 二叉树的主要性质 性质 结论 性质一 在二叉树的 i 层上至多有 2 ^ ( i - 1 ) 个结点（ i >= 1 ） 性质二 深度为 k 的二叉树至多有 2.
数据结构-树与二叉树-C++代码实现
lljjhh001的博客
04-14 1367
3.否则（注意这个else语句，否则包括：l<r 和 l=r 两种情况，比如某个结点为叶子结点，那么它的l=r=0,此时递归函数是有返回值的为：r+1，这点很容易被忽略，这也是递归能够持续下去的出发点）就返回r+1；假设B是A的孩子，T初始时指向A，比如T=T->Lchild执行后，此时T的指向已经发生改变，指向B,是一个动态递归的过程。2）数字和字母都属于字符，代码中定义data的数据类型为char型，所以输入数字和字母，代码都能完成遍历，无需将data类型改为int，反而会出错。
C++ 二叉搜索树(BST)的实现方法
08-30
主要介绍了C++ 二叉搜索树(BST)的实现方法，非常不错，具有参考借鉴价值，需要的的朋友参考下
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
二叉树 二叉树_基于C++实现的二叉搜索树
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
二叉搜索树（BST-Tree）(C++全)
weixin_48560325的博客
04-28 4650
目录 二叉搜索树基本概念 1，什么是根节点 2、什么是二叉搜索树 3、二叉搜索树结构 4、二叉搜索树的性质 5、复杂度 算法实现 1、创建一个二叉搜索树节点 2、打印二叉搜索树 3、二叉搜索树的插入 4、其他操作 （1）查找二叉搜索树的最大值 （2）查找二叉搜索树的最小值 （3）查找某一节点的前驱 （4）查找某一节点的后继 5、删除二叉搜索树的某一节点 步骤： 代码： 性能分析 二叉搜索树基本概念 1，什么是根节点 根结点（root）是树的一个组成部分，也
一文搞懂二叉搜索树及代码实现（C++版）
君莫笑lucky的博客
03-08 420
✊✊✊🌈大家好！本篇文章将较详细介绍二叉搜索树的相关内容，并对二叉搜索树的构建、前中后序遍历、层次遍历、树的高度及查找进行代码实现。代码语言为：C++代码 😇。
【C++】二叉搜索树
在平淡的日子里寻找存在的价值
03-21 656
a. 二叉搜索树左孩子小于根小于右孩子，所以左子树的最大节点一定大于当前节点的其余左子树节点，小于当前节点的所有右子树节点，那么将它替换掉当前节点后二叉搜索树仍然能保存二叉搜索树的结构 – 左子树节点全部小于根，右子树节点全部大于根；选右子树最小节点同理。给一个单词word，判断该单词是否拼写正确 – 我们可以将 K 的类型定义为 string，然后将英语词库中的所有单词作为 key，构建一颗二叉搜索树，然后在二叉搜索树中对用户写出的每一个单词进行查找，如果找不到，则说明该单词拼写错误。
二叉树代码（C++实现）
lanjiangyu的博客
03-23 297
【代码】二叉树代码（C++实现）
C++搜索二叉树
RXY24601的博客
05-27 1157
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
数据结构 | 二叉查找树(二叉搜索/排序树)详细代码
DBEBCXRQ的博客
09-11 187
2.把元素插入二叉查找树（构造二叉查找树）4.findmin()函数。
二叉树的代码实现（C++）
qq_46601680的博客
10-24 4567
主要功能：递归创建二叉树、递归先序遍历、中序遍历、后序遍历、复制二叉树、计算二叉树深度、计算结点数、计算叶子节点数 完整代码： #include <iostream> using namespace std; //数据结构 typedef struct BiTNode{ char data; struct BiTNode *lchild; struct BiTNode *rchild; }BiTNode,*BiTree; //先序遍历的顺序建立二叉链表 void
二叉搜索树查找c++代码
11-17
下面是一个使用递归的方式来实现二叉搜索树的查找代码： ```python def search(root, c): if root is None: return False if root.val == c: return True elif root.val > c: return search(root.left, c) ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值