二叉搜索树(BST树)

最新推荐文章于 2023-05-25 17:56:51 发布
最新推荐文章于 2023-05-25 17:56:51 发布
阅读量321 收藏 1
点赞数 1
分类专栏： 数据结构和算法 文章标签： 搜索 二叉树 二叉搜索树 二叉排序树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gogogo_sky/article/details/76360105
版权

一、简介

（1）二叉搜索树，又叫做二叉排序树，二叉查找树，有序二叉树
是指一棵空树或者具有下列性质的二叉树：

  1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。
  2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。
  3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。
  4. 左右子树都是二叉搜索树。

（2）二叉搜索树中序遍历的结果就是一个升序序列；

（3）空树也是一个二叉搜索树；

既然有以上性质，那么二叉树的查找是相当方便的;当然插入和删除，复杂度也会明显降低。
这里写图片描述

二、代码实现

（1）二叉搜索树的查找

从根结点开始搜索
如果根结点的健值大于要寻找的key，则向根结左点子树寻找；
如果根结点的健值小于要寻找的健值，则向根结点的右子树寻找；
如果相等，则代表找到；
如果一直找到NULL也没有找到，则说明该健值没有在此二叉搜索树里面；

bool _Find(Node* root,const T& x)//查找---非递归
    {
          //1.如果二叉搜索树为空，则返回错
          if (root==NULL)
          {
              return false;
          }
          //2.二叉搜索树不为空
          Node* cur=root;
          while (cur)
          {
              //2.1如果根结点的健值大于要寻找的key，则向根结点左子树寻找；
              if (cur->data>x)
              {
                  cur=cur->left;
              }
              //2.2如果根结点的健值小于要寻找的健值，则向根结点的右子树寻找；
              else if (cur->data<x)
              {
                    cur=cur->right;
              }
              //2.3如果相等，则代表找到；
              else 
              {
                  return true;
              }
          }
          //2.4如果一直找到NULL也没有找到，则说明该健值没有在此二叉搜索树里面；
          return false;

    }

(2)二叉搜索树的插入

首先说明，在二叉搜索树中，不能出现相同key值的两个结点；
二叉搜索树的插入是，先找到合适的空位置，然后进行插入；如果在寻找的过程中，发现了和要插入的值相同的结点；
那么就不用插入了，直接返回；
这里写图片描述

bool _InsertNoR(Node* root,const T& x)//给搜索二叉树插入某个元素--非递归
    {
        //1.如果二叉搜索树为空，则直接插入节点
        if (root==NULL)
        {
            root=new Node(x);
            _root=root;
            return true;
        }
        //2.二叉搜索树不为空
        Node* cur=root;//遍历二叉搜索树
        Node* father=NULL;//记录正确插入位置的父节点；
        //2.1寻找插入的正确位置，在此期间，如果遇到和插入节点相同的结点，则直接返回错误；
        while (cur)
        {
                if (cur->data==x)
             {
                 return false;
             }
                else if (cur->data > x)
             {
                 father=cur;
                 cur=cur->left;
             }
                else
             {
                 father=cur;
                 cur=cur->right;
             }
        }

        //2.2寻找到正确的插入位置，然后进行插入操作；
            cur=new Node(x);//要插入的结点
        //2.2.1如果父节点的值小于插入的值，则插入到父节点的右边
        if ( x> father->data)
        {
            father->right=cur;
        }
        //2.2.2如果父节点的值大于插入的值，则插入到父节点的左边
        else
        {
            father->left=cur;
        }
        return true;
    }

（3）二叉搜索树的删除
二插搜索树的删除比较麻烦，下面一一分析；
1>如果二叉搜索树为空，返回错；
2>如果要删除的结点没有在二叉搜索树中，则直接返回错误；
3>如果通过查找，发现要删除的结点是叶子节点，没有左右孩子，则直接将该节点删除；
4>如果通过查找发现要删除的结点只有一个孩子；
则

  • 如果该要删除的结点是父节点的左孩子，就将该孩子连接到父节点的左边；

  • 如果该要删除的结点是父节点的右孩子，就将该孩子连接到父节点的右边；

5>如果通过寻找发现该要删除的结点左右孩子都有；
那么首先：找到该节点的右子树的最小结点（或者也可以找到该节点的左子树的最大节点），该最小结点就是右子树的最左结点；

然后判断：该最小结点是否还有右子树，如果还有右子树，则还要判断改最小结点是其父节点的左孩子还是右孩子，如果是左孩子，则将该最小结点的右子树连接到其父节点的左边；如果是右孩子，则将该最小结点的右子树连接到其父节点的右边；

最后：将游离出来的最小节点和要删除的结点交换值，然后将最小节点释放；

注： 出现该最小结点是其父节点的右孩子的情况只有一种，那就是这个最小结点就是要删除的结点的右子树的根结点；
这里写图片描述

ool _RmoveNoR(Node* root,const T& x)    //二叉搜索树的删除---非递归
    {
        //1.二叉搜索树为空
        if (root==NULL)
        {
            return false;
        }
        //2.二叉搜索树不为空
        Node* cur=root;
        Node* father=NULL;
        //2.2寻找要删除的结点
        while (cur)
        {
            //2.2.1x小于cur,往左子树寻找
            if (cur->data>x)
            {
                father=cur;
                cur=cur->left;
            }
            //2.2.2 x大于cur,往右子树寻找
            else if (cur->data<x)
            {
                father=cur;
                cur=cur->right;
            }
            //2.2.3找到结点，准备删除
            else
            {
                //2.2.3.1删除的结点为叶子节点
                if (cur->left==NULL&&cur->right==NULL)
                {
                    //1)要删除的结点是父节点的左孩子
                    if (father->left==cur)
                    {
                        delete cur;
                        cur=NULL;
                        father->left=NULL;
                        return true;
                    }
                    //1)要删除的结点时父节点的右孩子
                    if (father->right==cur)
                    {
                        delete cur;
                        cur=NULL;
                        father->right=NULL;
                        return true;
                    }
                }
                //2.2.3.2删除的结点只右右子树！
                if (cur->left==NULL&&cur->right)
                {
                    //1)要删除的结点是父节点的左孩子
                    if (father->left==cur)
                    {
                        father->left=cur->right;
                        delete cur;
                        cur=NULL;
                        return true;
                    }
                    //1)要删除的结点是父节点的右孩子
                    if(father->right==cur)
                    {
                        father->right=cur->right;
                        delete cur;
                        cur=NULL;
                        return true;
                    }
                }
                //2.2.3.3删除的结点只有左子树！
                if (cur->left&&cur->right==NULL)
                {
                    //1)要删除的结点时父节点的左孩子
                    if (father->left==cur)
                    {
                        father->left=cur->left;
                        delete  cur;
                        cur=NULL;
                        return true;
                    }
                    //1)要删除的结点时父节点的右孩子
                    if (father->right==cur)
                    {
                        father->right=cur->left;
                        delete cur;
                        cur=NULL;
                        return true;
                    }
                }
                //2.2.3.4删除的结点左右子树都有
                if (cur->left&&cur->right)
                {
                    //首先先找到以该节点为根的右子树的最小结点，就是右子树中序遍历的第一个结点,就是右子树的最左结点
                    //然后将此节点替换要删除的结点；
                    Node* min=cur->right;
                    Node* father1=cur;
                    while (min->left)
                    {
                        father1=min;
                        min=min->left;
                    } 
                    if (min->right&&father1->left==min)
                    {
                        father1->left=min->right;

                    }
                    if (min->right&&father1->right==min)
                    {
                        father1->right=min->right;
                    }
                    std::swap(cur->data,min->data);
                    delete min;
                    min=NULL;
                    return true;
                }
            }
        }
        //2.3该节点没在二叉搜索树里面
        return false;
    }

三、二叉搜索树的退化及缺陷

二插搜索树的查找，插入和删除在一般情况下的时间复杂度都是O（H）【H为二叉树的高度】;

但是在插入有序数列或者接近有序的数列之后，查找和删除的时间复杂度是O(N);这和链表的顺序表的查找效率一样；删除效率和链表一样；体现不出二叉树每次排除一般的优势；
这里写图片描述
所以就出现了高度平衡的二叉搜索树AVL； 【明天写】

四、完整代码

#include<iostream>
using namespace std;
template<class T>
struct TreeNode
{
     T data;
     TreeNode<T>* left;
     TreeNode<T>* right;
     TreeNode(const T& x)
         :data(x)
         ,left(NULL)
         ,right(NULL)
     {}
};

template<class T>
class  SearchBinaryTree
{
    typedef TreeNode<T>  Node;
public:
    SearchBinaryTree()//构造
        :_root(NULL)
    {}
    ~SearchBinaryTree()//析构
    {
        _Destroy(_root);
    }
    bool Find(const T& x)//寻找
    {
        return _Find(_root,x);
    }
    bool InsertNoR(const T& x)//插入---非递归
    {
        return _InsertNoR(_root,x);
    }
    bool RmoveNoR(const T& x)//删除---非递归
    {
        return _RmoveNoR(_root,x);
    }
    void  Printf()//前序打印搜索二叉树
    {
          _Printf(_root);
    }
protected:
    void _Destroy(Node* root)//销毁搜索二叉树
    {
         if (root==NULL)
         {
             return ;
         }
         _Destroy(root->left);
         _Destroy(root->right);
         delete root;
    }
    void _Printf(Node* root)
    {
        if (root==NULL)
        {
            return ;
        }
        cout<<root->data<<" ";
        _Printf(root->left);
        _Printf(root->right);
    }
    bool _Find(Node* root,const T& x)//查找---非递归
    {
          //1.如果二叉搜索树为空，则返回错
          if (root==NULL)
          {
              return false;
          }
          //2.二叉搜索树不为空
          Node* cur=root;
          while (cur)
          {
              //2.1如果根结点的健值大于要寻找的key，则向根结点左子树寻找；
              if (cur->data>x)
              {
                  cur=cur->left;
              }
              //2.2如果根结点的健值小于要寻找的健值，则向根结点的右子树寻找；
              else if (cur->data<x)
              {
                    cur=cur->right;
              }
              //2.3如果相等，则代表找到；
              else 
              {
                  return true;
              }
          }
          //2.4如果一直找到NULL也没有找到，则说明该健值没有在此二叉搜索树里面；
          return false;

    }
    bool _InsertNoR(Node* root,const T& x)//给搜索二叉树插入某个元素--非递归
    {
        //1.如果二叉搜索树为空，则直接插入节点
        if (root==NULL)
        {
            root=new Node(x);
            _root=root;
            return true;
        }
        //2.二叉搜索树不为空
        Node* cur=root;//遍历二叉搜索树
        Node* father=NULL;//记录正确插入位置的父节点；
        //2.1寻找插入的正确位置，在此期间，如果遇到和插入节点相同的结点，则直接返回错误；
        while (cur)
        {
                if (cur->data==x)
             {
                 return false;
             }
                else if (cur->data > x)
             {
                 father=cur;
                 cur=cur->left;
             }
                else
             {
                 father=cur;
                 cur=cur->right;
             }
        }

        //2.2寻找到正确的插入位置，然后进行插入操作；
            cur=new Node(x);//要插入的结点
        //2.2.1如果父节点的值小于插入的值，则插入到父节点的右边
        if ( x> father->data)
        {
            father->right=cur;
        }
        //2.2.2如果父节点的值大于插入的值，则插入到父节点的左边
        else
        {
            father->left=cur;
        }
        return true;
    } 

   bool _RmoveNoR(Node* root,const T& x)    //二叉搜索树的删除---非递归
    {
        //1.二叉搜索树为空
        if (root==NULL)
        {
            return false;
        }
        //2.二叉搜索树不为空
        Node* cur=root;
        Node* father=NULL;
        //2.2寻找要删除的结点
        while (cur)
        {
            //2.2.1x小于cur,往左子树寻找
            if (cur->data>x)
            {
                father=cur;
                cur=cur->left;
            }
            //2.2.2 x大于cur,往右子树寻找
            else if (cur->data<x)
            {
                father=cur;
                cur=cur->right;
            }
            //2.2.3找到结点，准备删除
            else
            {
                //2.2.3.1删除的结点为叶子节点
                if (cur->left==NULL&&cur->right==NULL)
                {
                    //1)要删除的结点是父节点的左孩子
                    if (father->left==cur)
                    {
                        delete cur;
                        cur=NULL;
                        father->left=NULL;
                        return true;
                    }
                    //1)要删除的结点时父节点的右孩子
                    if (father->right==cur)
                    {
                        delete cur;
                        cur=NULL;
                        father->right=NULL;
                        return true;
                    }
                }
                //2.2.3.2删除的结点只右右子树！
                if (cur->left==NULL&&cur->right)
                {
                    //1)要删除的结点是父节点的左孩子
                    if (father->left==cur)
                    {
                        father->left=cur->right;
                        delete cur;
                        cur=NULL;
                        return true;
                    }
                    //1)要删除的结点是父节点的右孩子
                    if(father->right==cur)
                    {
                        father->right=cur->right;
                        delete cur;
                        cur=NULL;
                        return true;
                    }
                }
                //2.2.3.3删除的结点只有左子树！
                if (cur->left&&cur->right==NULL)
                {
                    //1)要删除的结点时父节点的左孩子
                    if (father->left==cur)
                    {
                        father->left=cur->left;
                        delete  cur;
                        cur=NULL;
                        return true;
                    }
                    //1)要删除的结点时父节点的右孩子
                    if (father->right==cur)
                    {
                        father->right=cur->left;
                        delete cur;
                        cur=NULL;
                        return true;
                    }
                }
                //2.2.3.4删除的结点左右子树都有
                if (cur->left&&cur->right)
                {
                    //首先先找到以该节点为根的右子树的最小结点，就是右子树中序遍历的第一个结点,就是右子树的最左结点
                    //然后将此节点替换要删除的结点；
                    Node* min=cur->right;
                    Node* father1=cur;
                    while (min->left)
                    {
                        father1=min;
                        min=min->left;
                    } 
                    if (min->right&&father1->left==min)
                    {
                        father1->left=min->right;

                    }
                    if (min->right&&father1->right==min)
                    {
                        father1->right=min->right;
                    }
                    std::swap(cur->data,min->data);
                    delete min;
                    min=NULL;
                    return true;
                }
            }
        }
        //2.3该节点没在二叉搜索树里面
        return false;
    }

protected:  
   Node* _root;
};
int main()
{
    SearchBinaryTree<int>  st;
    //插入
    st.InsertR(7);
    st.InsertR(5);
    st.InsertR(4);
    st.InsertR(3);
    st.InsertR(6);
    st.InsertR(9);
    st.InsertR(15);
    st.InsertR(1);
    st.InsertR(8);
    st.InsertR(10);
    st.InsertR(12);

    st.Printf();
    cout<<endl;
    //寻找
    cout<<"寻找"<<endl;
    cout<<st.Find(7)<<endl;
    cout<<st.Find(5)<<endl;
    cout<<st.Find(4)<<endl;
    cout<<st.Find(3)<<endl;
    cout<<st.Find(6)<<endl;
    cout<<st.Find(9)<<endl;
    cout<<st.Find(15)<<endl;
    cout<<st.Find(1)<<endl;
    cout<<st.Find(8)<<endl;
    cout<<st.Find(10)<<endl;
    cout<<st.Find(12)<<endl;
    cout<<st.Find(13)<<endl;
    cout<<st.Find(14)<<endl;
    /*cout<<"删除"<<endl;*/
    //删除
    st.RmoveNoR(3);
    st.RmoveNoR(6);
    st.RmoveNoR(9);
    st.Printf();
    return 0;

}

这里写图片描述

END！！！

gogogo_sky
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python实现二叉搜索树BST的方法示例
09-18
主要介绍了Python实现二叉搜索树BST的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C++ 二叉搜索树(BST)的实现方法
01-20
class BST { public: struct Node { int key;//节点的key int value;//节点的value Node* left; Node *right; int N;//节点的叶子节点数目 Node(int _key, int _value, int _N) { key = _key; value = _...
C++基础2
weixin_43572802的博客
01-16 121
本篇博客没有营养，仅仅作为个人笔记使用 #include<iostream> using namespace std; template<class T> //顺序搜索 int sequentialSearch(T a[], int n, const T& x) {//在数组a[0:n-1]中查找元素x //如果找到返回该元素位置，如果没找到范湖-1 int i; for (i = 0;i < n && a[i] != x;i++);
二叉查找树
白杨
11-03 967
文章目录二叉查找树(二叉搜索树、二叉排序树)构造二叉查找树二叉查找树查找结点二叉查找树插入结点二叉查找树删除结点删除叶子结点删除只有左子树的结点删除只有右子树的结点删除同时有左右子树结点删除结点代码实现完整代码 二叉查找树(二叉搜索树、二叉排序树) 对于有序线性表出来说，查找效率非常高，但是对于插入、删除操作，需要对数据进行移动，所以效率就不怎么高了。那么对于这种问题，我们就可以利用二叉查找树来解...
二叉搜索树（查找、插入、删除的讲解实现+图文并茂）
bang___bang_的博客
05-25 5890
本文讲解并模拟实现二叉搜索树，详解它的查找、插入、删除及实现，并对二叉搜索树的应用场景进行描述，最后进行了性能分析！
二叉搜索树(BST)详解
渐宽阁读书小弟
05-03 1013
二叉搜索树(BST)详解并使用Java实现对功能模块的测试
引用 const T &x=T()
这题AC再睡
02-01 423
引用 const T &x=T()
bst_二叉搜索树_
09-29
简单的BST二叉搜索树的实现，测试数据可更改
258-二叉排序树(BST树)
LINZEYU666的博客
04-04 1127
二叉排序树(BST树) 又叫二叉搜索树 堆的图解如下 以完全二叉树来组织，用于优先级队列。 二叉排序树的定义 #include<iostream> #include<vector> #include<stack> using namespace std; typedef int KeyType; typedef struct BstNode { KeyType key; BstNode* leftchild; BstNode* parent; BstNo
软考知识点：二叉树的关键码序列 解析
热门推荐
Tjmies的博客
09-15 2万+
题型： 解析：首先要理解什么是二叉树？什么是有序二叉树？ 二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 有序二叉树，就是左子树上的数值小于树根上的值，树根的值小于右子树的值。 到这里理解清楚有序二叉树后就能快速的解决此类题目了。 根据题目中的二叉树图可知， ①根节点为23，因此就可以排除选项中不..
BST（二叉搜索树）
Null
04-28 5179
BST（二叉搜索树） 所谓二叉搜索树（Binary Search Tree，简称 BST）大家应该都不陌生，它是一种特殊的二叉树。 特殊在哪里呢？ 简单来说就是：左小右大。 BST的完整定义如下： BST 中任意一个节点的左子树所有节点的值都小于该节点的值，右子树所有节点的值都大于该节点的值。 BST 中任意一个节点的左右子树都是 BST。 有了BST的这种特性，就可以在二叉树中做类似二分搜索的操作，搜索一个元素的效率很高。 一个合法二叉树的举例 对于 BST 相关的问题，你可能会经常看到类似下面
STL源码剖析6：仿函数以及适配器
weixin_46412362的博客
07-14 164
1.仿函数 1.1 简介 仿函数即意为函数对象，就是一种具有函数特性的对象，在上一章介绍的算法中，我们可以看到很多的算法往往有两个版本。第一个版本就是表现出最常见的运算，第二个版本则是体现出泛化性的版本，允许用户传入指定的仿函数来完成对应的功能，因此仿函数可以被认为是一种算法的策略作用于算法上。 从实现的角度而言，仿函数其实就是一个行为类似于函数的对象，为了能够实现这个功能，因此也就需要我们必须重载function的operator()函数，这样，当我们在仿函数对象后加上()后，对象可以像函数一样的被调用.
数据结构-二叉排序树
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
10-25 7784
1.定义 二叉排序树又称为二叉查找树，它或者是一颗空树，或者有以下性质的树： 若它的左子树非空，则左子树上所有结点的值均小于根结点的值 若它的右子树非空，则右子树上所有结点的值均大于根结点的值 左、右子树本身是二叉排序树 2.查找过程 因为二叉排序树的左子树上所有结点的关键字均小于根结点的关键字，右子树上所有结点的关键字均大于根结点的关键字，所以在二叉排序树上进行查找的过程为： ...
模拟实现list / list迭代器
wjmhlh的博客
01-28 1258
⭐在本篇文章中，list的迭代器是重点，它不像string和vector的迭代器一样可以使用原生指针。
数据结构与算法之二叉排序树
five-five
06-05 1119
二叉排序树，又称二叉查找树 (BST) 一颗二叉树或者空二叉树，或者是具有如下性质的二叉树：左子树结点值
数据结构 ： 二叉搜索树(BST)
LOOKTOMMER的博客
10-07 1208
????‍???? ????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍??????
设在一棵二叉搜索树的每个结点中,含有关键码key域和统计相同关键码
xiaoyao_zhang的博客
10-31 923
#include<stdio.h> #include<stdlib.h> typedef struct BTNode { int data; int count; struct BTNode *lchild; struct BTNode *rchild; }BTNode; /* int insert(BTNode *&T,int key)//递归方...
L2-004 这是二叉搜索树吗？ (25分)
FadePeople
04-10 6796
一棵二叉搜索树可被递归地定义为具有下列性质的二叉树：对于任一结点， 其左子树中所有结点的键值小于该结点的键值； 其右子树中所有结点的键值大于等于该结点的键值； 其左右子树都是二叉搜索树。 所谓二叉搜索树的“镜像”，即将所有结点的左右子树对换位置后所得到的树。 给定一个整数键值序列，现请你编写程序，判断这是否是对一棵二叉搜索树或其镜像进行前序遍历的结果。 输入格式： 输入的第一行给出正整数 N（≤...
二叉平衡树和二叉搜索树
最新发布
08-02
二叉搜索树（BST）是一种二叉树，它满足以下性质：非空左子树的所有键值小于其根结点的键值，非空右子树的所有键值大于其根结点的键值，左、右子树都是二叉搜索树。BST的主要作用是支持高效的查找操作，通过比较键值...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值