RedBlack-Tree（红黑树）原理及C++代码实现

众所周知，红黑树是用途很广的平衡二叉搜索树，用过的都说好。所以我们来看看红黑树的是怎么实现的吧。

红黑树顾名思义，通过红与黑两种颜色来给每个节点上色。其中根结点和叶子结点一定是黑色的，并且红色结点的两个孩子一定是黑色的，每个结点到所有后代叶子的简单路径上，均包含相同数目的黑色结点（黑高bh）。

这里和其他树有些区别的是，红黑树的叶子结点并不包含关键字，它只是用来维持红黑树的性质。所以包含关键字的结点都是内部结点。

这样的性质也带来了很多有意思的现象。下面我们忽略所谓的叶子结点来看看。

1.红色结点的孩子要么没有，要么是两个黑色结点，不会有单个孩子结点的时候。

2.如果某个结点只有一个孩子结点，那么那个孩子结点一定是红色的。

3.用吸收的角度去看，即黑色结点可以吸收它的红色孩子结点，红黑树就像一个2-3-4树。

下面我们来看看代码吧，代码用了一个小技巧，即所有的叶子结点都用一个nil结点来表示，指向nullptr的指针现在全部指向nil。

代码如下：（仅供参考）

 #include <iostream>
 using namespace std;

 class RBT {
 private :
     enum {RED = , BLACK};
     struct Node {
         int key;
         bool color;
         Node * left;
         Node * right;
         Node * parent;
         Node(int k = , bool c = BLACK, Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
             : key(k), color(c), left(l), right(r), parent(p) {}
     };
 private :
     Node * nil;
     Node * root;
 private :
     void leftRotate(Node * x);
     void rightRotate(Node * x);
     void fixup_insert(Node * p);
     void fixup_remove(Node * p);
     void transplant(Node * old_t, Node * new_t);
     void insert(Node * p);
     void remove(Node * p);
     Node * search(Node * p, const int k);
     Node * minimum(Node * p);
     Node * maximum(Node * p);
     void inorderWalk(Node * p) const;
 public :
     RBT() : nil(new Node), root(nil) {}
     ~RBT() {delete nil;}
     void insert(const int key) {insert(new Node(key, RED, nil, nil, nil));}
     void remove(const int key) {remove(search(root, key));}
     bool search(const int key) {return (search(root, key) == nil ? false : true);}
     int minimum() {return minimum(root)->key;}
     int maximum() {return maximum(root)->key;}
     int predecessor(const int key);
     int successor(const int key);

 friend ostream &operator<<(ostream &os, const RBT &t);
 };

 void RBT::inorderWalk(Node * p) const {
     if (p != nil) {
         inorderWalk(p->left);
         cout << p->key << ' ';
         inorderWalk(p->right);
     }
 }

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

 RBT::Node * RBT::minimum(Node * p) {
     if (p == nil)
         return p;
     while (p->left != nil)
         p = p->left;
     return p;
 }

 RBT::Node * RBT::maximum(Node * p) {
     if (p == nil)
         return p;
     while (p->right != nil)
         p = p->right;
     return p;
 }

 int RBT::predecessor(const int k) {
     Node * p = search(root, k);
     if (p == nil)
         return ;
     if (p->left != nil)
         return maximum(p->left)->key;
     Node * y = p->parent;
     while (y != nil && y->left == p) {
         p = y;
         y = y->parent;
     }
     return y->key;
 }

 int RBT::successor(const int k) {
     Node * p = search(root, k);
     if (p == nil)
         return ;
     if (p->right != nil)
         return minimum(p->right)->key;
     Node * y = p->parent;
     while (y != nil && y->right == p) {
         p = y;
         y = y->parent;
     }
     return y->key;
 }

 void RBT::leftRotate(Node * x) { //assume:x->right != nil
     Node * y = x->right;
     x->right = y->left;
     if (y->left != nil)
         y->left->parent = x;
     y->parent = x->parent;
     if (x->parent == nil)
         root = y;
     else if (x == x->parent->left)
         x->parent->left = y;
     else
         x->parent->right = y;
     y->left = x;
     x->parent = y;
 }

 void RBT::rightRotate(Node * x) { //assume:x->left != nil
     Node * y = x->left;
     x->left = y->right;
     if (y->right != nil)
         y->right->parent = x;
     y->parent = x->parent;
     if (x->parent == nil)
         root = y;
     else if (x == x->parent->right)
         x->parent->right = y;
     else
         x->parent->left = y;
     y->right = x;
     x->parent = y;
 }

 void RBT::insert(Node * p) {
     if (p == nullptr)
         return ;
     Node * x = root;
     Node * y = nil;
     while (x != nil) {
         y = x;
         if (x->key < p->key)
             x = x->right;
         else
             x = x->left;
     }
     p->parent = y;
     if (y == nil)
         root = p;
     else if (y->key < p->key)
         y->right = p;
     else
         y->left = p;
     fixup_insert(p);
 }

 void RBT::fixup_insert(Node * p) {
     while (p->parent->color == RED) {
         if (p->parent == p->parent->parent->left) {
             Node * y = p->parent->parent->right;
             if (y->color == RED) { //case 1
                 p->parent->color = BLACK;
                 y->color = BLACK;
                 p->parent->parent->color = RED;
                 p = p->parent->parent;
             }
             else {
                 if (p == p->parent->right) { //case 2
                     p = p->parent;
                     leftRotate(p);
                 }
                 p->parent->color = BLACK; //case 3
                 p->parent->parent->color = RED;
                 rightRotate(p->parent->parent);
             }
         }
         else { //with "right" and "left" exchanged
             Node * y = p->parent->parent->left;
             if (y->color == RED) { //case 1
                 p->parent->color = BLACK;
                 y->color = BLACK;
                 p->parent->parent->color = RED;
                 p = p->parent->parent;
             }
             else {
                 if (p == p->parent->left) { //case 2
                     p = p->parent;
                     rightRotate(p);
                 }
                 p->parent->color = BLACK; //case 3
                 p->parent->parent->color = RED;
                 leftRotate(p->parent->parent);
             }
         }
     }
     root->color = BLACK;
 }

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

 void RBT::fixup_remove(Node * x) {
     Node * z = nil;
     while (x != root && x->color == BLACK) {
         if (x == x->parent->left) {
             z = x->parent->right;
 /*case 1*/  if (z->color == RED) {
                 z->color = BLACK;
                 x->parent->color = RED;
                 leftRotate(x->parent);
                 z = x->parent->right; //new z
             }
 /*case 2*/  if (z->left->color == BLACK && z->right->color == BLACK) {
                 z->color = RED;
                 x = x->parent;
             }
             else {
 /*case 3*/      if (z->right->color == BLACK) {
                     z->left->color = BLACK;
                     z->color = RED;
                     rightRotate(z);
                     z = x->parent->right;
                 }
 /*case 4*/      z->color = x->parent->color;
                 x->parent->color = BLACK;
                 z->right->color = BLACK;
                 leftRotate(x->parent);
                 x = root; //exit while
             }
         }
         else {
             z = x->parent->left;
 /*case 1*/  if (z->color == RED) {
                 z->color = BLACK;
                 x->parent->color = RED;
                 rightRotate(x->parent);
                 z = x->parent->left; //new z
             }
 /*case 2*/  if (z->right->color == BLACK && z->left->color == BLACK) {
                 z->color = RED;
                 x = x->parent;
             }
             else {
 /*case 3*/      if (z->left->color == BLACK) {
                     z->right->color = BLACK;
                     z->color = RED;
                     leftRotate(z);
                     z = x->parent->left;
                 }
 /*case 4*/      z->color = x->parent->color;
                 x->parent->color = BLACK;
                 z->left->color = BLACK;
                 rightRotate(x->parent);
                 x = root; //exit while
             }
         }
     }
     x->color = BLACK;
 }

 void RBT::remove(Node * p) {
     if (p == nil)
         return ;
     Node * y = p;
     Node * x = nil;
     bool y_originalColor = y->color;
     if (p->left == nil) {
         x = p->right;
         transplant(p, p->right);
     }
     else if (p->right == nil) {
         x = p->left;
         transplant(p, p->left);
     }
     else {
         y = minimum(p->right);
         y_originalColor = y->color;
         x = y->right;
         if (y->parent == p)
             x->parent = y;   //maybe x == nil
         else {
             transplant(y, y->right);
             y->right = p->right;
             y->right->parent = y;
         }
         transplant(p, y);
         y->left = p->left;
         y->left->parent = y;
         y->color = p->color;
     }
     delete p;
     if (y_originalColor == BLACK)
         fixup_remove(x);
 }

 ostream &operator<<(ostream &os, const RBT &t) {
     t.inorderWalk(t.root);
     return os;
 }