高级数据结构及算法：BST树（二叉查找树）

最新推荐文章于 2022-10-04 12:05:09 发布
最新推荐文章于 2022-10-04 12:05:09 发布
阅读量274 收藏
点赞数
分类专栏： 数据结构及算法 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39398433/article/details/119189925
版权

文章目录

BST树（二叉查找树）

二叉查找树(Binary Search Tree)，又被称为二叉搜索树
二叉查找树演示连接

在这里插入图片描述

1. 特点

  1. 任意节点的左子树不空, 则左子树上所有节点的key均小于它的根节点的key
  2. 任意节点的右子树不空, 则右子树上所有节点的key均大于它的根节点的key
  3. 任意节点的左,右子树也分别为二叉查找树
  4. 没有key相等的节点

2. 操作

2.1 查找

用递归的方式查找，判断是否有对应数

		// 查找
        bool Search(char val){
                return Search(m_root,val);
        }
        bool Search(Node* root,char val){
                if(nullptr == root) return false;          // 根节点为空，表示没找到
                if(root->val == val) return true;          // 根节点的值等于要找的值
                if(root->val < val){
                        return Search(root->right,val);    // 根节点的值小于要找的值，往右边找
                }else{
                        return Search(root->left,val);     // 根节点的值大于要找的值，往左边找
                }
        }

2.2 添加

用递归的方式对数做判断，插入左子树或右子树

        // 插入
        void Insert(char val){
                if(Search(val)) return;               // 如果找到了要插入的值，则不用插入
                m_root = Insert(m_root,val);          // 如果没找到，插入到根节点中
        }
        Node* Insert(Node* root,char val){
                if(nullptr == root) return new Node(val);       // 根节点为空，创建一个类空间，值为val
                if(root->val > val){
                        root->left = Insert(root->left,val);     // 如果根节点大于要插的数，插到左子树
                }else{
                        root->right = Insert(root->right,val);   // 如果根节点小于要插的数，插到右子树
                }
                return root;                      // 返回当前节点
        }

对一个BST二叉搜索数进行依次添加

#include <iostream>
using namespace std;

class Node{
public:
        char val;
        Node* left;
        Node* right;
        Node(int val):val(val),left(nullptr),right(nullptr){}
        Node(int val,Node* left,Node* right):val(val),left(left),right(right){}

        // void SetRight(Node* right){this->right = right;}
        // void SetLeft(Node* left){this->left = left;}
};

// 查找、添加、删除
class BSTree{
        Node* m_root = nullptr;     // 成员变量，初始化
public:
        // 查找
        bool Search(char val){
                return Search(m_root,val);
        }
        bool Search(Node* root,char val){
                if(nullptr == root) return false;          // 根节点为空，表示没找到
                if(root->val == val) return true;          // 根节点的值等于要找的值
                if(root->val < val){
                        return Search(root->right,val);    // 根节点的值小于要找的值，往右边找
                }else{
                        return Search(root->left,val);     // 根节点的值大于要找的值，往左边找
                }
        }

        // 插入
        void Insert(char val){
                if(Search(val)) return;               // 如果找到了要插入的值，则不用插入
                m_root = Insert(m_root,val);          // 如果没找到，插入到根节点中
        }
        Node* Insert(Node* root,char val){
                if(nullptr == root) return new Node(val);       // 根节点为空，创建一个类空间，值为val
                if(root->val > val){
                        root->left = Insert(root->left,val);     // 如果根节点大于要插的数，插到左子树
                }else{
                        root->right = Insert(root->right,val);   // 如果根节点小于要插的数，插到右子树
                }
                return root;                      // 返回当前节点
        }

        // 外部调用
        void Print(){
                preorder(m_root);
        }
        // 做前序遍历进行打印
        void preorder(const Node* root){
                if(nullptr == root) return;
                if(root->left) cout << root->val << "--" << root->left->val << endl;
                if(root->right) cout << root->val << "--" << root->right->val << endl;
                preorder(root->left);
                preorder(root->right);
        }
};

int main(){
        BSTree bst;
        bst.Insert('G');
        bst.Insert('T');
        bst.Insert('E');
        bst.Insert('F');
        bst.Insert('B');
        bst.Insert('X');

        bst.Print();
}

结果为：

G--E
G--T
E--B
E--F
T--X

上面结果可以得到对应数形图：
在这里插入图片描述

2.3 删除

替代删除，后继代替删除节点，然后删除后继；或者前驱代替删除节点，然后删除前驱

例如：
在这里插入图片描述删除节点“15”，即先找到该节点的右子树的最小值，即为“20”，把“15”替换成“20”，并删除原来的“20”，删除后经过递归返回“15”的右节点“30”
在这里插入图片描述
对上述程序继续进行删除节点的操作

#include <iostream>
using namespace std;

class Node{
public:
        char val;
        Node* left;
        Node* right;
        Node(int val):val(val),left(nullptr),right(nullptr){}
        Node(int val,Node* left,Node* right):val(val),left(left),right(right){}
};

// 查找、添加、删除
class BSTree{
        Node* m_root = nullptr;     // 成员变量，初始化
public:
        // 查找
        bool Search(char val){
                return Search(m_root,val);
        }
        bool Search(Node* root,char val){
                if(nullptr == root) return false;          // 根节点为空，表示没找到
                if(root->val == val) return true;          // 根节点的值等于要找的值
                if(root->val < val){
                        return Search(root->right,val);    // 根节点的值小于要找的值，往右边找
                }else{
                        return Search(root->left,val);     // 根节点的值大于要找的值，往左边找
                }
        }

        // 插入
        void Insert(char val){
                if(Search(val)) return;               // 如果找到了要插入的值，则不用插入
                m_root = Insert(m_root,val);          // 如果没找到，插入到根节点中
        }
        Node* Insert(Node* root,char val){
                if(nullptr == root) return new Node(val);       // 根节点为空，创建一个类空间，值为val
                if(root->val > val){
                        root->left = Insert(root->left,val);     // 如果根节点大于要插的数，去左子树插
                }else{
                        root->right = Insert(root->right,val);   // 如果根节点小于要插的数，去右子树插
                }
                return root;                      // 返回当前节点
        }

        // 删除
        void Remove(char val){
                m_root = Remove(m_root,val);
        }
        Node* Remove(Node* root,char val){
                if(nullptr == root) return nullptr;              // 如果没找到要删除的值，则返回空
                if(root->val < val){
                        root->right = Remove(root->right,val);      // 如果节点数小于要删的数，去右子树删
                }else if(root->val > val){
                        root->left = Remove(root->left,val);        // 如果节点数大于要删的数，去左子树删
                }else{                 // 如果找到了要删除的节点，分四种情况
                        if(nullptr == root->right && nullptr == root->left){      // 左右节点都为空，即是叶子节点
                                delete root;                  // 释放该节点
                                return nullptr;               // 返回空
                        }
                        if(nullptr == root->right){                               // 右子树为空，即只有左子树
                                Node* left = root->left;      // 保存左节点
                                delete root;                  // 释放该节点
                                return left;                  // 返回左节点
                        }
                        if(nullptr == root->left){                                // 左字数为空，即只有右字数
                                Node* right = root->right;    // 保存右节点
                                delete root;                  // 释放该节点
                                return right;                 // 返回右节点
                        }
                        // 当左右子树都存在
                        int minval = Minimun(root->right);           // 找到右子树的最小值
                        root->val = minval;                          // 把当前节点的值替换成该最小值
                        root->right = Remove(root->right,minval);    // 再去删除那个最小值的节点，层层递归后最终返回右节点
                }
                return root;
        }

        // 找根对应当前树的最小值
        int Minimun(Node* root){
                if(nullptr == root) throw runtime_error("root is null");           // 没有根，抛异常
                while(nullptr != root->left) root = root->left;        // 一直往左找，一直到左子树为空，返回当前节点值
                return root->val;
        }

        // 外部调用
        void Print(){
                preorder(m_root);
        }
        // 做前序遍历
        void preorder(const Node* root){
                if(nullptr == root) return;
                if(root->left) cout << root->val << "--" << root->left->val << endl;
                if(root->right) cout << root->val << "--" << root->right->val << endl;
                preorder(root->left);
                preorder(root->right);
        }
};

int main(){
        BSTree bst;
        bst.Insert('G');
        bst.Insert('T');
        bst.Insert('E');
        bst.Insert('F');
        bst.Insert('B');
        bst.Insert('X');

        bst.Remove('E');
        bst.Print();
}

结果为：

G--F
G--T
F--B
T--X

上面结果可以得到对应数形图：
在这里插入图片描述

我们将两张图对比，可以清楚的发现删除过程为：在E的右子树下找到最小的值即F，把E替换为F，并将之前的F删掉

2.4 优化

让类型变换更灵活，从终端输入

#include <iostream>
using namespace std;

template <typename T>
class _Node{
public:
        T val;
        _Node* left;
        _Node* right;
        _Node(const T& val):val(val),left(nullptr),right(nullptr){}
        _Node(const T& val,_Node* left,_Node* right):val(val),left(left),right(right){}
};

template <typename T>
// 查找、添加、删除
class BSTree{
        typedef _Node<T> Node;      // 统一替换
        Node* m_root = nullptr;     // 成员变量，初始化
public:
        // 查找
        bool Search(const T& val){
                return Search(m_root,val);
        }
        bool Search(Node* root,const T& val){
                if(nullptr == root) return false;          // 根节点为空，表示没找到
                if(root->val == val) return true;          // 根节点的值等于要找的值
                if(root->val < val){
                        return Search(root->right,val);    // 根节点的值小于要找的值，往右边找
                }else{
                        return Search(root->left,val);     // 根节点的值大于要找的值，往左边找
                }
        }

        // 插入
        void Insert(const T& val){
                if(Search(val)) return;               // 如果找到了要插入的值，则不用插入
                m_root = Insert(m_root,val);          // 如果没找到，插入到根节点中
        }
        Node* Insert(Node* root,const T& val){
                if(nullptr == root) return new Node(val);       // 根节点为空，创建一个类空间，值为val
                if(root->val > val){
                        root->left = Insert(root->left,val);     // 如果根节点大于要插的数，去左子树插
                }else{
                        root->right = Insert(root->right,val);   // 如果根节点小于要插的数，去右子树插
                }
                return root;                      // 返回当前节点
        }

        // 删除
        void Remove(const T& val){
                m_root = Remove(m_root,val);
        }
        Node* Remove(Node* root,const T& val){
                if(nullptr == root) return nullptr;              // 如果没找到要删除的值，则返回空
                if(root->val < val){
                        root->right = Remove(root->right,val);      // 如果节点数小于要删的数，去右子树删
                }else if(root->val > val){
                        root->left = Remove(root->left,val);        // 如果节点数大于要删的数，去左子树删
                }else{                 // 如果找到了要删除的节点，分四种情况
                        if(nullptr == root->right && nullptr == root->left){      // 左右节点都为空，即是叶子节点
                                delete root;                  // 释放该节点
                                return nullptr;               // 返回空
                        }
                        if(nullptr == root->right){                               // 右子树为空，即只有左子树
                                Node* left = root->left;      // 保存左节点
                                delete root;                  // 释放该节点
                                return left;                  // 返回左节点
                        }
                        if(nullptr == root->left){                                // 左字数为空，即只有右字数
                                Node* right = root->right;    // 保存右节点
                                delete root;                  // 释放该节点
                                return right;                 // 返回右节点
                        }
                        // 当左右子树都存在
                        T minval = Minimun(root->right);           // 找到右子树的最小值
                        root->val = minval;                          // 把当前节点的值替换成该最小值
                        root->right = Remove(root->right,minval);    // 再去删除那个最小值的节点，返回右节点
                }
                return root;
        }

        // 找整个树的最小值
        T Minimun(Node* root){
                if(nullptr == root) throw runtime_error("root is null");           // 没有根，抛异常
                while(nullptr != root->left) root = root->left;        // 一直往左找，一直到左子树为空，返回当前节点值
                return root->val;
        }

        // 外部调用
        void Print(){
                preorder(m_root);
        }
        // 做前序遍历
        void preorder(const Node* root){
                if(nullptr == root) return;
                if(root->left) cout << root->val << "--" << root->left->val << endl;
                if(root->right) cout << root->val << "--" << root->right->val << endl;
                preorder(root->left);
                preorder(root->right);
        }
};

int main(){
        BSTree<int> intbst;
        int n;
        while(cin >> n){
                intbst.Insert(n);
        }
        intbst.Print();
}

结果为：

12 8 25 5 18 30 20
12--8
12--25
8--5
25--18
25--30
18--20

上面结果可以得到对应数形图：
在这里插入图片描述在这里插入图片描述

Warrior-K
关注
专栏目录
数据结构与算法-BST(二叉搜索树)、AVL树(平衡二叉树)
weixin_45639955的博客
02-12 347
1二叉查找树 1.1特点 任意节点的左子树不空, 则左子树上所有节点的key均小于它的根节点的key 任意节点的右子树不空, 则右子树上所有节点的key均大于它的根节点的key 任意节点的左,右子树也分别为二叉查找树 没有key相等的节点 二叉查找树进行中序遍历，可以得到一个递增的有序序列 1.2结构 struct Node { int key; struct Node* l...
《数据结构与算法》-李春葆 实验报告-典型查找算法实践-二叉查找树实现查找
最新发布
12-20
这篇实验报告是关于《数据结构与算法》课程中的一次实验，主要关注的是二叉查找树（Binary Search Tree，简称BST）的实现及其在查找操作中的应用。二叉查找树是一种特殊的二叉树，它的每个节点都包含一个键值，且...
查找二叉树（BST）
WHTGS的博客
03-04 263
今天分享一些关于BST的内容： 一、基础知识点 1 一棵树最上面的节点称为根节点，如果一个节点下面连接多个节点，那么该节点称为父节点，，，它下面的节点称为子节点。一个节点可以有0个 1个 或多个子节点，没有任何子节点的节点称为叶子节点 2 以某种特定的顺序访问树中所有的节点称为树的遍历 3 树可以分为几个层次，根节点是第0层，子节点是第1层，子节点的子节点是第2层，依次类推 二、今天的主角...
二叉查找树（BST）
m0_50710793的博客
11-01 422
二叉查找树的定义 二叉查找树：是一种特殊的二叉树，又叫排序二叉树，二叉排序树，二叉搜索树等等。 具体定义如下： 要么二叉查找树是一棵空树 要么二叉查找树由根结点、左子树、右子树组成，其中左子树和右子树都是二叉查找树，且左子树上所有结点的数据域均小于根结点的数据域，右子树上所有结点的数据域均大于根结点的数据域～ （左<根<右） 二叉查找树的基本操作（查找、插入、建树、删除） 搜索基本思路： 1. 如果当前根结点为root，那么查找失败，返回～ 2. 如果要查找的值等于当前根结点的数据域，说明查
数据结构：二叉查找树（BST）
青语的博客
09-16 303
定义：又叫二叉搜索树，它是一种特殊的二叉树，如果它的任意节点的左右节点存在，则它的左子树均小于这个节点，右节点均大于这个节点 代码实现 定义这个树的属性 public class BSTree<T extends Comparable<T>> { private BSTNode<T> mRoot; // 根结点 public class...
BST二叉查找树
never_compromise2580的博客
01-27 182
踏踏实实积累，不要浮躁！！！ 思想：利用二叉树来存储散列表中的值，提供高效的put get 操作 说明：下面的代码只是帮助理解散列表的工作原理，工程上一般都是用红黑树来实现平衡的二叉排序树 put 操作内部利用的是get 操作，如果能查找到则更新该节点的value值，如果没有找到根据大小关系在下面插入该节点 package search; import edu.princeton.cs...
bst.zip_bst_二叉查找树
09-23
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值、一个指向左子树的指针和一个指向右子树的指针。在二叉查找树中，对于任意节点，其左子树中的...
数据结构与算法探索：从二叉查找树到B+树
二叉查找树（Binary Search Tree，BST）是一种特殊的树，每个节点的值都大于其左子树中任何节点的值，小于其右子树中任何节点的值。这使得搜索、插入和删除等操作的平均时间复杂度为O(LogN)，效率较高。例如，TREE-...
JS算法与数据结构：二叉查找树（BST）深度解析
二叉查找树是数据结构中的重要组成部分，尤其在需要快速查找、插入和删除操作的场景中，如数据库索引和文件系统中。理解和熟练掌握二叉查找树的概念及其操作，对于提升JavaScript编程能力及解决实际问题大有裨益。
二叉搜索树（BST）
qq_41078889的博客
08-19 1958
BST树称作二叉搜索树(Binary Search Tree)或者二叉排序树(Binary Sort Tree) ,它或者是一颗空树;或者是具有下列性质的二叉树: 若左子树不为空，则左子树上所有节点的值均小于它的根节点的值 若右子树不为空，则右子树上所有节点的值均大于它的根节点的值 左右子树也分别满足二叉搜索树性质 特点:每一个节点都满足左孩子的值 (不为空) < 父节点的值<右孩子的值(不为空)。 二分查找就是利用了bst树的性质。 ......
BST树的所有可能情况
Fun_Coding的博客
11-16 420
Given n, how many structurally unique BST’s (binary search trees) that store values 1…n?For example, Given n = 3, there are a total of 5 unique BST’s.int numTrees(int n) { if(n==0) return
BST（二叉搜索/排序树）类模板的实现
乐行僧的博客
11-04 5378
BST树的递归定义： (1)BST树是一棵空树。 (2)BST树由根节点、左子树和右子树。左子树和右子树分别都是一棵BST树。 由于二叉树的递归定义，使得在二叉树中许多操作中可以以递归的方式书写操作，代码更加浅显易懂。 重点条件：左子树中的所有节点的数据域都小于或等于根节点的数据域，而右子树中的所有节点的数据域都大于等于根节点的数据域。根据这个特点，BST树的中序遍历是一个由小到大的顺序序列。 B...
【数据结构】二叉查找树（BST）
m0_46628950的博客
09-08 7406
二叉查找树(Binary Search Tree，BST)，又叫做二叉排序树、二叉搜索树，是一种对查找和排序都有用的特殊二叉树。二叉查找树的特性：左子树
二叉排序树（BST）查找算法详解之C语言版
sunnyoldboy博客
10-04 3666
在二叉排序树上查找某个结点，其实就是遍历二叉树。由于二叉排序树上的结点是有序的，因此不需要使用普通二叉树的遍历算法，其有自己一套简单的遍历算法，即从树根开始进行遍历，如果待查找元素小于树根元素，则向左遍历，否则向右遍历，如果相等结束遍历。
二叉查找树
char_c的博客
05-18 236
二叉查找树
C语言二叉查找树(图文详解)(超详细)
qq_28229519的博客
08-14 5782
本人在第一次学习二叉树的时候,感觉很懵懵懂懂,勉强知道了二叉树的结构和查找方式,但要我自己去动手写的时候,可是难上加难,所以这里我用干货+实际例子的方式让你上手二叉树,这个例子几乎可以套用到所有链式结构问题,我们开始吧!...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值