STL学习——RB-tree篇

STL学习——RB-tree篇

• 简介

  RB-tree（红黑树）是一棵平衡二叉搜索树，它需要满足以下规则：

  1）每个节点不是红色就是黑色；

  2）根节点为黑色；

  3）如果节点为红，其子节点必须为黑；

  4）任一节点至NULL（树尾端）的任何路径，所含之黑节点数必须相同。

• 插入

  依据红黑树的性质4）可以，在红黑树中插入节点，新插入的节点必须为红。插入节点后，可能会破坏红黑树的性质，此时需调整红黑树节点颜色或者旋转红黑树，使其满足红黑树的性质。

  红黑树插入新节点后主要涉及以下四种情况：

  1）伯父节点为黑，且新插入节点为外侧插入。对此情况，需先对父节点，祖父节点做一次单旋转，并更改父节点与祖父节点，即可重新满足红黑树规则3）。

  2）伯父节点为黑，且新插入节点为内测插入。对此情况，必须先对父节点，新插入节点做一次单旋转并更改祖父节点和新插入节点的颜色，再将结果对祖父节点做一次单旋转，即可再次满足红黑树规则3）。

  3）伯父节点为红，且新插入节点为外侧插入。对此情况，先对父节点和祖父节点做一次单旋转，并改变新插入节点的颜色。如果此时曾祖父节点为黑，则一切搞定，如果曾祖父节点为红，则考虑情况4）。

  4）伯父节点为红，且新插入节点为外侧插入。对此情况，先对父节点和祖父节点做一次单旋转，并改变新插入节点的颜色。如果此时曾祖父节点为红，则需持续向上做，直到不再有父子节点连续为红的情况。

• 由上而下的程序

  为避免插入时出现情况4，可以施行一个由上而下的程序：假设新增节点为A，那么就沿着A的路径，只要看到有某节点X的两个子节点皆为红色，就把X改为红色，并把两个子节点改为黑色。但如果X的父节点P也为红色，就需要像插入的情况1）一样，做一次单旋转并改变颜色，或是像情况2）一样地做一次双旋转并改变颜色。之后，节点插入就很单纯：要么直接插入，要么插入后在做一次旋转即可。

• RB-tree节点设计

  RB-tree有红黑两种颜色，并拥有左右子节点，其实现利用双层结构。因RB-tree中一些操作涉及到上溯其父节点，所以数据结构中安排了一个parent指针。其具体设计如下：

  typedef bool _Rb_tree_Color_type;
  const _Rb_tree_Color_type _S_rb_tree_red = false;    // 红色0
  const _Rb_tree_Color_type _S_rb_tree_black = true;   // 黑色1
  // RB-tree的节点设计
  // RB-tree基层节点
  struct _Rb_tree_node_base
  {
    typedef _Rb_tree_Color_type _Color_type;   // 颜色类型
    typedef _Rb_tree_node_base* _Base_ptr;     // 基指针类型
  
    _Color_type _M_color;                      // 节点颜色
    _Base_ptr _M_parent;                       // RB树的许多操作，必须知道父节点
    _Base_ptr _M_left;                         // 指向左节点
    _Base_ptr _M_right;                        // 指向右节点
  
    // 求最小值
    static _Base_ptr _S_minimum(_Base_ptr __x)
    {
      while (__x->_M_left != 0) __x = __x->_M_left;    // 一直向左走，就会找到最小值
      return __x;
    }
  
    // 求最大值
    static _Base_ptr _S_maximum(_Base_ptr __x)
    {
      while (__x->_M_right != 0) __x = __x->_M_right;  // 一直向右走，就会找到最大值
      return __x;
    }
  };
  // Rb-tree节点
  template <class _Value>
  struct _Rb_tree_node : public _Rb_tree_node_base
  {
    typedef _Rb_tree_node<_Value>* _Link_type;
    _Value _M_value_field;
  };
  

• RB-tree迭代器

  RB-tree实现一个泛型容器，其迭代器设计是关键。主要考虑迭代器的类别，前进，后退，提领，成员访问等操作。它的迭代器设计也是双层结构。使用双向迭代器，但不具有随机定位能力。其前进和后退操作，利用基层迭代器的前进和后退操作实现。下面是对这部分源码的分析。

  // 基层迭代器
  struct _Rb_tree_base_iterator
  {
    typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
    typedef bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t difference_type;
    _Base_ptr _M_node;   // 用来与容器之间产生一个连结关系
  
    // operator++
    void _M_increment()
    {
      if (_M_node->_M_right != 0) {            // 如果有右子节点 
        _M_node = _M_node->_M_right;           // 就向右走
        while (_M_node->_M_left != 0)          // 然后一直往左子树走到底
          _M_node = _M_node->_M_left;
      }
      else {                                   // 没有右子节点
        _Base_ptr __y = _M_node->_M_parent;    // 找出父节点
        while (_M_node == __y->_M_right) {     // 如果现行节点本身是个右子节点
          _M_node = __y;                       // 就一直上溯，直到“不为右子节点”止
          __y = __y->_M_parent;
        }
        if (_M_node->_M_right != __y)          // 若此时的右子节点不等于此时的父节点
          _M_node = __y;                       // 此时的父节点即为解答
                                               // 否则此时的node为解答。
      }
      // 注意：以上判断“若此时的右子节点不等于此时的父节点”，是为了应付一种特殊情况：
      // 我们欲寻找根节点的下一节点，而恰巧根节点无右子节点，当然，以上特殊做法必须
      // 配合RB-tree根节点与特殊之header之间的特殊情况。
    }
    // operator--
    void _M_decrement()
    {
      if (_M_node->_M_color == _S_rb_tree_red &&      // 如果是红节点，且
          _M_node->_M_parent->_M_parent == _M_node)   // 父节点的父节点等于自己
        _M_node = _M_node->_M_right;                  // 右子节点即为解答
      // 以上情况发生于node为header时（即node为end()是）
      // 注意，header之右子节点即mostright，指向整棵树的max节点
      else if (_M_node->_M_left != 0) {               // 如果有左子节点 
        _Base_ptr __y = _M_node->_M_left;             // 令y指向左子节点
        while (__y->_M_right != 0)                    // 当y有右子节点时
          __y = __y->_M_right;                        // 一直往右子节点走到底
        _M_node = __y;                                // 最后即为答案
      }
      else {                                          // 既非根节点，亦无左子节点
        _Base_ptr __y = _M_node->_M_parent;           // 找出父节点
        while (_M_node == __y->_M_left) {             // 当现行节点身为左子节点
          _M_node = __y;                              // 一直交替往上走，直到现行节点
          __y = __y->_M_parent;                       // 不为左子节点
        }
        _M_node = __y;                                // 此时父节点即为答案
      }
    }
  };
  // Rb-tree迭代器
  template <class _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) { _M_node = __x; }
    _Rb_tree_iterator(const iterator& __it) { _M_node = __it._M_node; }
  
    reference operator*() const { return _Link_type(_M_node)->_M_value_field; }
  #ifndef __SGI_STL_NO_ARROW_OPERATOR
    pointer operator->() const { return &(operator*()); }
  #endif /* __SGI_STL_NO_ARROW_OPERATOR */
    // 后++操作
    _Self& operator++() { _M_increment(); return *this; }
    // 前++操作
    _Self operator++(int) {
      _Self __tmp = *this;
      _M_increment();
      return __tmp;
    }
    // 后--操做   
    _Self& operator--() { _M_decrement(); return *this; }
    // 先--操作
    _Self operator--(int) {
      _Self __tmp = *this;
      _M_decrement();
      return __tmp;
    }
  };
  

• RB-tree数据结构及构造

  RB-tree定义中，有专属的空间配置器，每次用来配置一个节点大小，也可以看到各种型别定义，用来维护整棵RB-tree的数据。RB-tree的构造方式有两种：1）以现有的RB-tree复制一个新的RB-tree；2）产生一棵空树，然后将节点依次插入到树中。具体如下源码：

  // RB_tree定义
  template <class _Key, class _Value, class _KeyOfValue, class _Compare,
            class _Alloc = __STL_DEFAULT_ALLOCATOR(_Value) >
  class _Rb_tree : protected _Rb_tree_base<_Value, _Alloc> {
    typedef _Rb_tree_base<_Value, _Alloc> _Base;
  protected:
    typedef _Rb_tree_node_base* _Base_ptr;
    typedef _Rb_tree_node<_Value> _Rb_tree_node;
    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;
  
    typedef typename _Base::allocator_type allocator_type;
    allocator_type get_allocator() const { return _Base::get_allocator(); }
  
  protected:
  #ifdef __STL_USE_NAMESPACES
    using _Base::_M_get_node;
    using _Base::_M_put_node;
    using _Base::_M_header;
  #endif /* __STL_USE_NAMESPACES */
  
  protected:
  
    _Link_type _M_create_node(const value_type& __x)
    {
      _Link_type __tmp = _M_get_node();           // 配置空间
      __STL_TRY {
        construct(&__tmp->_M_value_field, __x);   // 构造内容  
      }
      __STL_UNWIND(_M_put_node(__tmp));          
      return __tmp;
    }
  
    _Link_type _M_clone_node(_Link_type __x)      // 复制一个节点（的值和色）
    {
      _Link_type __tmp = _M_create_node(__x->_M_value_field);   
      __tmp->_M_color = __x->_M_color;
      __tmp->_M_left = 0;
      __tmp->_M_right = 0;
      return __tmp;
    }
  
    void destroy_node(_Link_type __p)
    {
      destroy(&__p->_M_value_field);              // 释放内容
      _M_put_node(__p);                           // 释放内存
    }
  
  protected:
    size_type _M_node_count; // keeps track of size of tree  追踪记录树的大小（节点数量）
    _Compare _M_key_compare; // 节点间的键值大小比较准则。应该是个function object
  
    // 以下三个函数用来方便取得header的成员
    _Link_type& _M_root() const 
      { return (_Link_type&) _M_header->_M_parent; }
    _Link_type& _M_leftmost() const 
      { return (_Link_type&) _M_header->_M_left; }
    _Link_type& _M_rightmost() const 
      { return (_Link_type&) _M_header->_M_right; }
  
    // 以下六个函数用来方便取得节点x的成员
    static _Link_type& _S_left(_Link_type __x)
      { return (_Link_type&)(__x->_M_left); }
    static _Link_type& _S_right(_Link_type __x)
      { return (_Link_type&)(__x->_M_right); }
    static _Link_type& _S_parent(_Link_type __x)
      { return (_Link_type&)(__x->_M_parent); }
    static reference _S_value(_Link_type __x)
      { return __x->_M_value_field; }
    static const _Key& _S_key(_Link_type __x)
      { return _KeyOfValue()(_S_value(__x)); }
    static _Color_type& _S_color(_Link_type __x)
      { return (_Color_type&)(__x->_M_color); }
    // 以下六个函数用来方便取得节点x的成员
    static _Link_type& _S_left(_Base_ptr __x)
      { return (_Link_type&)(__x->_M_left); }
    static _Link_type& _S_right(_Base_ptr __x)
      { return (_Link_type&)(__x->_M_right); }
    static _Link_type& _S_parent(_Base_ptr __x)
      { return (_Link_type&)(__x->_M_parent); }
    static reference _S_value(_Base_ptr __x)
      { return ((_Link_type)__x)->_M_value_field; }
    static const _Key& _S_key(_Base_ptr __x)
      { return _KeyOfValue()(_S_value(_Link_type(__x)));} 
    static _Color_type& _S_color(_Base_ptr __x)
      { return (_Color_type&)(_Link_type(__x)->_M_color); }
    // 求取极大值和极小值。
    static _Link_type _S_minimum(_Link_type __x) 
      { return (_Link_type)  _Rb_tree_node_base::_S_minimum(__x); }
  
    static _Link_type _S_maximum(_Link_type __x)
      { return (_Link_type) _Rb_tree_node_base::_S_maximum(__x); }
  
  public:
    typedef _Rb_tree_iterator<value_type, reference, pointer> iterator;
    typedef _Rb_tree_iterator<value_type, const_reference, const_pointer> 
            const_iterator;
  
  #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
    typedef reverse_iterator<const_iterator> const_reverse_iterator;
    typedef reverse_iterator<iterator> reverse_iterator;
  #else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
    typedef reverse_bidirectional_iterator<iterator, value_type, reference,
                                           difference_type>
            reverse_iterator; 
    typedef reverse_bidirectional_iterator<const_iterator, value_type,
                                           const_reference, difference_type>
            const_reverse_iterator;
  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ 
  
  private:
    iterator _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
    _Link_type _M_copy(_Link_type __x, _Link_type __p);
    void _M_erase(_Link_type __x);
  
  public:
                                  // allocation/deallocation
    _Rb_tree()
      : _Base(allocator_type()), _M_node_count(0), _M_key_compare()
      { _M_empty_initialize(); }
  
    _Rb_tree(const _Compare& __comp)
      : _Base(allocator_type()), _M_node_count(0), _M_key_compare(__comp) 
      { _M_empty_initialize(); }
  
    _Rb_tree(const _Compare& __comp, const allocator_type& __a)
      : _Base(__a), _M_node_count(0), _M_key_compare(__comp) 
      { _M_empty_initialize(); }
  
    _Rb_tree(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x) 
      : _Base(__x.get_allocator()),
        _M_node_count(0), _M_key_compare(__x._M_key_compare)
    { 
      if (__x._M_root() == 0)
        _M_empty_initialize();
      else {
        _S_color(_M_header) = _S_rb_tree_red;
        _M_root() = _M_copy(__x._M_root(), _M_header);
        _M_leftmost() = _S_minimum(_M_root());
        _M_rightmost() = _S_maximum(_M_root());
      }
      _M_node_count = __x._M_node_count;
    }
    ~_Rb_tree() { clear(); }
    _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& 
    operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x);
  
  private:
    void _M_empty_initialize() {
      _S_color(_M_header) = _S_rb_tree_red; // used to distinguish header from 
      // 令head为红色，用来区分header和root，在Iterator.operator--之中 // __root, in iterator.operator++
      _M_root() = 0;                        
      _M_leftmost() = _M_header;            // 令header的左子节点为自己
      _M_rightmost() = _M_header;           // 令header的右子节点为自己
    }
  
  public:    
                                  // accessors:
    _Compare key_comp() const { return _M_key_compare; }
    iterator begin() { return _M_leftmost(); }               // RB-tree树的起头最左（最小）节点处
    const_iterator begin() const { return _M_leftmost(); }
    iterator end() { return _M_header; }                     // RB-tree树的终点为header所指出
    const_iterator end() const { return _M_header; }
    reverse_iterator rbegin() { return reverse_iterator(end()); }
    const_reverse_iterator rbegin() const { 
      return const_reverse_iterator(end()); 
    }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const { 
      return const_reverse_iterator(begin());
    } 
    bool empty() const { return _M_node_count == 0; }
    size_type size() const { return _M_node_count; }
    size_type max_size() const { return size_type(-1); }
  
    void swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __t) {
      __STD::swap(_M_header, __t._M_header);
      __STD::swap(_M_node_count, __t._M_node_count);
      __STD::swap(_M_key_compare, __t._M_key_compare);
    }
  
  public:
                                  // insert/erase
    // 将x插入到RB-tree中（保持节点值独一无二）
    pair<iterator,bool> insert_unique(const value_type& __x);
    // 将x插入到RB-tree中（允许节点值重复）
    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);
  
  #ifdef __STL_MEMBER_TEMPLATES  
    template <class _InputIterator>
    void insert_unique(_InputIterator __first, _InputIterator __last);
    template <class _InputIterator>
    void insert_equal(_InputIterator __first, _InputIterator __last);
  #else /* __STL_MEMBER_TEMPLATES */
    void insert_unique(const_iterator __first, const_iterator __last);
    void insert_unique(const value_type* __first, const value_type* __last);
    void insert_equal(const_iterator __first, const_iterator __last);
    void insert_equal(const value_type* __first, const value_type* __last);
  #endif /* __STL_MEMBER_TEMPLATES */
  
    void erase(iterator __position);
    size_type erase(const key_type& __x);
    void erase(iterator __first, iterator __last);
    void erase(const key_type* __first, const key_type* __last);
    void clear() {
      if (_M_node_count != 0) {
        _M_erase(_M_root());
        _M_leftmost() = _M_header;
        _M_root() = 0;
        _M_rightmost() = _M_header;
        _M_node_count = 0;
      }
    }      
  
  public:
                                  // set operations:
    iterator find(const key_type& __x);
    const_iterator find(const key_type& __x) const;
    size_type count(const key_type& __x) const;
    iterator lower_bound(const key_type& __x);
    const_iterator lower_bound(const key_type& __x) const;
    iterator upper_bound(const key_type& __x);
    const_iterator upper_bound(const key_type& __x) const;
    pair<iterator,iterator> equal_range(const key_type& __x);
    pair<const_iterator, const_iterator> equal_range(const key_type& __x) const;
  
  public:
                                  // Debugging.
    bool __rb_verify() const;
  };
  

• RB-tree的元素操作**

  RB-tree主要提供两种操作：insert_unique()和insert_equal()，前者表示被插入节点的键值在整棵树中必须独一无二（如果树中存在相同的键值，插入操作就不会真正的进行），后者表示被插入节点的键值在整棵树中可以重复，故无论如何插入都会成功（除非空间不足导致配置失败）。下面是对插入操作的源码分析：

  // 元素插入操作
  // 插入新值：节点键值允许重复
  // 注意：返回值是一个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 = _M_header;      
    _Link_type __x = _M_root();                                 // 从根节点开始
    while (__x != 0) {                                          // 从根节点开始，往下寻找适当的插入点
      __y = __x;
      __x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ? 
              _S_left(__x) : _S_right(__x);                     // 以上，遇“大”则往左，遇“小于或等于”则往右
    }
    return _M_insert(__x, __y, __v);                            // x为新值插入点，y为新值插入点之父节点，v为新值
  }
  
  // 插入新值：节点键值不允许重复，若重复则插入无效
  // 注意，返回值是个pair，第一个元素是个Rb-tree迭代器，指向新增节点，第二个元素表示插入成功与否
  template <class _Key, class _Value, class _KeyOfValue, 
            class _Compare, class _Alloc>
  pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator, 
       bool>
  _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
    ::insert_unique(const _Value& __v)
  {
    _Link_type __y = _M_header;
    _Link_type __x = _M_root();                                 // 从根节点开始
    bool __comp = true;
    while (__x != 0) {                                          // 从根节点开始，往下寻找适当的插入点
      __y = __x;
      __comp = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)); // v键值小于目前节点值键值?
      __x = __comp ? _S_left(__x) : _S_right(__x);              // 遇“大”则往左，遇“小于或等于”则往右
    }
    // 离开while循环之后，y所指即插入点之父节点（此时的它必为叶节点）
    iterator __j = iterator(__y);                               // 令迭代器j指向插入点之父节点y   
    if (__comp)
      if (__j == begin())                                       // 如果插入点之父节点为最左节点     
        return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
        // 以上，x为插入点，y为插入点之父节点，v为新值
      else                                                      // 否则（插入点之父节点不为最左节点）
        --__j;                                                  // 调整j，回头准备测试...
    if (_M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
      // 新键值不与既有节点之键值重复，于是以下执行安插操作
      return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
      // 以上，x为新值插入点，y为插入点之父节点，v为新值
      // 进行至此，表示新值一定与树中键值重复，那么就不该插入新值
    return pair<iterator,bool>(__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>
    ::_M_insert(_Base_ptr __x_, _Base_ptr __y_, const _Value& __v)
  {
    // 参数值x为新值插入点，参数值y为插入点之父节点，参数v为新值
    _Link_type __x = (_Link_type) __x_;
    _Link_type __y = (_Link_type) __y_;
    _Link_type __z;
    // key_compare是键值大小比较准则。应该会是个function object
    if (__y == _M_header || __x != 0 || 
        _M_key_compare(_KeyOfValue()(__v), _S_key(__y))) {
      __z = _M_create_node(__v);        // 产生一个新节点
      // 这使得当y即为header时，leftmost() = z
      _S_left(__y) = __z;               // also makes _M_leftmost() = __z 
                                        //    when __y == _M_header
      if (__y == _M_header) {
        _M_root() = __z;
        _M_rightmost() = __z;
      }
      else if (__y == _M_leftmost())    // 如果y为最左节点，维护leftmost()，使它永远指向最左节点 
        _M_leftmost() = __z;   // maintain _M_leftmost() pointing to min node
    }
    else {
      __z = _M_create_node(__v);        // 产生一个新节点
      _S_right(__y) = __z;              // 令新节点成为插入点之父节点y的右子节点
      if (__y == _M_rightmost())
        _M_rightmost() = __z;           // maintain _M_rightmost() pointing to max node
                                        // 维护rightmost()，使它永远指向最右节点
    }
    _S_parent(__z) = __y;               // 设定新节点的父节点
    _S_left(__z) = 0;                   // 设定新节点的左子节点
    _S_right(__z) = 0;                  // 设定新节点的右子节点
                                        // 新节点的颜色将在Rb_tree_rebalance()设定（并调整）
    _Rb_tree_rebalance(__z, _M_header->_M_parent);   // 参数一为新增节点，参数二为root  
    ++_M_node_count;                    // 节点数累加
    return iterator(__z);               // 返回一个迭代器，指向新增节点
  }
  

• 调整RB-tree（旋转及改变颜色）

  // 全局函数
  // 重新令树形平衡（改变颜色及旋转树形）
  // 参数一为新增节点，参数二为root
  inline void 
  _Rb_tree_rebalance(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
  {
    __x->_M_color = _S_rb_tree_red;                                          // 新节点必为红
    while (__x != __root && __x->_M_parent->_M_color == _S_rb_tree_red) {    // 父节点为红
      if (__x->_M_parent == __x->_M_parent->_M_parent->_M_left) {            // 父节点为祖父节点之左子节点
        _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_right;       // 令y为伯父节点
        if (__y && __y->_M_color == _S_rb_tree_red) {                        // 伯父节点存在，且为红
          __x->_M_parent->_M_color = _S_rb_tree_black;                       // 更改父节点为黑
          __y->_M_color = _S_rb_tree_black;                                  // 更改伯父节点为黑
          __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;              // 更改祖父节点为红
          __x = __x->_M_parent->_M_parent;
        }
        else {                                                               // 无伯父节点，或伯父节点为黑
          if (__x == __x->_M_parent->_M_right) {
            __x = __x->_M_parent;
            _Rb_tree_rotate_left(__x, __root);                               // 第一个参数为左旋点
          }
          __x->_M_parent->_M_color = _S_rb_tree_black;                       // 改变颜色
          __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
          _Rb_tree_rotate_right(__x->_M_parent->_M_parent, __root);          // 第一个参数为右旋点
        }
      }
      else {                                                                 // 父节点为祖父节点之右子节点
        _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left;        // 令y为伯父节点
        if (__y && __y->_M_color == _S_rb_tree_red) {                        // 有伯父节点，且为红
          __x->_M_parent->_M_color = _S_rb_tree_black;                       // 更改父节点为黑
          __y->_M_color = _S_rb_tree_black;                                  // 更改伯父节点为黑
          __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;              // 更改祖父节点为红
          __x = __x->_M_parent->_M_parent;                                   // 准备继续往上层检查
        }
        else {                                                               // 无伯父节点，或伯父节点为黑
          if (__x == __x->_M_parent->_M_left) {                              // 如果新节点为父节点之左子节点
            __x = __x->_M_parent;
            _Rb_tree_rotate_right(__x, __root);                              // 第一参数为右旋点
          }
          __x->_M_parent->_M_color = _S_rb_tree_black;                       // 改变颜色
          __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
          _Rb_tree_rotate_left(__x->_M_parent->_M_parent, __root);           // 第一个参数为左旋点
        }
      }
    }
    __root->_M_color = _S_rb_tree_black;                                     // 根节点永远为黑
  }
  
  // 全局函数
  // 新节点必为红节点。如果插入之处父节点亦为红节点，就违反红黑树规则，此时可能需要
  // 做树形旋转（及颜色改变，在程序它处）
  inline void 
  _Rb_tree_rotate_left(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
  {
    // x为旋转点
    _Rb_tree_node_base* __y = __x->_M_right;   // y为旋转点的右子节点
    __x->_M_right = __y->_M_left;
    if (__y->_M_left !=0)                 
      __y->_M_left->_M_parent = __x;           // 回设父节点
    __y->_M_parent = __x->_M_parent;
    // 令y完全顶替x的地位（必须将x对其父节点的关系完全接收过来）
    if (__x == __root)                         // x为根节点                        
      __root = __y;
    else if (__x == __x->_M_parent->_M_left)   // x为其父节点的左子节点
      __x->_M_parent->_M_left = __y;
    else                                       // x为其父节点的右子节点
      __x->_M_parent->_M_right = __y;
    __y->_M_left = __x;
    __x->_M_parent = __y;
  }
  
  // 全局函数
  // 新节点比为红节点。如果插入处之父节点亦为红节点，就违反红黑树规则，此时必须做旋转（及颜色
  // 改变，在程序其他处）
  inline void 
  _Rb_tree_rotate_right(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
  {
    // x为旋转点
    _Rb_tree_node_base* __y = __x->_M_left;       // y为旋转点的左子节点
    __x->_M_left = __y->_M_right;
    if (__y->_M_right != 0)
      __y->_M_right->_M_parent = __x;             // 回设父节点
    __y->_M_parent = __x->_M_parent;
    // 令y完全顶替x的地位（必须将x对其父节点的关系完全接收过来）
    if (__x == __root)                            // x为根节点
      __root = __y;
    else if (__x == __x->_M_parent->_M_right)     // x为其父节点的右子节点
      __x->_M_parent->_M_right = __y;
    else                                          // x为其父节点的左子节点
      __x->_M_parent->_M_left = __y;
    __y->_M_right = __x;
    __x->_M_parent = __y;
  }
  

• RB-tree中元素搜寻

  // 寻找RB-tree中是否有键值为k的节点
  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>::find(const _Key& __k)
  {
    _Link_type __y = _M_header;      // Last node which is not less than __k. 
    _Link_type __x = _M_root();      // Current node. 
  
    while (__x != 0) 
      // 以下，key_compare是节点键值大小比较准则。应该会是个function object
      if (!_M_key_compare(_S_key(__x), __k))   
        __y = __x, __x = _S_left(__x);    // 进行到这里，表示x键值大于k。遇到大值就向左走
      else
        __x = _S_right(__x);              // 进行到这里，表示x键值小于k。遇到小值就向右走
  
    iterator __j = iterator(__y);   
    return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ? 
       end() : __j;
  }
  

• 应用

  RB-tree之所以为红黑树，原因是红黑颜色用来检测树的平衡性，达到AVL树的平衡要求。降低了对旋转的要求，从而提高了统计性能。红黑树相对于AVL树能够给予用户一个较“便宜”的解决方案。红黑树的算法时间复杂度和AVL树相同，但统计性能比AVL树更好。

  RB-tree应用：主要用于存储有序的数据，它的时间复杂度为O(logn），效率非常高。Java集合中的tree-set和tree-map，C++ STL中的set，map以及Linux虚拟机内存的管理都是通过红黑树实现的。

• 参考文献

  STL源码剖析——侯捷

  STL源码