你们要的红黑树

源码来自B站大佬
视频链接
红黑树核心原理：
通过“双红限制”(不允许父亲儿子都为红)和“黑深度”(叶节点到根节点路径上黑节点的个数)维持平衡

#include<iostream>
using namespace std;
#define bro(x) (((x)->f->l == (x))?((x)->f->r):((x)->f->l))

enum Color {red=0,black=1} ;

template<typename T>
class RedBlackTree            //主要结构和功能
{
public:
     struct iterator;         //定义迭代器
     RedBlackTree():_root(NULL),_hot(NULL),_size(0){}
                           
     iterator insert(T);      //返回插入位置
     bool remove(T); 
     bool remove(iterator&);
     iterator search(T);
     iterator lower_bound(T);
     iterator upper_bound(T);
     
     void clear();            //清空树
     int size();
     bool empty();
     iterator begin();
     static iterator end();  //为什么static?
protected:
     struct Node;
     Node *_root;         //根节点
     Node *_hot;          //选中节点
     int _size;           //树大小
     void Init(T);
     
     Node *zig(Node *);   //左旋
     Node *zag(Node *);   //右旋
     
     void SolveDoubleRed(Node *); //双红修正
     void SolveLostBlack(Node *); //失黑修正

     Node *find(T v);
     void removetree(Node *); //dfs后序遍历清空树
};


template<typename T>
struct RedBlackTree<T>::Node  //节点实现
{
    T val;
    Color rb;
    Node *f;
    Node *l;
    Node *r;
    
    Node (T v=T(),Color rb=red,Node *f=NULL, Node *l=NULL, Node *r=NULL):
    val(v),rb(rb),f(f),l(l),r(r){}  //节点构造

    Node *forward()       //前驱 = 小于当前节点的最大值
    {
        Node *ptn=this;
        if(!ptn->l)       //没有左儿子 在父亲里面找前驱
        {
            while(ptn->f&&ptn->f->l==ptn)ptn=ptn->f;
            ptn=ptn->f;   
        } 
        else
        {                 //有左儿子
            ptn=ptn->l;
            while(ptn->r)ptn=ptn->r;
        }
        return ptn;
    }

    Node *backward()      //后驱 = 大于当前节点的最小值
    {
        Node *ptn=this;
        if(!ptn->r)       //没有右儿子 在父亲里面找后驱
        {                 
            while(ptn->f&&ptn->f->r==ptn)ptn=ptn->f;
            ptn=ptn->f;
        }                 //有右儿子
        else
        {
            ptn=ptn->r;
            while(ptn->l)ptn=ptn->l;
        }
        return ptn;
    }
};

template<typename T>
struct RedBlackTree<T>::iterator
{
protected:
   Node *_real_node;
public:
   T& operator*()
   {
       return _real_node->val;
   }

   bool operator==(iterator const& itr)
   {
       return _real_node ==itr._real_node;
   }

   bool operator!()
   {
       return !_real_node; 
   }

   iterator& operator=(iterator const& itr)
   {
       _real_node=itr._real_node;
       return *this;
   }

   iterator& operator++()   // 后继
   {
       _real_node = _real_node->backward();
       return *this;
   }

   iterator& operator--()   // 前驱
   {
       _real_node = _real_node->forward();
       return *this;
   }

   iterator(T const& val):_real_node(find(val)){}
   iterator(Node *nd=NULL):_real_node(nd){}
   iterator(iterator const& itr):_real_node(itr._real_node){}
};

template <typename T>
RedBlackTree<T>::Node* RedBlackTree<T>::find(T v)
{
   Node *ptn=_root;
   _hot=NULL;
   while(ptn&&ptn->val!=v)
   {   
       _hot = ptn;
       if(ptn->val > v) ptn=ptn->l;
       else ptn=ptn->r;
   }
   return ptn;
}

template <typename T>
RedBlackTree<T>::iterator RedBlackTree<T>::search(T v)
{
   return iterator(find(v));
}

template <typename T>
RedBlackTree<T>::iterator RedBlackTree<T>::lower_bound(T v)
{
   Node* ptn = _root;
   _hot = NULL;
   while(ptn)
   {
       _hot = ptn;
       if(ptn->val >= v)ptn=ptn->l;  
       else ptn=ptn->r;
   } 
   if(_hot->val >= v)ptn = _hot;     //小于v的最大值
   else ptn = _hot->backward();      //大于v的最小值
   return iterator(ptn);             //以T为下界的迭代器
}

template <typename T>
RedBlackTree<T>::iterator RedBlackTree<T>::upper_bound(T v)
{
   Node* ptn = _root;
   _hot = NULL;
   while(ptn)
   {
       _hot = ptn;
       if(ptn->val > v)ptn=ptn->l;  
       else ptn=ptn->r;
   } 
   if(_hot->val >= v)ptn = _hot;     //小于v的最大值
   else ptn = _hot->backward();      //大于v的最小值
   return iterator(ptn);             //返回以T为上界的迭代器
}

int main()
{
   return 0;
}