二叉搜索树（二叉排序树）

最新推荐文章于 2025-07-03 16:43:45 发布
最新推荐文章于 2025-07-03 16:43:45 发布
阅读量1k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 二叉搜索树 二叉排序树 递归 非递归 中序遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jhcconan614/article/details/72617561

二叉搜索树：又称二叉排序树，他有三个特点：

1、若它的左子树不为空，那么它的左子树中所有节点的值都小于根结点的值

2、若它的右子树不为空，那么它的右子树的所有节点的值都大于根结点的值

3、它的左右子树也是二叉搜索树

那么现在我们就来给出一个二叉搜索树，我们来观察一下，看看能发现什么。

这里写图片描述

首先我们可以根据他的性质可以分析出，最左边的结点是最小的，而最右边的结点是最大的，这样就给出了一个求最小结点和最大结点的方法。

当我们用中序遍历的方式来遍历这个二叉树的时候，会发现什么：0123456789

它是有序的，也就是说，二叉搜索树在中序遍历下是有序的，这个很重要。

了解完了这些之后，我们在来看一下它的实现过程吧

首先是插入操作，要想插入，我们必须构建一个结构体来创建它的结点：

template<class K, class V>
struct BSTNode
{
    BSTNode(const K& key, const V& value)
    : _pLeft(NULL)
    , _pRight(NULL)
    , _key(key)
    , _value(value)
    {}

    BSTNode<K, V>* _pLeft;
    BSTNode<K, V>* _pRight;

    K _key;  
    V _value;
};

然后就是插入和删除操作了，具体是怎么实现呢，我们来看一下过程分析：

这里写图片描述

这里写图片描述

下面是总体的代码：包括递归和非递归两种实现的方法，及测试用例

#include<iostream>
using namespace std;

template<class K, class V>
struct BSTNode
{
    BSTNode(const K& key, const V& value)
    : _pLeft(NULL)
    , _pRight(NULL)
    , _key(key)
    , _value(value)
    {}

    BSTNode<K, V>* _pLeft;
    BSTNode<K, V>* _pRight;

    K _key;  
    V _value;
};

//// 非递归版本
//template<class K, class V>
//class BSTree
//{
//  typedef BSTNode<K, V> Node;
//public:
//  BSTree()
//      : _pRoot(NULL)
//  {}
//
//  //BSTree(const BSTree& bst);
//  //BSTree<K, V>& operator=(const BSTree<K, V>& bst);
//  //~BSTree();
//
//
//  bool Insert(const K& key, const V& value)
//  {
//      return _Insert(_pRoot, key, value);
//  }
//
//  Node* Find(const K& key)
//  {
//      return _Find(_pRoot, key);
//  }
//
//  bool Remove(const K& key)
//  {
//      return _Remove(_pRoot, key);
//  }
//
//  //二叉搜索树的中序遍历是有序的
//  void InOrder()
//  {
//      cout << "InOrder: ";
//      _InOrder(_pRoot);
//      cout << endl;
//  }
//
//  const K& GetMaxKey()const;
//  const K& GetMinKey()const;
//
//protected:
//  //中序遍历
//  void _InOrder(Node* pRoot)
//  {
//      if (pRoot)
//      {
//          _InOrder(pRoot->_pLeft);
//          cout << pRoot->_key << " ";
//          _InOrder(pRoot->_pRight);
//      }
//  }
//
//  //插入
//  bool _Insert(Node* & pRoot, const K& key, const V& value)
//  {
//      if (pRoot == NULL)//如果树是空的，那么直接插入，并返回true
//      {
//          pRoot = new Node(key, value);
//          return true;
//      }
//      
//      Node* pCur = pRoot;
//      Node*parent = NULL;
//
//      //开始找插入位置
//      while (pCur)
//      {
//          if (key < pCur->_key)//如果要插入的Key要小于当前结点的key，那么去左子树中继续遍历
//          {
//              parent = pCur;
//              pCur = pCur->_pLeft;            
//          }
//          else if (key>pCur->_key)//如果要插入的Key要大于当前结点的key，那么去右子树中继续遍历
//          {
//              parent = pCur;
//              pCur = pCur->_pRight;
//          }
//          else//否则，说明这个KaKey已存在，那么久不用插入了，返回false
//              return false;
//      }
//
//      //开始插入，判断这个结点是其双亲结点的左还是右
//      pCur = new Node(key, value);
//      if (key < parent->_key)
//          parent->_pLeft = pCur;
//      else
//          parent->_pRight = pCur;
//
//      return true;//不要忘了，最后返回true
//  }
//
//  Node* _Find(Node* pRoot, const K& key)
//  {
//      //直接将根结点保存，然后开始循环查找，不用判空，因为空的话，循环进不去
//      Node*pCur = pRoot;
//      while (pCur)
//      {
//          if (key == pCur->_key)
//              return pCur;
//          else if (key < pCur->_key)
//              pCur = pCur->_pLeft;
//          else
//              pCur = pCur->_pRight;
//      }
//      //如果循环结束还没有找到，返回NULL
//      return NULL;
//  }
//
//  bool _Remove(Node*& pRoot, const K& key)
//  {
//      //1、如果树为空，那么返回false
//      if (pRoot == NULL)
//          return false;
//
//      //2、如果树只有一个结点，且key和要删除的key相等，那么直接删除
//      if (pRoot->_pLeft == NULL&&pRoot->_pRight == NULL&&pRoot->_key == key)
//      {
//          delete pRoot;
//          pRoot = NULL;
//          return true;
//      }
//
//      //3、普通情况，先将待删除结点找到，之后，又分为四种情况
//      Node* pCur = pRoot;
//      Node* parent = NULL;
//      while (pCur)
//      {
//          if (key < pCur->_key)
//          {
//              parent = pCur;
//              pCur = pCur->_pLeft;
//          }
//          else if (key>pCur->_key)
//          {
//              parent = pCur;
//              pCur = pCur->_pRight;
//          }
//          else//找到，退出循环
//              break;
//      }
//
//      if (pCur)
//      {
//          //没有左孩子
//          if (pCur->_pLeft == NULL)
//          {
//              if (pCur != pRoot)
//              {
//                  if (parent->_pRight == pCur)
//                      parent->_pRight = pCur->_pRight;
//                  else
//                      parent->_pLeft = pCur->_pRight;
//              }
//              else
//                  pRoot = pCur->_pRight;
//          }
//
//          //没有右孩子
//          else if (pCur->_pRight == NULL)
//          {
//              if (pCur != pRoot)
//              {
//                  if (parent->_pLeft == pCur)
//                      parent->_pLeft = pCur->_pLeft;
//                  else
//                      parent->_pRight = pCur->_pLeft;
//              }
//              else
//                  pRoot = pCur->_pLeft;
//          }
//
//          //左右孩子都有
//          else
//          {
//              parent = pCur;
//              Node* fio = pCur->_pRight;//找到右子树中，中序遍历下的第一个结点
//              while (fio->_pLeft)
//              {
//                  parent = fio;
//                  fio = fio->_pLeft;
//              }
//
//              pCur->_key = fio->_key;
//              pCur->_value = fio->_value;
//
//              if (parent->_pLeft == fio)
//                  parent->_pLeft = fio->_pRight;
//              else
//                  parent->_pRight = fio->_pRight;
//
//              pCur = fio;
//          }
//
//          //所有的情况都讨论完，删除结点，并返回true
//          delete pCur;
//          pCur = NULL;
//          return true;
//      }
//      return false;
//  }
//
//protected:
//  Node* _pRoot;
//};


// 递归版本
template<class K, class V>
class BSTree
{
    typedef BSTNode<K, V> Node;
public:
    BSTree()
        : _pRoot(NULL)
    {}

    //BSTree(const BSTree& bst);
    //BSTree<K, V>& operator=(const BSTree<K, V>& bst);
    //~BSTree();


    bool Insert(const K& key, const V& value)
    {
        return _Insert(_pRoot, key, value);
    }

    Node* Find(const K& key)
    {
        return _Find(_pRoot, key);
    }


    bool Remove(const K& key)
    {
        return _Remove(_pRoot, key);
    }

    void InOrder()
    {
        cout << "InOrder: ";
        _InOrder(_pRoot);
        cout << endl;
    }


protected:

    bool _Insert(Node* & pRoot, const K& key, const V& value)
    {
        if (pRoot == NULL)
        {
            pRoot = new Node(key, value);
            return true;
        }

        if (key < pRoot->_key)
            return _Insert(pRoot->_pLeft, key, value);
        else if (key>pRoot->_key)
            return _Insert(pRoot->_pRight, key, value);
        else
            return false;
    }

    Node* _Find(Node* pRoot, const K& key)
    {
        if (pRoot == NULL)
            return NULL;

        if (key < pRoot->_key)
            return _Find(pRoot->_pLeft, key);
        else if (key>pRoot->_key)
            return _Find(pRoot->_pRight, key);
        else
            return pRoot;
    }

    bool _Remove(Node*&root, const K& key)
    {
        if (root == NULL)
            return false;
        if (root->_key < key)
            return _Remove(root->_pRight, key);
        else if (root->_key > key)
            return _Remove(root->_pLeft, key);
        else
        {
            Node* del = root;
            if (root->_pLeft == NULL)
                root = root->_pRight;
            else if (root->_pRight == NULL)
                root = root->_pLeft;
            else
            {
                Node* minright = root; //寻找右树的最左结点进行key值的交换
                minright = root->_pRight;

                while (minright->_pLeft)
                    minright = minright->_pLeft;

                root->_key = minright->_key;
                del = minright;
            }

            delete del;
            return true;
        }
    }

    void _InOrder(Node* pRoot)
    {
        if (pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout << pRoot->_key << " ";
            _InOrder(pRoot->_pRight);
        }
    }

protected:
    Node* _pRoot;
};


void FunTest()
{
    int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
    BSTree<int, int> bst;

    for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
    {
        bst.Insert(a[i], i);
    }

    bst.InOrder();

    if (bst.Find(2))
        cout << bst.Find(2)->_key << endl;

    bst.Remove(3);
    bst.InOrder();

    bst.Remove(5);
    bst.InOrder();

    bst.Remove(6);
    bst.InOrder();

    bst.Remove(8);
    bst.InOrder();
}

int main()
{
    FunTest();
    return 0;
}
二叉搜索树；二叉查找树；二叉排序树；binary search tree
疯狂算法~
06-09 1万+
binary search tree，中文翻译为二叉搜索树、二叉查找树或者二叉排序树。简称为BST 一：二叉搜索树的定义 他的定义与树的定义是类似的，也是一个递归的定义： 1、要么是一棵空树 2、如果不为空，那么其左子树节点的值都小于根节点的值；右子树节点的值都大于根节点的值 3、其左右子树也是二叉搜索树 在算法导论中的定义： 下图中是BST的两个例子： 其中(b)图中
【C++、数据结构】二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
金哥的博客
10-22 2184
二叉搜索树/二叉排序树/二叉查找树：创建、插入、查找、删除（非递归以及递归版本代码），以及超详细步骤图解
HDOJ题目3791二叉搜索树（二叉搜索树）
Jogging_Clown
08-21 681
二叉搜索树 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2844    Accepted Submission(s): 1244 Problem Description 判断两序列是否为同一二叉搜索树序列  
详解二叉搜索树
最新发布
2302_81016149的博客
07-03 792
只有key值的二叉搜索树只支持查找功能，比如：我们要查找某个单词是否在字典中存在，停车场是否存在某辆车等等，但对于其它信息我们无法获取如：单词的意思，车辆停车时长。然而，如果我们在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为链表，相应的，二叉搜索树的查找操作是和这棵树的高度相关的，而此时这颗树的高度就是这颗树的节点数 n，这时各种操作的时间复杂度也会退化为 𝑂(𝑛)。这样二叉搜索树便可满足如查询单词，查询车辆的停车时长，单词的引用次数一些简单需求。二分搜索树在时间性能上是具有局限性的。
二叉搜索树（排序树）
weixin_46383092的博客
04-15 897
二叉搜索树 排序树 二叉搜索树的删除详解 非递归版本
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
二叉搜索树实例练习
09-05
在中序遍历二叉搜索树时，节点将按照升序（默认）顺序访问，这也是它被称为“排序树”的原因。 在给定的实例练习中，我们看到一个具体的问题：判断两个序列是否能构建出相同的二叉搜索树。这个问题可以通过构建二叉...
Python实现二叉搜索树BST的方法示例
01-20
二叉排序树（BST）又称二叉查找树、二叉搜索树 二叉排序树(Binary Sort Tree)又称二叉查找树。它或者是一棵空树；或者是具有下列性质的二叉树： 1.若左子树不空，则左子树上所有结点的值均小于根结点的值； 2.若...
二叉树的特点和性质
09-24
二叉树的特点和性质 满二叉树 完全二叉树
二叉查找树的基本特征
csonst1017的博客
12-12 3679
版权声明：欢迎转载，注明作者和出处就好！如果不喜欢或文章存在明显的谬误，请留言说明原因再踩哦，谢谢，我也可以知道原因，不断进步！ https://blog.youkuaiyun.com/csonst1017/article/details/84940856 最近在实现二叉查找树的各种算法，总结了二叉查找树的基本特征，如果不知道基本特征的话，那肯定是实现不了的。 1.二叉查找树 首先二叉查找树是拥有二叉树的...
二叉搜索树特点(个人整理更新)
AzeShinja的博客
09-28 507
对二叉搜索树进行中序遍历就是一个顺序增长的数组 给两个数算他的祖先节点，例如: p, q 两个节点分别为~~~ 那么：（root.val - p.val ）* （root.val - q.val ）<= 0 代表 这两个节点再root节点两边 就例如LeetCode#235 二叉搜索数的最近公共祖先 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNo.
树、二叉树、二叉搜索树的实现和特性
org_hjh的博客
09-14 326
点赞再看，养成习惯，微信搜一搜【一角钱小助手】关注更多原创技术文章。 本文 GitHub github.com/JavaStudy 已收录，有我的系列文章。 前言 本篇先回顾树、二叉树、二叉搜索树的实现和特性，《AVL 树和红黑树的实现和特性》可以阅读这篇。另外，树的面试题解法一般都是递归 为什么? 我们在后面总结。 一维结构：数组、链表、跳表、栈、队列等，这些结构都是 线性存储结构。 二维结构：树、图，是一种非线性存储结构，存储的是具有 “一对多”关系的数据元素的集合。 树 Tree 树的结点..
C++：二叉搜索树的特点以及简易实现
ETalien_的博客
05-04 844
二叉搜索树 二叉搜索树也叫二叉排序树，它可以是一棵空树。它具有一下特点： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 没有键值（key）相等的节点 简单的说就是左边的值都比该节点的值小，右边的值都比该节点的值大。 像这样： 二叉搜索树的查找 因为二叉搜索树的特点就是左边的值都比该节点的...
【数据结构】【二叉树】四、二叉搜索树的特性（不断更新）
怕走崎岖路，莫想登高峰
12-28 456
目录一、题目1：二叉搜索树的后序遍历序列（剑指Offer 33）1. 后序遍历的两个特性2.二叉搜索树的特性3.二叉搜索树的后序遍历的特性注：二叉搜索树的中序遍历特性 刷leetcode进入了中等题目阶段，发现二叉搜索树有一些解题技巧可循，故记录于此。 一、题目1：二叉搜索树的后序遍历序列（剑指Offer 33） 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回true，否则返回false。假设输入的数组的任意两个数字都互不相同。 参考以下这颗二叉搜索树： 5 /
二叉树 | 二叉搜索树 | 二叉树的有序性 | leecode刷题笔记
qq_44250700的博客
08-12 423
跟随carl代码随想录刷题 语言：python。
二叉查找树（BST）具备什么特性呢
jiuyishaonv的博客
01-31 4599
1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树 二分查找的思想：查找所需的最大次数等同于二叉查找树的高度 在插入节点的时候，也是通过一层层的比较大小，找到新节点适合插入的位置   二叉树的缺陷：它主要体现在新插入节点的时候： （1）假设初始的二叉查找树只有三个节点，根节点值为9，左孩子值为8
二叉排序树和二叉搜索树
03-22
<think>嗯，用户想了解二叉排序树和二叉搜索树的区别和联系。首先，我需要确认这两个术语的定义。根据提供的引用，引用[2]、[4]提到二叉搜索树、二叉排序树、二叉查找树是同一概念的不同名称。比如引用[2]明确说“二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树”，而引用[4]也指出“二叉排序树（Binary Sort Tree）又称二叉查找(搜索)树（Binary Search Tree）”。这说明它们是同一个数据结构的不同翻译或称呼，可能没有本质区别。 接下来，用户可能想知道为什么会有不同的名称。可能是中文翻译的不同，比如“排序”和“搜索”对应不同的侧重点，但实际结构特性一致。根据引用中的描述，无论是二叉排序树还是二叉搜索树，都满足左子树节点小于根，右子树节点大于根的特性，并且中序遍历得到有序序列。例如引用[2]提到“对二叉搜索树进行中序遍历可以得到按关键字排序的有序序列”，这也适用于二叉排序树。 然后，我需要检查是否有引用提到两者的区别。但根据提供的资料，所有引用都统一认为它们是同一概念的不同名称，没有提到区别。例如引用[4]直接说“二叉排序树又称二叉查找(搜索)树”，引用[2]也做了同样的说明。因此可以确定它们是同一数据结构的不同名称，没有本质区别。 此外，用户可能还想了解它们的应用场景和操作，比如查找、插入、删除等。根据引用[5]中的代码示例，二叉搜索树的查找操作利用了左小右大的特性，这和二叉排序树的操作一致。引用[3]提到二叉查找树在大量数据下查询速度较快，这也适用于二叉排序树。 总结来说，用户的问题可能源于不同资料中使用不同术语导致的困惑，需要明确两者是同一概念的不同称呼，没有区别。同时，可以进一步解释它们的特性和操作，帮助用户全面理解。</think>### 二叉排序树 vs 二叉搜索树：定义、区别与联系 #### 1. **定义** - **二叉排序树（Binary Sort Tree）** 是一种特殊的二叉树结构，满足以下性质： 1. 若左子树非空，则左子树所有结点的值均小于根结点的值； 2. 若右子树非空，则右子树所有结点的值均大于根结点的值； 3. 左、右子树本身也是二叉排序树[^4][^2]。 - **二叉搜索树（Binary Search Tree, BST）** 定义与二叉排序树完全一致，仅名称不同。其核心性质是通过二分思想实现高效查找、插入和删除操作[^2][^5]。 #### 2. **区别与联系** - **名称差异** - **二叉排序树**：强调中序遍历结果是有序序列（即对数据排序的支持）。 - **二叉搜索树**：强调基于二分法的快速搜索能力[^3]。 - **本质一致性** 两者是同一数据结构的不同名称，**无本质区别**。中文资料中常将二者混用，英文统称为 *Binary Search Tree (BST)*[^4]。 #### 3. **核心特性** - **有序性**：中序遍历结果为升序序列，例如对树 $$T$$ 进行中序遍历可得到 $$a_1 < a_2 < \dots < a_n$$[^4]。 - **高效操作**： - **查找**：时间复杂度为 $O(h)$（$h$ 为树的高度），最优情况下为 $O(\log n)$（平衡树）。 - **插入/删除**：需保持有序性，可能导致树结构变化（如调整子树）[^5]。 #### 4. **应用场景** 1. 数据库索引结构（如B树的基础）。 2. 动态数据集合的快速检索与维护[^5]。 3. 排序算法（通过中序遍历直接输出有序序列）。 #### 5. **代码示例（查找操作）** ```c++ bool Find(const K& key) { Node* cur = _root; while (cur) { if (key < cur->_key) cur = cur->_left; // 左子树查找 else if (key > cur->_key) cur = cur->_right; // 右子树查找 else return true; // 找到目标 } return false; // 未找到 } ``` ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值