二叉搜索树详解以及C++实现二叉搜索树（递归和非递归）-阿里云开发者社区

1. 二叉搜索树的概念

二叉搜索树又称二叉排序树或者二叉查找树，它或者是一棵空树，或者是具有以下性质的二叉树:

若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树
例如：

2. 二叉搜索树的相关操作

以下列数组创建的搜索二叉树为例：

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

2.1 插入

插入的具体过程如下：

树为空，则直接新增节点，赋值给root指针。
树不空，按二叉搜索树性质查找插入位置，插入新节点。

例如：

2.2 删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

要删除的结点无孩子结点。
要删除的结点只有左孩子结点。
要删除的结点只有右孩子结点。
要删除的结点有左、右孩子结点。

看起来有待删除节点有4中情况，实际情况 1 可以与情况 2 或者 3 合并起来，因此真正的删除过程如下：

情况2：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除。

情况3：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除。

情况4：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除。

例如：

2.3 查找

从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
最多查找高度次，走到到空，还没找到，这个值不存在。

3. 二叉搜索树的实现

3.1 创建结点

template<class K>
struct BSTreeNode
{
  BSTreeNode<K>* _left;
  BSTreeNode<K>* _right;
  K _key;
  BSTreeNode(const K& key)
    :_key(key)
    ,_left(nullptr)
    ,_right(nullptr)
  {}
};

3.2 创建一个BSTree类

template<class K>
class BSTree
{
  typedef BSTreeNode<K> Node;
private:
  void DestoryTree(Node* root)
  {
    if (root == nullptr)
      return;
    DestoryTree(root->_left);
    DestoryTree(root->_right);
    delete root;
  }
  Node* CopyTree(Node* root)
  {
    if (root == nullptr)
      return nullptr;
    Node* copyNode = new Node(root->_key);
    copyNode->_left = CopyTree(root->_left);
    copyNode->_right = CopyTree(root->_right);
    return copyNode;
  }
public:
  BSTree() = default;//C++11、强制编译器自己生成构造函数
  BSTree(const BSTree<K>& t)
  {
    _root = CopyTree(t._root);
  }
  BSTree<K>& operator=(BSTree<K> t)
  {
    std::swap(_root, t._root);
    return *this;
  }
  ~BSTree()
  {
    DestoryTree(_root);
    _root = nullptr;
  }
private:
  Node* _root = nullptr;
};

3.3 二叉搜索树的插入操作

3.3.1 递归实现

  bool _InsertR(Node*& root, const K& key)
  {
    if (root == nullptr)
    {
      root = new Node(key);
      return true;
    }
    if (root->_key > key)
    {
      return _InsertR(root->_left, key);
    }
    else if (root->_key < key)
    {
      return _InsertR(root->_right, key);
    }
    else
    {
      return false;
    }
  }
  bool InsertR(const K& key)
  {
    return _InsertR(_root, key);
  }

3.3.2 非递归实现

  bool Insert(const K& key)
  {
    if (_root == nullptr)
    {
      _root = new Node(key);
      return true;
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
      if (cur->_key > key)
      {
        parent = cur;
        cur = cur->_left;
      }
      else if (cur->_key < key)
      {
        parent = cur;
        cur = cur->_right;
      }
      else
      {
        return false;//存在重复元素
      }
    }
    cur = new Node(key);
    if (parent->_key < key)
    {
      parent->_right = cur;
    }
    else
    {
      parent->_left = cur;
    }
    return true;
  }

3.4 二叉搜索树的删除操作

3.4.1 递归实现

  bool _EraseR(Node*& root, const K& key)
  {
    if (root == nullptr)
      return false;
    if (root->_key > key)
    {
      return _EraseR(root->_left, key);
    }
    else if (root->_key < key)
    {
      return _EraseR(root->_right, key);
    }
    else
    {
      Node* del = root;
      if (root->_left == nullptr)
      {
        root = root->_right;
      }
      else if (root->_right == nullptr)
      {
        root = root->_left;
      }
      else
      {
        Node* minRight = root->_right;
        while (minRight->_left)
        {
          minRight = minRight->_left;
        }
        swap(root->_key, minRight->_key);
        return _EraseR(root->_right, key);
      }
      delete del;
      return true;
    }
  }
  bool EraseR(const K& key)
  {
    return _EraseR(_root, key);
  }

3.4.2 非递归实现

  bool Erase(const K& key)
  {
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
      if (cur->_key < key)
      {
        parent = cur;
        cur = cur->_right;
      }
      else if (cur->_key > key)
      {
        parent = cur;
        cur = cur->_left;
      }
      else
      {
        //一个孩子   左空/右空
        if (cur->_left == nullptr)
        {
          if (cur == _root)
          {
            _root = cur->_right;
          }
          else
          {
            if (cur == parent->_left)
            {
              parent->_left = cur->_right;
            }
            else
            {
              parent->_right = cur->_right;
            }
          }
          delete cur;
        }
        else if (cur->_right == nullptr)
        {
          if (cur == _root)
          {
            _root = cur->_left;
          }
          else
          {
            if (cur == parent->_left)
            {
              parent->_left = cur->_left;
            }
            else
            {
              parent->_right = cur->_left;
            }
          }
          delete cur;
        }
        //两个孩子
        else
        {
          Node* minRight = cur->_right;
          Node* minParent = cur;
          while (minRight->_left)
          {
            minParent = minRight;
            minRight = minRight->_left;
          }
          //cur->_key = minRight->_key;
          swap(minRight->_key, cur->_key);
          if (minParent->_left == minRight)
          {
            minParent->_left = minRight->_right;
          }
          else
          {
            minParent->_right = minRight->_right;
          }
          delete minRight;
        }
        return true;
      }
    }
    return false;
  }

3.5 二叉搜索树的查找操作

3.5.1 递归实现

  bool _FindR(Node* root, const K& key)
  {
    if (root == nullptr)
      return false;
    if (root->_key < key)
    {
      return _FindR(root->_right, key);
    }
    else if (root->_key > key)
    {
      return _FindR(root->_left, key);
    }
    else
    {
      return true;
    }
  }
  bool FindR(const K& key)
  {
    return _FindR(_root, key);
  }

3.5.2 非递归实现

  bool Find(const K& key)
  {
    Node* cur = _root;
    while (cur)
    {
      if (cur->_key < key)
      {
        cur = cur->_right;
      }
      else if (cur->_key > key)
      {
        cur = cur->_left;
      }
      else
      {
        return true;
      }
    }
    return false;
  }

3.6 实现二叉搜索树的完整代码

#pragma once
#include<algorithm>
#include<iostream>
using namespace std;
template<class K>
struct BSTreeNode
{
  BSTreeNode<K>* _left;
  BSTreeNode<K>* _right;
  K _key;
  BSTreeNode(const K& key)
    :_key(key)
    ,_left(nullptr)
    ,_right(nullptr)
  {}
};
template<class K>
class BSTree
{
  typedef BSTreeNode<K> Node;
public:
  BSTree() = default;//C++11、强制编译器自己生成构造函数
  BSTree(const BSTree<K>& t)
  {
    _root = CopyTree(t._root);
  }
  BSTree<K>& operator=(BSTree<K> t)
  {
    std::swap(_root, t._root);
    return *this;
  }
  ~BSTree()
  {
    DestoryTree(_root);
    _root = nullptr;
  }
  bool Insert(const K& key)
  {
    if (_root == nullptr)
    {
      _root = new Node(key);
      return true;
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
      if (cur->_key > key)
      {
        parent = cur;
        cur = cur->_left;
      }
      else if (cur->_key < key)
      {
        parent = cur;
        cur = cur->_right;
      }
      else
      {
        return false;//存在重复元素
      }
    }
    cur = new Node(key);
    if (parent->_key < key)
    {
      parent->_right = cur;
    }
    else
    {
      parent->_left = cur;
    }
    return true;
  }
  void InOrder()
  {
    _InOrder(_root);
    cout << endl;
  }
  bool Find(const K& key)
  {
    Node* cur = _root;
    while (cur)
    {
      if (cur->_key < key)
      {
        cur = cur->_right;
      }
      else if (cur->_key > key)
      {
        cur = cur->_left;
      }
      else
      {
        return true;
      }
    }
    return false;
  }
  bool Erase(const K& key)
  {
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
      if (cur->_key < key)
      {
        parent = cur;
        cur = cur->_right;
      }
      else if (cur->_key > key)
      {
        parent = cur;
        cur = cur->_left;
      }
      else
      {
        //一个孩子   左空/右空
        if (cur->_left == nullptr)
        {
          if (cur == _root)
          {
            _root = cur->_right;
          }
          else
          {
            if (cur == parent->_left)
            {
              parent->_left = cur->_right;
            }
            else
            {
              parent->_right = cur->_right;
            }
          }
          delete cur;
        }
        else if (cur->_right == nullptr)
        {
          if (cur == _root)
          {
            _root = cur->_left;
          }
          else
          {
            if (cur == parent->_left)
            {
              parent->_left = cur->_left;
            }
            else
            {
              parent->_right = cur->_left;
            }
          }
          delete cur;
        }
        //两个孩子
        else
        {
          Node* minRight = cur->_right;
          Node* minParent = cur;
          while (minRight->_left)
          {
            minParent = minRight;
            minRight = minRight->_left;
          }
          //cur->_key = minRight->_key;
          swap(minRight->_key, cur->_key);
          if (minParent->_left == minRight)
          {
            minParent->_left = minRight->_right;
          }
          else
          {
            minParent->_right = minRight->_right;
          }
          delete minRight;
        }
        return true;
      }
    }
    return false;
  }
  bool FindR(const K& key)
  {
    return _FindR(_root, key);
  }
  bool InsertR(const K& key)
  {
    return _InsertR(_root, key);
  }
  bool EraseR(const K& key)
  {
    return _EraseR(_root, key);
  }
private:
  bool _EraseR(Node*& root, const K& key)
  {
    if (root == nullptr)
      return false;
    if (root->_key > key)
    {
      return _EraseR(root->_left, key);
    }
    else if (root->_key < key)
    {
      return _EraseR(root->_right, key);
    }
    else
    {
      Node* del = root;
      if (root->_left == nullptr)
      {
        root = root->_right;
      }
      else if (root->_right == nullptr)
      {
        root = root->_left;
      }
      else
      {
        Node* minRight = root->_right;
        while (minRight->_left)
        {
          minRight = minRight->_left;
        }
        swap(root->_key, minRight->_key);
        return _EraseR(root->_right, key);
      }
      delete del;
      return true;
    }
  }
  bool _InsertR(Node*& root, const K& key)
  {
    if (root == nullptr)
    {
      root = new Node(key);
      return true;
    }
    if (root->_key > key)
    {
      return _InsertR(root->_left, key);
    }
    else if (root->_key < key)
    {
      return _InsertR(root->_right, key);
    }
    else
    {
      return false;
    }
  }
  void DestoryTree(Node* root)
  {
    if (root == nullptr)
      return;
    DestoryTree(root->_left);
    DestoryTree(root->_right);
    delete root;
  }
  Node* CopyTree(Node* root)
  {
    if (root == nullptr)
      return nullptr;
    Node* copyNode = new Node(root->_key);
    copyNode->_left = CopyTree(root->_left);
    copyNode->_right = CopyTree(root->_right);
    return copyNode;
  }
  void _InOrder(Node* root)
  {
    if (root == nullptr)
      return;
    _InOrder(root->_left);
    cout << root->_key << " ";
    _InOrder(root->_right);
  }
  bool _FindR(Node* root, const K& key)
  {
    if (root == nullptr)
      return false;
    if (root->_key < key)
    {
      return _FindR(root->_right, key);
    }
    else if (root->_key > key)
    {
      return _FindR(root->_left, key);
    }
    else
    {
      return true;
    }
  }
private:
  Node* _root = nullptr;
};

4. 二叉搜索树的应用

K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。

比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方式在现实生活中非常常见：

比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是就构成一种键值对。

5. 二叉搜索树性能分析

二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其查找的时间复杂度为O(logN)。
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其查找的时间复杂度为O(N)。

如果想要二叉搜索树的性能都能达到最优，那么要实现AVL树和红黑树。

二叉搜索树详解以及C++实现二叉搜索树（递归和非递归）