BinarySearchTree（二叉搜索树）原理及C++代码实现

BST是一类用途极广的数据结构。它有如下性质：设x是二叉搜索树内的一个结点。如果y是x左子树中的一个结点，那么y.key<=x.key。如果y是x右子树中的一个结点，那么y.key>=x.key。

BST容易出现不平衡的情况，所以实际运用的时候还是以平衡的二叉搜索树为主，例如RB树，AVL树，treap树甚至skiplist等。

BST实现较为简单，我们直接来看看代码吧。

代码如下：（仅供参考）

 #include <iostream>
 using namespace std;

 struct Node {
     int key;
     Node * left;
     Node * right;
     Node * parent;
     Node() : key(), left(nullptr), right(nullptr), parent(nullptr) {}
 };

 class BST {
     Node * root;
 private :
     Node * minimum(Node * p);
     Node * maximum(Node * p);
     //用新结点代替旧结点，只修改结点与其父节点的指向，允许新结点为空
     void transplant(Node * old_t, Node * new_t);
 public :
     BST() : root(nullptr) {}
     Node * search(const int k) {return search(root, k);}
     Node * search(Node * p, const int k);
     const Node * minimum() {return minimum(root);}
     const Node * maximum() {return maximum(root);}
     const Node * successor(Node * p);
     const Node * predecessor(Node * p);
     void insert(const int k);
     void remove(const int k) {remove(search(k));}
     void remove(Node * p);
     void inorderWalk() {inorderWalk(root);}
     void inorderWalk(Node * p);
 };

 Node * BST::search(Node * p, const int k) {
     if (p == nullptr || k == p->key)
         return p;
     if (k < p->key)
         return search(p->left, k);
     else
         return search(p->right, k);
 }

 Node * BST::minimum(Node * p) {
     if (p == nullptr)
         return p;
     while (p->left)
         p = p->left;
     return p;
 }

 Node * BST::maximum(Node * p) {
     if (p == nullptr)
         return p;
     while (p->right)
         p = p->right;
     return p;
 }

 const Node * BST::successor(Node * p) {
     if (p->right)
         return minimum(p->right);
     Node * y = p->parent;
     while (y != nullptr && y->right == p) {
         p = y;
         y = y->parent;
     }
     return y;
 }

 const Node * BST::predecessor(Node * p) {
     if (p->left)
         return maximum(p->left);
     Node * y = p->parent;
     while (y != nullptr && y->left == p) {
         p = y;
         y = y->parent;
     }
     return y;
 }

 void BST::insert(const int k) {
     Node * p = new Node;
     p->key = k;

     Node *x = root, *y = nullptr;
     while (x != nullptr) {
         y = x;
         if (x->key < k)
             x = x->right;
         else
             x = x->left;
     }
     p->parent = y;
     if (y == nullptr)
         root = p;
     else if (y->key < k)
         y->right = p;
     else
         y->left = p;
 }

 void BST::transplant(Node * old_t, Node * new_t) {
     if (old_t->parent == nullptr)
         root = new_t;
     else if (old_t == old_t->parent->left)
         old_t->parent->left = new_t;
     else
         old_t->parent->right = new_t;
     if (new_t != nullptr)
         new_t->parent = old_t->parent;
 }

 void BST::remove(Node * p) {
     if (p->left == nullptr)
         transplant(p, p->right);
     else if (p->right == nullptr)
         transplant(p, p->left);
     else {
         Node * t = minimum(p->right);
         if (t->parent != p) {
             transplant(t, t->right);
             t->right = p->right;
             t->right->parent = t;
         }
         transplant(p, t);
         t->left = p->left;
         t->left->parent = t;
     }
     delete p;
 }

 void BST::inorderWalk(Node * p) {
     if (p) {
         inorderWalk(p->left);
         cout << p->key << ends;
         inorderWalk(p->right);
     }
 }