红黑树RB_tree

   红黑树也是一种而叉搜索树，因此二叉搜索树的性质红黑树都具有，同时，我们知道为了避免最坏情况下的二叉搜索树（就是高度不平衡的情况）衍生出了AVL树，使其任何节点的左右子树的高度差相差最多1，从而达到平衡，以确保最坏情况下的搜索效率。当然红黑树为了比较好的搜索效率降低了对平衡的要求，但是红黑树仍然具有良好的平衡状态。

    AVL树与RB_tree

    AVL树也称为高度平衡树，其插入，删除，查找在平均和最坏情况下都是O(log n),增加和删除要通过一次或多次树的旋转来重新平衡这个树。

    RB_tree并不追求完全平衡，只要求部分达到平衡要求，降低了对旋转的要求，从而提高了性能，红黑树能够以O(log 2 n)的时间复杂度进行插入，删除，查找，此外由于它的设计任何不平衡都会在3次旋转之内解决。相比较而言红黑树和AVL树的算法时间复杂度相同，但统计性能比AVL树高。同时，红黑树的应用比AVL树广泛

    例如：（1）红黑树广泛应用于c++的STL中，比如关联式容器set, map,multiset, multimap都以RB_tree为底层机制。

               （2）epoll在内核中的实现，用红黑树管理事件块。

               （3）linux进程调度上，用红黑树管理进程控制块。

               （4）nginx中用红黑树管理timer

下面自己分析了SGI中的stl_tree.h源码的分析

#ifndef __SGI_STL_INTERNAL_TREE_H
#define __SGI_STL_INTERNAL_TREE_H
//RB-tree的节点设计
//设计思路节点设计分为两层__rb_tree_node继承__rb_tree_node_base以达到将指针和数据分开
typedef bool __rb_tree_color_type;
const __rb_tree_color_type __rb_tree_red = false;
const __rb_tree_color_type __rb_tree_black = true;

struct __rb_tree_node_base
{
    typedef __rb_tree_color_type color_type;
    typedef __rb_tree_node_base* base_ptr;
    color_type color;
    base_ptr parent;
    base_ptr left;
    base_ptr right;
    //找到存储的最小值
    static base_ptr minimum(base_ptr x)
    {
        wile(x->left != 0){
            x = x->left;
        }
        return x;
    }
    static base_ptr maximum(base_ptr x)
    {
        while(x->right != 0){
            x = x->right;
        }
        return x;
    }
};

template<class Value>
struct __rb_tree_node : public __rb_tree_node_base
{
    typedef __rb_tree_node<Value>* link_type;
    Value value_field;
};

//因为红黑树是非线性的结构，所以要找到一个节点的前面的节点或者后面的节点比较麻烦，且红黑树节点的显示是

//按中序排列的，所以对迭代器的前进和后退操作要借用内置函数increment()和decrement()

//RB_tree迭代器结构设计，也是采用双层迭代其结构
struct __rb_base_iterator
{
    typedef __rb_tree_node_base::base_ptr base_ptr;
    typedef bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t difference_type;
    base_ptr node;
    //迭代器的前进操作operator++()调用了基层迭代器的increment()
    //(1)如果node有右子树，但这个右子树没有左子节点，那么node前进一个节点为node->right.如果这个右子   树有左子树，那么node后面的节点就是这个左子树的最左边的那个节点。
    //(2)如果node没有右子树，并且node是node->parent的左子树，那么node后面的节点是node->parent。如果node是node->parent的右子树，则一直上朔，直到不再是右子节点比如为y，那么node后面的节点是就是y->parent这个节点
    void increment()
    {
        if(node->right != 0){
            node = node->right;
            while(node->left != 0){
                node = node->left;
            }
        }
        else{
            base_ptr y = node->parent;
            while(node == y->right){
                node = y;
                y = y->parent;
            }
            if(node->right != y){
                node = y;
            }
        }
    }
    //迭代器的后退操作operator--()调用基层迭代器ecrement()
    //(1)node有左子树，且node的左子树没有右子树，那么node前面的节点就是node->left。如果node的左子树有右子树，那么node前面的节点就是这个右子树的最右边的节点。
    //(2)node没有左子树，且node为其父节点的左节点，那么就上朔直到node不为node->parent的左节点，那么node的前面的节点就是这个node->parent。如果为其父节点的右节点，那么node的前面的节点就是node->parent。
    void decrement()
    {
       //判断node就是header这个虚节点
        if(node->color == __rb_tree_red && node->parent->parent == node){
            node = node->right;
        }
        else if(node->left != 0){
            base_ptr y = node->left;
            while(y->right != 0){
                y = y->right;
            }
            node = y;
        }
        else{
            base_ptr y = node->parent;
            while(node == y->left){
                node = y;
                y = y->parent;
            }
            node = y;
        }  
    }
};

template<calss Value, class Ref, class Ptr>
struct __ rb_tree_iterator : public __rb_tree_base_iterator
{
     typedef Value value_type;
     typedef Ref reference;
     typedef Ptr pointer;
     typedef __rb_tree_iterator<Value, Value&, Value*>             iterator;
     typedef __rb_tree_iterator<Value, const Value&, const Value*> const_iterator;
     typedef __rb_tree_iterator<Value, Ref, Ptr>                   self;
     typedef __rb_tree_node<Value>* link_type;

    __rb_tree_iterator(){}
    __rb_tree_iterator(link_type x){node = x;}
    __rb_tree_iterator(const iterator& it){ode = it.node;}

    self& operator++() { increment(); return *this; }
    self operator++(int) {
        self tmp = *this;
        increment();
        return tmp;
    }
    
    self& operator--() { decrement(); return *this; }
    self operator--(int) {
        self tmp = *this;
        decrement();
        return tmp;
    }
};

inline bool operator==(const __rb_tree_base_iterator& x,
                       const __rb_tree_base_iterator& y)
{
   return x.node == y.node;
}

inline bool operator!=(const __rb_tree_base_iterator& x,
                       const __rb_tree_base_iterator& y)
{
   return x.node != y.node;
}
//RB_tree数据结构
template <class Key, class Value, class KeyOfValue, class Compare,
          class Alloc = alloc>
class rb_tree {
protected:
  typedef void* void_pointer;
  typedef __rb_tree_node_base* base_ptr;
  typedef __rb_tree_node<Value> rb_tree_node;
  typedef simple_alloc<rb_tree_node, Alloc> rb_tree_node_allocator;
  typedef __rb_tree_color_type color_type;
public:
  typedef Key key_type;
  typedef Value value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef rb_tree_node* link_type;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
public:
    rb_tree(const Compare& comp = Compare())
    : node_count(0), key_compare(comp) { init(); }

    ~rb_tree() {
        clear();
        put_node(header);
    }
    rb_tree<Key, Value, KeyOfValue, Compare, Alloc>&
    operator=(const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x);
protected:
    get_node(){return rb_tree_node_allocator::allocate();}
    void put_node(link_type p) { rb_tree_node_allocator::deallocate(p); }

    link_type create_node(const value_type& x) {
        link_type tmp = get_node();
        put_node(tmp);
        return tmp;
    }
    //复制一个节点
    link_type clone_node(link_type x) {
        link_type tmp = create_node(x->value_field);
        tmp->color = x->color;
        tmp->left = 0;
        tmp->right = 0;
        return tmp;
    }

    void destroy_node(link_type p) {
        destroy(&p->value_field);
        put_node(p);
    }

protected:
    size_type node_count; // keeps track of size of tree
    link_type header;  
    Compare key_compare;
    //这三个函数方便取得header的成员
    link_type& root() const { return (link_type&) header->parent; }
    //取得最左边的节点
    link_type& leftmost() const { return (link_type&) header->left; }
    //取得最右边的节点
    link_type& rightmost() const { return (link_type&) header->right; }
    //这六个函数方便取得节点x的成员（自身做参数）自己对这12个函数没有具体搞明白为什么写两种
    static link_type& left(link_type x) { return (link_type&)(x->left); }
    static link_type& right(link_type x) { return (link_type&)(x->right); }
    static link_type& parent(link_type x) { return (link_type&)(x->parent); }
    static reference value(link_type x) { return x->value_field; }
    static const Key& key(link_type x) { return KeyOfValue()(value(x)); }
    static color_type& color(link_type x) { return (color_type&)(x->color); }
    //这六个函数方便取得节点x的成员（以父类类型的节点做参数）
    static link_type& left(base_ptr x) { return (link_type&)(x->left); }
    static link_type& right(base_ptr x) { return (link_type&)(x->right); }
    static link_type& parent(base_ptr x) { return (link_type&)(x->parent); }
    static reference value(base_ptr x) { return ((link_type)x)->value_field; }
    static const Key& key(base_ptr x) { return KeyOfValue()(value(link_type(x)));}
    static color_type& color(base_ptr x) { return (color_type&)(link_type(x)->color); }

    static link_type minimum(link_type x) {
      return (link_type)  __rb_tree_node_base::minimum(x);
    }
    static link_type maximum(link_type x) {
      return (link_type) __rb_tree_node_base::maximum(x);
    }

public:
    typedef __rb_tree_iterator<value_type, reference, pointer> iterator;
    typedef __rb_tree_iterator<value_type, const_reference, const_pointer>
          const_iterator;

public:
    Compare key_comp()const {return key_compare;}
    iterator begin(){return leftmost;}
    //最后的一个节点应该是rightmost但是end()指向的是最后节点的后一个节点自然就是header
    iterator end(){return header;}
    bool empty()const{return node_count == 0;}
    size_type size()const{return node_count;}
    size_type max_size()const{return size_type(-1);}
public:
    pair<iterator, bool>insert_unique(const value_type& x);
    iterator insert_equal(const value_type& x);
    iterator insert_unique(iterator position, const value_type& x);
    iterator insert_equal(iterator position, const value_type& x);

};
//这里的返回值是个RB_tree迭代器，所以前面加那么多
template<class Key, class Value, class KeyOfValue, class Compare, class Alloc>
typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator
rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::insert_equal(const value& v)
{
    link_type y = header;
    link_type x = root();
    while(x != 0){
        y = x;
        x = key_compare(KetOfValue()(v), key(x)) ? left(x):right(x);
    }
    //x为新插入节点，Y为插入的父节点，v为插入的新值
    return __insert(x, y, v);
}


template<class Key, class Value, class KeyOfValue, class Compare, class Alloc>
//注意这一行，返回值是pair类型，pair称为对组，这样写则返回值不返回一个值，而是返回两个值，这里可以看出返回的
//第一个值是iterator类型，即返回插入点的位置。返回的第二个值是bool类型，通过true或者false来判断插入是否成功
pair<typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator, bool>
rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::insert_unique(const value_type& v)
{
    link_type y = header;
    link_type x = root();
    bool comp = true;
    //从根节点开始查找适当的插入点
    while(x != 0){
        y = x;
        comp = key_compare(KeyOfValue()(v), key(y));
        //当插入的元素v<找到的插入点即y，则v往y的左边插入，否则右边
        x = comp ? left(x) : right(x);
    }
    //这里大家要注意理解，画图可以最直观的分析，这里自己也是看了好久才弄明白
    //下面的代码的作用是防止插入值重复。
    //分两种情况
    //（1）如果插入点的父节点是树的最左边节点，那么直接插入
    //（2）如果插入点的父节点不是树的最左边的节点，这个时候要考虑到插入的新节点
    //     是否可能跟已经插入的节点值重复，因此要进行回朔
    iterator j = iterator(y);
    //if(com)为真，也就是说当v<y，往左节点插入新值
    if(comp){
        if(j === begin()){
            return pair<iterator, bool>(__insert(x, y, v), true);
        }else{
            --j;
        }   
    }
    //满足这个条件即表示新插入的键值不与已经插入的节点的键值相等
    if(key_compare(key(j.node), KeyOfValue()(v))){
        return pair<iterator, bool>(__insert(x, y, v), true);
    }
    //键值重复不进行插入操作
    return pair<iterator, bool>(__insert(j, false);
}

template<class Key, class Value, class KeyOfValue, class Compare, class Alloc>
typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator
rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::__insert(base_ptr x_, base_type y_,  const value_type& v)
{
    link_type x = (link_type)x_;
    link_type y = (link_type)y_;
    link_type z;
    //当key_compare(KeyOfValue()(v), keyy(y))为真时，也就是说v<y,往y的左节点插入，分3种情况
    //（1）y==header,插入的节点是root，这样就要注意要让root()=插入的节点，并且让header的左指针指向插入节点
    //即leftmost()=z
    //（2）y==leftmost,插入的地方是树的最左边的节点，注意的是要让header的左指针指向这个插入节点即leftmost()=z
    //（3）插入的仅仅是个普通的节点，直接让父节点y的左指针指向这个插入的节点即可
    if(y == header || x != 0 || key_compare(KeyOfValue()(v), key(y))){
        z = create_node(v);
        //让leftmost() = z
        left(y) = z;
        //如果插入的节点是root节点，则让root作为header的左子节点
        if(y == header){
            root() = z;
            rightmost = z;
        //如果插入的地方是树的最左边的节点
        }else if(y == leftmost()){
            leftmost() = z;
        }
    }
    //当key_compare(KeyOfValue()(v), key(y))为假时，也就是说v>y,(注意这里规定的默认的key_compare规则是小与)
    //往插入点的父节点y的右节点插入，分1种情况
    //这里不用判断插入点为root节点，因为规定root节点只能作为header的左子节点插入
    else{
        z = create_node(v);
        right(y) = z;
        if(y == rightmost()){
            rightmost() = z;
        }
    }
    //设置新插入节点的父节点和左右节点
    parent(z) = y;
    left(z) = 0;
    right(z) = 0;
    //插入节点后记得要重新调整平衡和颜色
    __rb_tree_rebalance(z, header->parent);
    ++node_count;
    return iteratro(z);
}
//红黑树的旋转以及颜色的调整比较麻烦，所以大家要静下心来
//一：当插入点的父节点为祖父节点的左子树：
//    （1）如果伯父节点存在且为红
//    （2）如果伯父节点不存在或者为黑，
//         （1）则又要判断插入节点为父节点的左子树
//         （2）插入节点为父节点的右子树
//二：当插入点的父节点为祖父节点的右子树
//    （1）如果伯父节点存在且为红
//    （2）如果伯父节点不存在或者为黑
//         （1）插入点为父节点的左子树
//         （2）插入点为父节点的右子树
inline void __rb_tree_rebalance(__rb_tree_node_base* x, __rb_tree_node_base*& root)
{
    //新插入的节点必须为红节点，因为如果插入的新节点为黑节点，这样就打破了红黑树的约束条件
    //红黑树要求任一节点到NULL的任何的路径，所含之黑节点数目必须相等
    x->color = rb_tree_red;
    while(x != root && x->parent->color == rb_tree_red){
        //插入的父节点为祖父节点的左子树
        if(x->parent == x->parent->parent->left){
            //伯父节点存在且为红
            __rb_tree_node_base* y = x->parent->parent->right;
            if(y && y->color == __rb_tree_red){
                x->parent->color = __rb_tree_black;
                y->color = __rb_tree_black;
                x->parent->parent = __rb_tree_red;
                x = x->parent->parent;
            }
            //伯父节点不存在或者为黑
            else{
                if(x == x->parent->right){
                    x = x->parent;
                    __rb_tree_rotate_left(x, root);
                }
                x->parent->color = __rb_tree_black;
                x->parent->parent->color = __rb_tree_red;
                __rb_tree_rotate_right(x->parent->parent, root);
            }
        }
        //插入的节点的父节点为祖父节点的右子树
        else{
            //伯父节点存在且为红
            __rb_tree_node_base* y =x->parent->parent->left;
            if(y && y->color == __rb_tree_red){
                x->parent->color = __rb_tree_black;
                y->color = __rb_tree_black;
                x->parent->parent->color = __rb_tree_red;
                x = x->parent->parent;
            }
            //伯父节点不存在或者为黑
            else{
                if(x == x->parent->left){
                    x = x->parent;
                    __rb_tree_rotate_right(x, root);
                }
                x->parent->color = __rb_tree_black;
                x->parent->parent->color = __rb_tree_red;
                __rb_tree_rotate_left(x->parent->parent, root);
            }
        }
    }
    //根节点永远为黑
    root->color = __rb_tree_black;
}
//下面两个函数是红黑树节点的旋转
//x为旋转对象
//红黑树的旋转根AVL树的旋转一样，只是由于红黑树的节点又parent这个指针，所以旋转的时后要特别的注意这个指针的连接
//左旋：
//（1）将旋转目标x的右子节点Y的左子树挂在x的右子树上，
//（2）将y树挂在x的父节点上，
//（3）将y的左指针指向x；
//
inline void __rb_tree_rotate_left(__rb_tree_node_base* x, __rb_tree_node_base*& root)
{
    __rb_tree_node_base* y = x->right;
    x->right = y->left;
    if(y->left != 0){
        y->left->parent = x;
    }
    y->parent = x->parent;
    if(x == root){
        root = y;
    }
    else if(x == x->parent->left){
        x->parent->left = y;
    }
    else{
        x->parent->right = y;
    }
    y->left = x;
    x->parent = y;
}
//右旋：
//（1）将旋转目标x的左子树y的右子树挂在x的左链上
//（2）将y树挂在x的父节点上
//（3）将x树挂在y的右链上
inline void __rb_tree_rotate_right(__rb_tree_node_base* x, __rb_tree_node_base*& root)
{
    __rb_tree_node_base* y = x->right;
    x->left = y->right;
    if(y->right != 0){
        y->right->parent = x;
    }
    y->parent = x->parent;
    if(x == root){
        root = y;
    }
    else if(x == x->parent->left){
        x->parent->left = y;
    }else{
        x->parent->right = y;
    }
    y->right = x;
    x->parent = y;
    
}

};
#endif

 /