C++一步一步实现二叉搜索树

最新推荐文章于 2025-06-07 17:14:27 发布
最新推荐文章于 2025-06-07 17:14:27 发布
阅读量386 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构-C++ 文章标签： stl 源码 class 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011283415/article/details/63252868
本文通过《STL源码剖析》关联容器章节，介绍了如何一步步实现二叉搜索树，包括节点插入、建立、中序遍历、查找、删除及销毁等功能。文章详细解释了每个操作的逻辑，并提供了完整的C++代码实现。此外，还通过一道题目验证了二叉搜索树的操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

学习《STL源码剖析》关联容器的章节，map,set等关联容器的底层实现都是红黑树，本着循序渐进的思想，先实现二叉搜索树。读懂了二叉搜索树的定义后，实现了二叉搜索树的基本功能。文章属原创，代码全手打，欢迎指正讨论。首先给出类的定义，如下：

#include<iostream>
#include<string>
#include<cstring>
#include<sstream>
//#include<>
using namespace std;
class BST
{
private:
    //嵌套类，仅在BST中有效
    class Node
    {
    public:
        int val;
        Node *left;
        Node *right;
        Node *parent; //增加父节点，在删除节点时父节点很有用

        Node()
        {
            val = 0;
            left = right = parent = NULL;
        }
    };
    Node *m_root;      //存储根节点
    Node *m_cur;       //存储查找的结果  
    int   m_size;      //存储树的大小

    void SetNode(Node* cur,Node* newNode);           //设置节点的父子关系
    bool CompareTree(const Node *r1,Node* r2) const;
public:
    bool InsertNode(const int val);                  //插入节点
    bool FindNode(const int val);                    //找到返回true，val所在的位置就是pos
    bool DelNode(const int val);                     //删除节点
    void Inorder(Node *p, string &str) const;        //中序遍历输出参数可自定义
    void DestroyTree(Node *p);                       //销毁整棵二叉树,模仿后序遍历  
    bool operator==(BST &t) const;                   //用于判断两个BST是否相等
    void CreateBST(const string &str);

    Node* GetRootNode() const
    {
        return m_root;
    }
    BST() :m_root(NULL), m_cur(NULL),m_size(0){}
    ~BST()
    {
        DestroyTree(m_root);
    }
};

一、实现节点插入功能，此处是构建二叉搜索树的基本操作。插入节点时需满足的条件有二：
1、左子树小于父节点。
2、右子树不小于父节点。
以下是详细实现代码，以下代码虽不是最简短的写法，但是但是能想到的思路最清晰的写法，适合用于学习理解二叉搜索树。

bool BST::InsertNode(const int val)
{
    Node *p = new Node();
    p->val = val;
    m_size++;
    if (m_root == NULL)
    {
        m_root = p;
        return true;
    }
    Node * cur = m_root;
    Node * last = m_root;
    bool lflag = false;  //为true说明是左子树
    while (cur != NULL)
    {
        last = cur;
        if (val >= cur->val)
        {
            cur = cur->right;
            lflag = false;
        }
        else
        {
            cur = cur->left;
            lflag = true;
        }
    }

    //建立父节点与子树的关系
    cur = p;
    cur->parent = last;
    lflag == true ? last->left = cur : last->right = cur;

    return true;
}

二、建立二叉搜索树。此处只需要循环调用上面实现的InsertNode方法即可。

void BST::CreateBST(const string &str)
{
    stringstream ss;
    int val;
    for (int i = 0; i < str.size(); i++)
    {
        ss << str[i];
        ss >> val;
        ss.clear();//多次转换需要清空
        InsertNode(val);
    }
}

三、中序遍历二叉搜索树。二叉搜索树中序遍历的结果可得到递增的有序序列，从此处可以理解为BST查找的平均复杂度是O(logn)，因为其查找过程类似于二分查找。为了方便输出查看，将输出结果放在string中。中序遍历实现方法有两种，其一为采用递归的方式；其二为使用栈来辅助实现。此处给出递归版本，今后再补充给出非递归版本。

void BST::Inorder(Node *p, string &st) const
{
    if (p == NULL)
    {
        return;
    }
    Inorder(p->left,st);
    stringstream ss;
    string t;
    ss << p->val;
    ss >> t;
    st += t;
    Inorder(p->right, st);
}

四、在二叉搜索树中查找节点。二叉排序树的查找操作，平均复杂度为O(logn)，最差为O(n)。而平衡二叉搜索树能很好的处理最坏情况。常见的平衡二叉搜索树：红黑树等

bool BST::FindNode(const int val)
{
    if (m_root == NULL)
    {
        return false;
    }
    bool ret = false;
    Node * cur = m_root;
    while (cur != NULL)
    {
        if (cur->val == val)
        {
            m_cur = cur;
            ret = true;
            break;
        }
        else if (val > cur->val)
        {
            cur = cur->right;
        }
        else
        {
            cur = cur->left;
        }
    }
    return ret;
}

五、二叉搜索树删除节点。二叉搜索树不能只是简单的删除某个节点，应该保证BST删除元素后仍然符合二叉搜索树的定义。删除分为三种情况：
1、左子树和右子树均不为空，那么就从右子树中找到一个最小值来替换。
2、仅有一个单个子树，那就将当前元素删除即可
3、没有子树
在编码时一定要注意根节点是特殊情况，根节点没有父节点。
此处代码分为两个步骤，首先找到要替代节点（倘若有），然后替换掉原来的节点。 

bool BST::DelNode(const int val)
{
    if (m_root == NULL)
    {
        return false;
    }
    m_size--;
    if (!FindNode(val))
    {
        return false;
    }
    //难点：找到叶子节点后如何处理父节点，防止父节点中出现野指针
    //为方便操作，而返回去增加定义父指针
    if (m_cur->left != NULL && m_cur->right != NULL)//有两个子树
    {
        Node * min = m_cur->right;  
        while (min->left != NULL)
        {
            min = min->left;
        }
        m_cur->right == min ? min->parent->right = NULL : min->parent->left = NULL;
        SetNode(m_cur,min);
        delete m_cur;
        m_cur = NULL;
    }
    else if (m_cur->left != NULL || m_cur->right != NULL)//仅有一个子树
    {
        if (m_cur->left != NULL)
        {
            SetNode(m_cur, m_cur->left);
            delete m_cur;
            m_cur = NULL;
        }
        else
        {
            SetNode(m_cur, m_cur->right);
            delete m_cur;
            m_cur = NULL;
        }
    }
    else //叶子节点、无子树的根节点直接删除
    {
        SetNode(m_cur, NULL);
        delete m_cur;
        m_cur = NULL;
    }
    return false;
}

DelNode方法中调用的SetNode代码实现如下，主要作用是重新设定原来节点周围的父子关系。
总共要设定五条关系
1、当前节点与父节点之间的关系（单边1条）
2、与左子树之间的关系（双边2条）
3、与右子树之间的关系（双边2条）

void BST::SetNode(Node* cur, Node* newNode)
{
    //与父节点
    if (cur->parent != NULL)
    {
        if (cur->parent->left == cur)
        {
            cur->parent->left = newNode;
        }
        else
        {
            cur->parent->right = newNode;
        }
    }
    else
    {
        m_root = newNode;  //父节点为空，说明为根节点
    }
    //与左子树
    if (cur->left != NULL)
    {
        //子->父
        cur->left->parent = newNode;
        //父->子
        if (newNode != cur->left)
        {
            newNode->left = cur->left;
        }
        else
        {
            //不操作
        }

    }
    //右子树
    if (cur->right != NULL)
    {
        //子->父
        cur->right->parent = newNode;
        if (newNode != cur->right)
        {
            newNode->right = cur->right;
        }
        else
        {
            //不操作
        }
    }
}
六、二叉树拓扑结构比较。为了比较两个二叉树是否相同，可采用递归的方式实现，代码如下：

bool BST::CompareTree(const Node *r1,Node* r2) const
{
    if (r1 == NULL && r2 == NULL)
    {
        return true;
    }
    if (r1 == NULL || r2 == NULL)
    {
        return false;
    }
    if (r1->val == r2->val)
    {
        if (CompareTree(r1->left, r2->left) && CompareTree(r1->right, r2->right))
        {
            return true;
        }
    }
    return false;
}
bool BST::operator==(BST &t) const
{
    return CompareTree(GetRootNode(),t.GetRootNode());
}

七、二叉搜索树的销毁。所有节点均使用的new获取的堆空间，因此必须手动释放，否则会造成内存泄漏。释放的方法模仿后序遍历实现。

void BST::DestroyTree(Node *p)
{
    if (p == NULL)
    {
        return;
    }
    DestroyTree(p->left);
    DestroyTree(p->right);
    delete p;
}

现在二叉搜索树已经实现，可以通过一道题目来练习。
题目描述
判断两序列是否为同一二叉搜索树序列
输入描述:
开始一个数n，(1<=n<=20) 表示有n个需要判断，n= 0 的时候输入结束。
接下去一行是一个序列，序列长度小于10，包含(0~9)的数字，没有重复数字，根据这个序列可以构造出一颗二叉搜索树。
接下去的n行有n个序列，每个序列格式跟第一个序列一样，请判断这两个序列是否能组成同一颗二叉搜索树。

输出描述:
如果序列相同则输出YES，否则输出NO

输入例子:
2
567432
543267
576342
0

输出例子:
YES
NO

整个工程的全部代码如下：

#include<iostream>
#include<stack>
#include<vector>
#include<queue>
#include<map>
#include<algorithm>
#include<cctype>
#include<string>
#include<cstring>
#include<sstream>
//#include<>
using namespace std;

class BST
{
private:
    //嵌套类，仅在BST中有效
    class Node
    {
    public:
        int val;
        Node *left;
        Node *right;
        Node *parent; //增加父节点，在删除节点时父节点很有用

        Node()
        {
            val = 0;
            left = right = parent = NULL;
        }
    };
    Node *m_root; //存储根节点
    Node *m_cur;    //存储查找的结果  
    int m_size;   //存储树的大小

    void SetNode(Node* cur,Node* newNode); //设置节点的父子关系
    bool CompareTree(const Node *r1,Node* r2) const;
public:
    bool InsertNode(const int val);                  //插入节点
    bool FindNode(const int val);   //找到返回true，val所在的位置就是pos
    bool DelNode(const int val);                     //删除节点
    void Inorder(Node *p, string &str) const;        //中序遍历输出参数可自定义
    void DestroyTree(Node *p);                       //销毁整棵二叉树,模仿后序遍历  
    bool operator==(BST &t) const;                    //用于判断两个BST是否相等
    void CreateBST(const string &str);

    Node* GetRootNode() const
    {
        return m_root;
    }
    BST() :m_root(NULL), m_cur(NULL),m_size(0){}
    ~BST()
    {
        DestroyTree(m_root);
    }
};
//二叉排序树的查找操作，平均复杂度为O(logn)，最差为O(n)。而平衡二叉搜索树能很好的
//处理最坏情况。常见的平衡二叉搜索树：红黑树等
bool BST::FindNode(const int val)
{
    if (m_root == NULL)
    {
        return false;
    }
    bool ret = false;
    Node * cur = m_root;
    while (cur != NULL)
    {
        if (cur->val == val)
        {
            m_cur = cur;
            ret = true;
            break;
        }
        else if (val > cur->val)
        {
            cur = cur->right;
        }
        else
        {
            cur = cur->left;
        }
    }
    return ret;
}

bool BST::InsertNode(const int val)
{
    Node *p = new Node();
    p->val = val;
    m_size++;
    if (m_root == NULL)
    {
        m_root = p;
        return true;
    }

    Node * cur = m_root;
    Node * last = m_root;
    bool lflag = false;
    while (cur != NULL)
    {
        last = cur;
        if (val >= cur->val)
        {
            cur = cur->right;
            lflag = false;
        }
        else
        {
            cur = cur->left;
            lflag = true;
        }
    }
    cur = p;
    cur->parent = last;
    lflag == true ? last->left = cur : last->right = cur;
    return true;
}

void BST::CreateBST(const string &str)
{
    stringstream ss;
    int val;
    for (int i = 0; i < str.size(); i++)
    {
        ss << str[i];
        ss >> val;
        ss.clear();//多次转换需要清空
        InsertNode(val);
    }
}

/*
总共要设定五条关系
1、当前节点与父节点之间的关系（单边1条）
2、与左子树之间的关系（双边2条）
3、与右子树之间的关系（双边2条）
*/

void BST::SetNode(Node* cur, Node* newNode)
{
    //与父节点
    if (cur->parent != NULL)
    {
        if (cur->parent->left == cur)
        {
            cur->parent->left = newNode;
        }
        else
        {
            cur->parent->right = newNode;
        }
    }
    else
    {
        m_root = newNode;  //父节点为空，说明为根节点
    }

    //与左子树
    if (cur->left != NULL)
    {
        //子->父
        cur->left->parent = newNode;

        //父->子
        if (newNode != cur->left)
        {
            newNode->left = cur->left;
        }
        else
        {
            //不操作
        }

    }

    if (cur->right != NULL)
    {
        //子->父
        cur->right->parent = newNode;
        if (newNode != cur->right)
        {
            newNode->right = cur->right;
        }
        else
        {
            //不操作
        }
    }

}
//二叉搜索树不能只是简单的删除某个节点，应该保证删除元素后
//仍然符合二叉搜索树的定义
/*
1、左子树和右子树均不为空，那么就从右子树中找到一个最小值来替换。
2、仅有一个单个子树或者没有子树，那就将当前元素删除即可
*/
bool BST::DelNode(const int val)
{
    if (m_root == NULL)
    {
        return false;
    }
    m_size--;
    if (!FindNode(val))
    {
        return false;
    }
    //难点：找到叶子节点后如何处理父节点，防止父节点中出现野指针
    //为方便操作，而返回去增加定义父指针
    if (m_cur->left != NULL && m_cur->right != NULL)
    {
        Node * min = m_cur->right;  
        while (min->left != NULL)
        {
            min = min->left;
        }
        m_cur->right == min ? min->parent->right = NULL : min->parent->left = NULL;
        SetNode(m_cur,min);
        delete m_cur;
        m_cur = NULL;
    }
    else if (m_cur->left != NULL || m_cur->right != NULL)
    {
        if (m_cur->left != NULL)
        {
            SetNode(m_cur, m_cur->left);
            delete m_cur;
            m_cur = NULL;
        }
        else
        {
            SetNode(m_cur, m_cur->right);
            delete m_cur;
            m_cur = NULL;
        }
    }
    else //叶子节点、无子树的根节点直接删除
    {
        SetNode(m_cur, NULL);
        delete m_cur;
        m_cur = NULL;
    }
    return false;
}

bool BST::CompareTree(const Node *r1,Node* r2) const
{
    if (r1 == NULL && r2 == NULL)
    {
        return true;
    }
    if (r1 == NULL || r2 == NULL)
    {
        return false;
    }
    if (r1->val == r2->val)
    {
        if (CompareTree(r1->left, r2->left) && CompareTree(r1->right, r2->right))
        {
            return true;
        }
    }
    return false;
}
bool BST::operator==(BST &t) const
{
    return CompareTree(GetRootNode(),t.GetRootNode());
}
void BST::Inorder(Node *p, string &st) const
{
    if (p == NULL)
    {
        return;
    }
    Inorder(p->left,st);
    stringstream ss;
    string t;
    ss << p->val;
    ss >> t;
    st += t;
    Inorder(p->right, st);
}

void BST::DestroyTree(Node *p)
{
    if (p == NULL)
    {
        return;
    }
    DestroyTree(p->left);
    DestroyTree(p->right);
    delete p;
}
int main()
{
    //注释掉的为原始测试代码
    //BST tree;
    //BST tree1,tree2;
    //string str = "567432";// "567043289";
    //string str1 = "543267";
    //string str2 = "576342";
    //tree.CreateBST(str);
    //tree1.CreateBST(str1);
    //tree2.CreateBST(str2);
    //if (tree2 == tree)
    //{
    //  cout << "same tree!!" << endl;
    //}
    //str.clear();
    //tree.Inorder(tree.GetRootNode(),str);
    //cout << str << endl;
    //if(tree.FindNode(4))
    //{
    //  cout << "I find it !!" << endl;
    //}
    //else
    //{
    //  cout << "I find nothing！" << endl;
    //}

    //tree.DelNode(4);

    //if (tree.FindNode(4))
    //{
    //  cout << "I find it !!" << endl;
    //}
    //else
    //{
    //  cout << "I find nothing!" << endl;
    //}
    //str.clear();
    //tree.Inorder(tree.GetRootNode(), str);
    //cout << str << endl;

    int n = 0;
    string str;
    while (cin >> n >> str)
    {
        BST tree;
        tree.CreateBST(str);
        while (n--)
        {
            string match;
            cin >> match;
            BST treeMatch;
            treeMatch.CreateBST(match);
            if (tree == treeMatch)
            {
                cout << "YES" << endl;
            }
            else
            {
                cout << "NO"<< endl;
            }
        }
    }
    return 0;
}

写在最后：完整的实现了二叉搜索树后回过来看，在实现删除功能时可以不增加父指针，增加的指针带来了替换操作的复杂度上升。直接导致这部分代码需要更多的时间调试。

C++实现二叉搜索树
CodeRoarX的博客
09-05 101
二叉搜索树（Binary Search Tree）是一种常见的数据结构，它具有高效的插入、删除和搜索操作。在本文中，我们将使用C++来实现一个二叉搜索树，并提供相应的源代码。在上面的代码中，我们首先创建了一个BinarySearchTree对象，并插入了一些节点。然后，我们搜索值为4的节点，并输出结果。通过以上的代码，我们成功地实现了一个二叉搜索树，并进行了一些基本的操作。首先，让我们定义二叉搜索树的节点结构。接下来，我们可以定义一个BinarySearchTree类，用于管理二叉搜索树。
C++实现一个简单的二叉搜索树
Jing Sir的博客
05-08 9411
如下所示，这是一个简单的二叉搜索树： template <class T> class binarysearchtreenode { public: T data; binarysearchtreenode<T> *leftchild; binarysearchtreenode<T> * rightchild; binarysearchtreenode () { leftchild=rightchild=NULL; } binarysearchtre
c++实现二叉搜索树
longhopefor,开启学习之路
06-13 1075
自己实现了一下二叉搜索树的数据结构，记录一下： #include using namespace std; struct TreeNode{ int val; TreeNode *left; TreeNode *right; TreeNode(int value) { val=value; left=NULL; right=NULL; } }; clas
【C++】二叉搜索树
最新发布
whispers421的博客
06-07 457
二叉搜索树（Binary Search Tree, BST）是一种二叉树数据结构，其中每个节点的值都大于其左子树中所有节点的值，且小于其右子树中所有节点的值。这一性质递归地适用于所有子树，使得中序遍历BST会得到一个严格升序的序列。如下图：这就是一个简单的二叉搜索树。
【 C++ 】二叉搜索树
bit_zyx的博客
09-03 1573
目录 1、二叉搜索树的概念 2、二叉搜索树的实现 ①、结点类 ②、二叉搜索树的类 2.1、默认成员函数 构造函数 拷贝构造函数 赋值运算符重载函数 析构函数 2.2、中序遍历 2.3、Insert插入函数 ............
【二叉搜索树】c++实现二叉搜索树
yizhizainulii的博客
04-15 2330
二叉搜索树的定义： 二叉树中每一个节点： 若其左子树存在，则其左子树中每个节点的值都小于该节点值， 若其右子树存在，则其右子树中每个节点的值都大于该节点值。 没有键值相等的节点。 如果想了解更多二叉搜索树的定义：数据结构（二）：二叉搜索树（Binary Search Tree） 二叉搜索树主要是用来查找和排序的， 查找的时间复杂度o(logn) ~ o(n) ， 排序只要中序遍历一遍就可以得到有序的序列。 代码： #include <iostream> using namespace
C++ 实现二叉搜索树
sushhsishdgsusk的博客
09-13 323
可以说，二叉搜索树在查找上面的进步是很大，他的平均查找速度为O(logN),最坏查找情况为O(N）。（N为树的高度）为什么呢，其实类似于二分查找，它每次在查找的时候都只会前往左右区间，也就是直接剔除一半的值，最后便得出平均查找速度。最坏查找是因为有特殊情况，（一般是有序）使二叉树退化成单子树，从而大幅降低了查找效率。
二叉树-基于C++实现的二叉搜索树.zip
04-26
为了实现插入、查找和删除的递归辅助函数，我们需要考虑每一步如何调整树的结构以保持二叉搜索树的特性。在删除操作中，我们可能需要找到一个替代节点来替换被删除的节点，以保持树的平衡。 在实际应用中，二叉搜索...
【C++】——二叉搜索树（详解）
m0_74092462的博客
06-23 1053
以上就是搜索二叉树的大概内容了，希望对你有用。
VC/C++实现二叉搜索树查找算法
12-21
在本主题中，我们将深入探讨如何使用VC/C++编程语言实现二叉搜索树的查找算法。 首先，我们需要理解二叉搜索树的基本性质：对于树中的每个节点，其左子树中的所有节点的值都小于该节点，而右子树中的所有节点的值都...
C++实现二叉搜索树的数据结构分析
C++中的二叉搜索树实现会涉及以下关键点： - 定义树节点（通常是一个结构体或类），包含数据值以及指向左右子树的指针。 - 实现插入操作，用于将新元素加入树中。 - 实现查找操作，用于在树中查找特定值。 - 实现...
最优二叉搜索树的动态规划算法
04-23
在每一步中，我们都保存当前最优解，最后得到的`dp[keys.Length]`即为整个序列的最优二叉搜索树成本。 在实际代码实现中，除了动态规划数组`dp`，还需要一个二维数组`parent`来记录每个状态对应的最优分割点，这有...
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
二叉搜索树(C++实现)
qq_56628506的博客
08-22 3046
二叉搜索树初探
C++——二叉搜索树的实现
大学生一枚
07-13 479
二叉搜索树又叫做二叉排序树，他或者是一棵空树，或者具有以下性质：若他的左子树不为空，则左子树的所有节点的值都小于根节点的值，若他的右子树不为空，则右子树的所有节点的值都大于根节点的值，他的左右子树也分别为二叉搜索树；
[数据结构C++实现]二叉搜索树
Protein_zmm的博客
08-04 1043
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 三、二叉搜索树实现 3.1 非递归版本 插入 删除没有孩子的节点 只有一个孩子的节点 有两个孩子的节点 并且最右节点(一定右为空)或者最左节点(一定左为空)删除只有一个孩子节点的情况： 父亲会不会为空？——会，只有根节点父亲会为空 让root指向cur的孩子有两个孩子的节点：要么找右子树最左节点或者是左子树最右节点若删除5： 若删除7：不要给空：，不然min父节点为空，之后又会出错 3.2 递归版本 递归可能会爆栈
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值