二叉搜索树完整实现（BST）

最新推荐文章于 2024-08-19 00:01:32 发布
最新推荐文章于 2024-08-19 00:01:32 发布
阅读量137 收藏 1
点赞数
分类专栏： C++ 文章标签： 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62291184/article/details/128819966
版权

几段重要的代码以及讲解

一.findMin和findMax

    Node* findMin(Node* t) const
    {
        if (t == nullptr)  return nullptr;
        if (t->left == nullptr) return t;
        return findMin(t->left);
    }

    Node* findMax(Node* t) const
    {
        if (t == nullptr)  return nullptr;
        if (t->right == nullptr) return t;
        return findMax(t->right);
    }

二.insert

   /*
    void insert(E x, Node* t)
    {
        if (t == nullptr)
            t = new Node{ x,nullptr,nullptr };
        else if (x < t->data) insert(x, t->left);
        else if (x > t->data)    insert(x, t->right);
        else;
    }
    */


    void insert(const E &x, Node* &t)
    {
        if (t == nullptr)
            t = new Node{ x,nullptr,nullptr };
        else if (x < t->data)    insert(x, t->left);
        else if (x > t->data)    insert(x, t->right);
        else;
    }
    
    
    void insert(E&& x,Node*& t)
    {
        if (t == nullptr)
            t = new Node{ std::move(x),nullptr,nullptr };
        else if (x < t->data)
            insert(std::move(x), t->left);
        else if (x > t->data)
            insert(std::move(x), t->right);
        else;
    }

三.remove

//这里一定要用Node *&
    void remove(const E& x, Node*& t)
    {
        if (t == nullptr) return;
        if (x < t->data)      remove(x, t->left);
        else if (x > t->data) remove(x, t->right);
        else if (t->left != nullptr && t->right != nullptr)  //两个儿子
        {
            t->data = findMin(t->right)->data;      //用右子树的最小值来代替这个要被删除的结点的值
            remove(t->data, t->right);              //递归的删除用来替代的结点
        }
        else
        {
            Node* old = t;
            t = (t->left != nullptr) ? t->left : t->right;
            delete old;
        }
    }

  /*
    void remove(E x, Node* t)
    {
        if (t == nullptr) return;
        if (x < t->data) remove(x, t->left);
        else if (x > t->data) remove(x, t->right);
        else if (t->left != nullptr && t->right != nullptr)  //两个儿子
        {
            t->data = findMin(t->right)->data;      //用右子树的最小值来代替这个要被删除的结点的值
            remove(t->data, t->right);              //递归的删除用来替代的结点
        }
        else
        {
            Node* old = t;
            t = (t->left != nullptr) : t->left ? t->right;
            delete old;
        }
    }*/

四.树的遍历（前中后序）

    
    void printTree_Inorder(Node* t) const
    {
        if (t != nullptr)
        {
            printTree_Inorder(t->left);
            std::cout << t->data << " ";
            printTree_Inorder(t->right);
        }
        
    }

    void printTree_Preorder(Node* t) const 
    {
        if (t != nullptr)
        {
            std::cout << t->data << " ";
            printTree_Preorder(t->left);
            printTree_Preorder(t->right);
        }
    }

    void printTree_Postorder(Node* t) const
    {
        if (t != nullptr)
        {
            printTree_Postorder(t->left);
            printTree_Postorder(t->right);
            std::cout << t->data<< " ";
        }
    }

思想说明

充分利用C++类的特性，所有的public函数只提供接口（即调用private函数），所有的private函数进行实现。

全部实现代码（BinarySearchTree.cpp）

#include<iostream>

/*
   public 函数基本只提供接口，所有的实现都在 private 函数里实现
*/
template<typename E>
class BinarySearchTree
{
private:
    struct Node
    {
        E data;
        Node* left;
        Node* right;
        Node(const E& element, Node* lt, Node* rt)
            :data{ element }, left{ lt }, right{ rt }
        {

        }
    };

    Node* root;

    Node* clone(Node* t) const
    {
        if (t == nullptr)  return nullptr;
        else return new Node{ t->data,clone(t->left),clone(t->right) };
    }

    void makeEmpty(Node*& t)
    {
        if (t != nullptr)
        {
            makeEmpty(t->left);
            makeEmpty(t->right);
            delete t;
        }
        t = nullptr;
    }

    //这里使用常量引用类型 const E& 避免对x进行修改,同时程序更加高效
    //函数为const 避免修改成员函数
    bool find(const E& x, Node* t) const
    {
        /* x=10 */
        if (t == nullptr)      return false;
        else if (x < t->data)  return find(x, t->left);
        else if (x > t->data)  return find(x, t->right);
        else                   return true;
    }

    Node* findMin(Node* t) const
    {
        if (t == nullptr)  return nullptr;
        if (t->left == nullptr) return t;
        return findMin(t->left);
    }

    Node* findMax(Node* t) const
    {
        if (t == nullptr)  return nullptr;
        if (t->right == nullptr) return t;
        return findMax(t->right);
    }

    /*
    void insert(E x, Node* t)
    {
        if (t == nullptr)
            t = new Node{ x,nullptr,nullptr };
        else if (x < t->data) insert(x, t->left);
        else if (x > t->data)    insert(x, t->right);
        else;
    }*/


    void insert(const E &x, Node* &t)
    {
        if (t == nullptr)
            t = new Node{ x,nullptr,nullptr };
        else if (x < t->data)    insert(x, t->left);
        else if (x > t->data)    insert(x, t->right);
        else;
    }
    
    
    void insert(E&& x,Node*& t)
    {
        if (t == nullptr)
            t = new Node{ std::move(x),nullptr,nullptr };
        else if (x < t->data)
            insert(std::move(x), t->left);
        else if (x > t->data)
            insert(std::move(x), t->right);
        else;
    }

    //这里一定要用Node *&
    void remove(const E& x, Node*& t)
    {
        if (t == nullptr) return;
        if (x < t->data)      remove(x, t->left);
        else if (x > t->data) remove(x, t->right);
        else if (t->left != nullptr && t->right != nullptr)  //两个儿子
        {
            t->data = findMin(t->right)->data;      //用右子树的最小值来代替这个要被删除的结点的值
            remove(t->data, t->right);              //递归的删除用来替代的结点
        }
        else
        {
            Node* old = t;
            t = (t->left != nullptr) ? t->left : t->right;
            delete old;
        }
    }

    /*
    void remove(E x, Node* t)
    {
        if (t == nullptr) return;
        if (x < t->data) remove(x, t->left);
        else if (x > t->data) remove(x, t->right);
        else if (t->left != nullptr && t->right != nullptr)  //两个儿子
        {
            t->data = findMin(t->right)->data;      //用右子树的最小值来代替这个要被删除的结点的值
            remove(t->data, t->right);              //递归的删除用来替代的结点
        }
        else
        {
            Node* old = t;
            t = (t->left != nullptr) : t->left ? t->right;
            delete old;
        }
    }*/

    void printTree_Inorder(Node* t) const
    {
        if (t != nullptr)
        {
            printTree_Inorder(t->left);
            std::cout << t->data << " ";
            printTree_Inorder(t->right);
        }
        
    }
    void printTree_Preorder(Node* t) const 
    {
        if (t != nullptr)
        {
            std::cout << t->data << " ";
            printTree_Preorder(t->left);
            printTree_Preorder(t->right);
        }
    }
    void printTree_Postorder(Node* t) const
    {
        if (t != nullptr)
        {
            printTree_Postorder(t->left);
            printTree_Postorder(t->right);
            std::cout << t->data<< " ";
        }
    }
public:
    BinarySearchTree()
        :root{nullptr}
    {

    }
    BinarySearchTree(const BinarySearchTree & rhs)
        :root{nullptr}
    {
       root= clone(rhs.root);
    }
    ~BinarySearchTree()
    {
        makeEmpty(root);
    }
     
    E findMinNode() const
    {
        return findMin(root)->data;
    }

    E findMaxNode() const
    {
        return findMax(root)->data;
    }

    void insert(const E& data)
    {
        insert(data, root);
    }
    void remove(const E& data)
    {
        remove(data, root);
    }

    bool find(const E& x)
    {
        return find(x, root);
    }
    bool isEmpty() const
    {
        return root == nullptr?true : false;
    }

    void print(std::string order) const
    {
        
        if (order == "in")   printTree_Inorder(root);
        else if (order == "pre")  printTree_Preorder(root);
        else if (order == "post") printTree_Postorder(root);
    }

};

测试函数（main.cpp）

代码



#include <iostream>
#include "BinarySearchTree.cpp"
int main()
{
    BinarySearchTree<int> BST_test;


    BST_test.insert(9);
    BST_test.insert(4);
    BST_test.insert(15);
    BST_test.insert(26);
    BST_test.insert(11);
    BST_test.insert(16);
    BST_test.insert(5);
    BST_test.insert(7);
    BST_test.insert(10);
    BST_test.insert(14);
    BST_test.insert(19);
    BST_test.print("post");
    std::cout << std::endl;
    BST_test.print("in");
    std::cout << std::endl;
    BST_test.print("pre");
    system("pause");

    BST_test.remove(15);
    BST_test.print("post");
    std::cout << std::endl;
    BST_test.print("in");
    std::cout << std::endl;
    BST_test.print("pre");
    system("pause");

    std::cout << BST_test.findMinNode() << std::endl;
    std::cout << BST_test.findMaxNode() << std::endl;

    std::cout << BST_test.isEmpty();

}

运行结果

reddiey
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
Python实现二叉搜索树
09-21
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，其特性在于每个节点的左子树上的所有节点的值均小于该节点的值，而右子树上所有节点的值均大于该节点的值。这种结构使得二叉搜索树在搜索、插入...
笔记分享: 香港中文大学CSCI5610高级数据结构——最邻近查询
qq_64091900的博客
08-18 702
香港中文大学CSCI5610高级数据结构
【408数据结构】概述
weixin_46876169的博客
08-18 710
程序 = 数据结构 + 算法算法是求解问题的步骤。
【数据结构】红黑树
weixin_69380220的博客
08-18 1021
红黑树的模拟实现
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 726
完全二叉堆：批量建堆
牛客竞赛数据结构专题班树状数组、线段树练习题
Landing_on_Mars的博客
08-18 306
令 f[i][0/1] 表示从第 1 层的左边（0）或右边（1）到第 i 层的左边（0）或右边（1）的方案数。不能发现这个问题如果不带修改则可以用 dp+前缀和（矩阵乘法）解决，带修改则可以用线段树维护区间和。我们可以将每一层的转移状态用矩阵表示，
【Solidity】复杂类型相关操作
Superman_H的博客
08-18 178
# 操作 Enum ```solidity contract Demo { enum State { PENDING, ACTIVE, INACTIVE } State private state; // 更新 state function updateState(State _state) public { state = _state; } // 重置 state fu
数据结构----链表
新手嵌入式学习的博客
08-16 2023
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
【数据结构篇】~顺序表
旺小仔的博客
08-16 573
【数据结构篇】~顺序表
C++学习笔记之数据结构
sincerelover的博客
08-18 861
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
初阶数据结构之直接选择排序和快速排序
Mr_Xuhhh的博客
08-17 692
1.直接选择排序思考⾮常好理解，但是效率不是很好。实际中很少使⽤2.时间复杂度： O(N。
数据结构初阶——算法复杂度超详解
fhvyxyci的博客
08-15 1406
1.数据结构前言 1.1 数据结构 1.2 算法 2.算法效率 2.1 复杂度的概念 3. 时间复杂度 3.1 大O的渐进表示法 3.2 时间复杂度计算示例 示例1 示例2 示例3 示例4 示例5 示例6 示例7 4. 空间复杂度 4.1 空间复杂度计算示例 4.1.1 示例1 4.1.2 示例2 5. 常见复杂度对比 6.复杂度算法题——[旋转数组](https://leetcode.cn/problems/rotate-array/description/) 思路1 思路2 思路3
【排序篇】实现快速排序的三种方法
2303_79015671的博客
08-18 1209
本文将讲述实现快速排序的3种方法：hoare法，挖坑法，前后指针法
C++ //练习 17.13 编写一个整型对象，包含真/假测验的正确答案。使用它来为前两题中的数据结构生成测验成绩。
Made in Code
08-16 827
【代码】C++ //练习 17.13 编写一个整型对象，包含真/假测验的正确答案。使用它来为前两题中的数据结构生成测验成绩。
数据结构详细教程绪论
意疏的博客
08-18 2091
🌏个人博客主页希望文章能够给到初学的你一些启发～ 如果觉得文章对你有帮助的话，支持一下笔者吧～
数据结构8.16
jay__jay_的博客
08-18 210
1、顺序表实现学生管理系统（参照顺序表技能）写出菜单界面switch选择，功能1创建顺序表（堆区），2录入学生信息，3插入一个学生信息，4删除一个学生信息，5按照位置修改一个学生信息，6、按照姓名顺序查找一个学生是否存在7、对学生年龄直接插入排序（从小到大）。2、单链表实现学生管理系统（参照顺序表技能）写出菜单界面switch选择，功能1创建单链表，2录入学生信息，3删除一个学生信息，4按照成绩修改一个学生的年龄，5、按照姓名顺序查找一个学生是否存在。1、学生信息结构体姓名，分数，年龄，电话。
数据结构（Java）：揭开二叉搜索树删除机制的奥秘
最新发布
2401_83595513的博客
08-19 1814
二叉搜索树的模拟实现
二叉查找树（BST）详解与Python实现
"本文介绍了二叉查找树的基本概念和特性，并提供了Python实现的代码示例，包括插入、搜索和删除操作。" 二叉查找树（Binary Search Tree，BST），作为一种重要的数据结构，它在计算机科学中扮演着关键角色，特别是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值