C++STL RBT

RB

红黑树的主要规则：

每个节点不是红色就是黑色的；

根节点总是黑色的；

如果节点是红色的，则它的子节点必须是黑色的；

从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点；

红黑树主要通过三总方式对平衡性进行修改，改变节点颜色，左旋和右旋。

Stl tree源码

//定义节点颜色

typedef bool _Rb_tree_Color_type;

const _Rb_tree_Color_type _S_rb_tree_red = false;

const _Rb_tree_Color_type _S_rb_tree_black = true;

//node base

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;

//左子节点

  _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 node

template <class _Value>

struct _Rb_tree_node : public _Rb_tree_node_base

{

  typedef _Rb_tree_node<_Value>* _Link_type;

//节点数据

  _Value _M_value_field;

};

//迭代器

struct _Rb_tree_base_iterator

{

//node指针

  typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;

  typedef bidirectional_iterator_tag iterator_category;

  typedef ptrdiff_t difference_type;

  _Base_ptr _M_node;

//当前node++

  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--

  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;

    else if (_M_node->_M_left != 0) {

      _Base_ptr __y = _M_node->_M_left;

      while (__y->_M_right != 0)

        __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;

    }

  }

};

//迭代器类

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;

  }