你們要的紅黑樹

源碼來自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;
}