平衡树之RB-tree

 #include <memory>
 
 template<class T>
 struct rb_node
 {
     T key;
     bool color;//true red | false black
     std::shared_ptr<rb_node> lchild, rchild, parent;
 
     rb_node(T key, bool color = true, std::shared_ptr<rb_node> lchild = nullptr,
         std::shared_ptr<rb_node> rchild = nullptr, std::shared_ptr<rb_node> parent = nullptr)
         :key(key)//此处不能使用this：现在对象还没被构建起来
     {
         //赋值，初始化在初始化列表中执行
         this->color = color;
         this->lchild = lchild;
         this->rchild = rchild;
         this->parent = parent;
     }
 };
 
 template<class T>
 class rb_tree
 {
 private:
     std::shared_ptr<rb_node<T>> root;
     std::shared_ptr<rb_node<T>> nil;//叶节点
     void left_rotation(std::shared_ptr<rb_node<T>> a)
     {
         if (a == nullptr) return;
         std::shared_ptr<rb_node<T>> b = a->rchild;
         if (b == nullptr) return;
         if (b->lchild != nullptr)
             b->lchild->parent = a;
         a->rchild = b->lchild;
 
         if (a->parent == nil)
             root = b;//rbtree的root以nil为父节点
         else
         {
             if (a->parent->lchild == a)
                 a->parent->lchild = b;
             else
                 a->parent->rchild = b;
         }
         b->parent = a->parent;
 
         b->lchild = a;
         a->parent = b;
     }
     void right_rotation(std::shared_ptr<rb_node<T>> a)
     {
         if (a == nullptr) return;
         std::shared_ptr<rb_node<T>> b = a->lchild;
         if (b == nullptr) return;
         if (b->rchild != nullptr)
             b->rchild->parent = a;
         a->lchild = b->rchild;
 
         if (a->parent == nil)
             root = b;
         else
         {
             if (a->parent->lchild == a)
                 a->parent->lchild = b;
             else
                 a->parent->rchild = b;
         }
         b->parent = a->parent;
 
         b->rchild = a;
         a->parent = b;
     }
 
 public:
     rb_tree()
     {
         root = nullptr;
         T key;
         nil = std::make_shared<rb_node<T>>(key, false);
     }
     void insert(T key)
     {
         std::shared_ptr<rb_node<T>> tmp = std::make_shared<rb_node<T>>(key, true, nil, nil, nil);
         std::shared_ptr<rb_node<T>> ptr = root;
 
         //情况1：树为空
         if (ptr == nullptr)
         {
             tmp->color = false;
             root = tmp;
             return;
         }
         while (true)
         {
             if (key <= ptr->key)
             {
                 if (ptr->lchild == nil) break;
                 ptr = ptr->lchild;
             }
             else
             {
                 if (ptr->rchild == nil) break;
                 ptr = ptr->rchild;
             }
         }
 
         if (key <= ptr->key)
             ptr->lchild = tmp;
         else
             ptr->rchild = tmp;
         tmp->parent = ptr;
 
         while(true)
         {
             if (ptr == nil)//注意root可能被情况三修改为red，记得加特判
             {
                 tmp->color = false;
                 root = tmp;
                 return;
             }
 
             //情况2：插入节点的父节点为黑色
             if (!ptr->color) return;        
 
             /*情况3：插入节点的父节点和叔节点都存在且都为红色*/
             if (ptr->parent->lchild->color && ptr->parent->rchild->color)
             {
                 ptr->parent->color = true;
                 ptr->parent->lchild->color = false;
                 ptr->parent->rchild->color = false;
 
                 tmp = ptr->parent;
                 ptr = tmp->parent;
                 continue;
             }
             if (ptr->parent->lchild == ptr)
             {
                 //情况4：右旋
                 if (tmp == ptr->lchild)
                 {
                     ptr->parent->color = true;
                     ptr->color = false;
                     right_rotation(ptr->parent);
                     return;
                 }
                 else
                 {
                     //情况5：左旋 + 右旋
                     left_rotation(ptr);
                     tmp = ptr;
                     ptr = tmp->parent;
                     continue;
                 }
             }
             else
             {
                 //情况4：左旋
                 if (tmp == ptr->rchild)
                 {
                     ptr->parent->color = true;
                     ptr->color = false;
                     left_rotation(ptr->parent);
                     return;
                 }
                 else
                 {
                     //情况5：右旋+左旋
                     right_rotation(ptr);
                     tmp = ptr;
                     ptr = tmp->parent;
                     continue;
                 }
             }
         }
     }
     void earse(T key)
     {
         //待续
     }
 };