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源码
扫一扫
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
