stl_tree.h
这是整个STL中最复杂的数据结构，也是我接触到的最复杂的数据结构之一
/**
Red-black tree class, designed for use in implementing STL
associative containers (set, multiset, map, and multimap). The
insertion and deletion algorithms are based on those in Cormen,
Leiserson, and Rivest, Introduction to Algorithms (MIT Press, 1990),
except that
(1) the header cell is maintained with links not only to the root
but also to the leftmost node of the tree, to enable constant time
begin(), and to the rightmost node of the tree, to enable linear time
performance when used with the generic set algorithms (set_union,
etc.);
(2) when a node being deleted has two children its successor node is
relinked into its place, rather than copied, so that the only
iterators invalidated are those referring to the deleted node.
*/
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;
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;
///寻找以x为根节点的RB树的最小值结点
static _Base_ptr _S_minimum(_Base_ptr __x)
{
while (__x->_M_left != 0) __x = __x->_M_left;
return __x;
}
///寻找以x为根节点的RB树的最大值结点
static _Base_ptr _S_maximum(_Base_ptr __x)
{
while (__x->_M_right != 0) __x = __x->_M_right;
return __x;
}
};
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
{
typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
typedef bidirectional_iterator_tag iterator_category; ///双向迭代器
typedef ptrdiff_t difference_type;
_Base_ptr _M_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;
}
///结点的右孩子不为其父节点,则后继即为该父节点,如果结点的右孩子为其父节点
///只有一种情况,根节点无右子树(根节点为right_most结点),此时while循环亦会将迭
///代器指针指向end结点,因此在此处不需要再次修改迭代器指向.
if (_M_node->_M_right != __y)
_M_node = __y;
}
}
///找到递增序列的前驱
void _M_decrement()
{
if (_M_node->_M_color == _S_rb_tree_red &&
_M_node->_M_parent->_M_parent == _M_node) ///对end迭代器进行递减,指向最大值
_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;
}
pointer operator->() const
{
return &(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;
}
};
inline bool operator==(const _Rb_tree_base_iterator& __x,
const _Rb_tree_base_iterator& __y)
{
return __x._M_node == __y._M_node;
}
inline bool operator!=(const _Rb_tree_base_iterator& __x,
const _Rb_tree_base_iterator& __y)
{
return __x._M_node != __y._M_node;
}
inline bidirectional_iterator_tag
iterator_category(const _Rb_tree_base_iterator&)
{
return bidirectional_iterator_tag();
}
inline _Rb_tree_base_iterator::difference_type*
distance_type(const _Rb_tree_base_iterator&)
{
return (_Rb_tree_base_iterator::difference_type*) 0;
}
template <class _Value, class _Ref, class _Ptr>
inline _Value* value_type(const _Rb_tree_iterator<_Value, _Ref, _Ptr>&)
{
return (_Value*) 0;
}
///将以__x为根的子树左旋
inline void
_Rb_tree_rotate_left(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
///用__x->_M_right取代__x的位置,x取代x->_M_right的左孩子
///x->_M_right的左孩子取代x的右孩子
_Rb_tree_node_base* __y = __x->_M_right;
__x->_M_right = __y->_M_left;
if (__y->_M_left !=0)
__y->_M_left->_M_parent = __x;
__y->_M_parent = __x->_M_parent;
if (__x == __root)
__root = __y;
else if (__x == __x->_M_parent->_M_left)
__x->_M_parent->_M_left = __y;
else
__x->_M_parent->_M_right = __y;
__y->_M_left = __x;
__x->_M_parent = __y;
}
///将以__x为根的子树右旋
inline void
_Rb_tree_rotate_right(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
///用__x->_M_left取代__x的位置,x取代x->_M_left的右孩子
///x->_M_left的右孩子取代x的左孩子
_Rb_tree_node_base* __y = __x->_M_left;
__x->_M_left = __y->_M_right;
if (__y->_M_right != 0)
__y->_M_right->_M_parent = __x;
__y->_M_parent = __x->_M_parent;
if (__x == __root)
__root = __y;
else if (__x == __x->_M_parent->_M_right)
__x->_M_parent->_M_right = __y;
else
__x->_M_parent->_M_left = __y;
__y->_M_right = __x;
__x->_M_parent = __y;
}
///插入结点x之后的调整,使其符合RB树的定义,
///调整采用按子树逐层上溯处理,直至整棵树合法为止
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) ///父节点和叔父结点同为红色
{
///其祖父结点必不为红色,因此可以直接将红色上移至其祖父结点,
///然后将其父节点和叔父结点同时染黑,可保证自其祖父结点以下
///满足RB树的定义.
__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; ///将x指向其祖父结点,再次循环从其祖父结点开始调整
}
else ///其叔父结点为黑色
{
///此时x,x父节点均为红色,x叔父结点为黑色
if (__x == __x->_M_parent->_M_right) ///调整,将x调整为左孩子交由后面处理
{
__x = __x->_M_parent;
_Rb_tree_rotate_left(__x, __root);
}
///此时x必为左孩子,且x,x父节点均为红色,x叔父结点为黑色
__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);
///此时x父节点已经为黑色,可保证整棵树符合RB树的定义,完全可以跳出循环
}
}
else ///父节点为右孩子,和上面对称操作
{
_Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left;
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; ///调整根节点颜色
}
///删除结点z并调整该树,使其符合RB树的定义
inline _Rb_tree_node_base*
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* __z,
_Rb_tree_node_base*& __root,
_Rb_tree_node_base*& __leftmost,
_Rb_tree_node_base*& __rightmost)
{
_Rb_tree_node_base* __y = __z;
_Rb_tree_node_base* __x = 0;
_Rb_tree_node_base* __x_parent = 0;
if (__y->_M_left == 0) /// __z has at most one non-null child. y == z.
__x = __y->_M_right; /// __x might be null.
else if (__y->_M_right == 0) /// __z has exactly one non-null child. y == z.
__x = __y->_M_left; /// __x is not null.
else
{
///为了删除以后方便调整,RB树只删除没有孩子或只有一个孩子的结点
///如果需要删除的结点具有双孩子,需要找到该结点的后继(一定无双孩子)
///然后用后继代替该节点,同时染上该节点的颜色,调整因此,实际删除
///的结点永远无双孩子
/// __z has two non-null children. Set __y to
__y = __y->_M_right; /// __z's successor. __x might be null.
while (__y->_M_left != 0)
__y = __y->_M_left;
__x = __y->_M_right;
}
if (__y != __z) ///z具有双孩子
{
/// relink y in place of z. y is z's successor
__z->_M_left->_M_parent = __y;
__y->_M_left = __z->_M_left;
if (__y != __z->_M_right)
{
__x_parent = __y->_M_parent;
if (__x) __x->_M_parent = __y->_M_parent;
__y->_M_parent->_M_left = __x; /// __y must be a child of _M_left
__y->_M_right = __z->_M_right;
__z->_M_right->_M_parent = __y;
}
else
__x_parent = __y;
if (__root == __z)
__root = __y;
else if (__z->_M_parent->_M_left == __z)
__z->_M_parent->_M_left = __y;
else
__z->_M_parent->_M_right = __y;
__y->_M_parent = __z->_M_parent;
__STD::swap(__y->_M_color, __z->_M_color);
__y = __z;
/// __y now points to node to be actually deleted
}
else /// __y == __z
{
///z不具有双孩子
__x_parent = __y->_M_parent;
if (__x) __x->_M_parent = __y->_M_parent;
if (__root == __z)
__root = __x;
else if (__z->_M_parent->_M_left == __z)
__z->_M_parent->_M_left = __x;
else
__z->_M_parent->_M_right = __x;
if (__leftmost == __z)
if (__z->_M_right == 0) /// __z->_M_left must be null also
__leftmost = __z->_M_parent;
/// makes __leftmost == _M_header if __z == __root
else
__leftmost = _Rb_tree_node_base::_S_minimum(__x);
if (__rightmost == __z)
if (__z->_M_left == 0) /// __z->_M_right must be null also
__rightmost = __z->_M_parent;
/// makes __rightmost == _M_header if __z == __root
else /// __x == __z->_M_left
__rightmost = _Rb_tree_node_base::_S_maximum(__x);
}
///删除完毕,需要调整,和rebalance一样是按子树逐层上溯处理,直到整棵树合法为止
///如果为红色结点不需要调整
if (__y->_M_color != _S_rb_tree_red)
{
///如果x是根结点或者红色结点,只需最后调整结点颜色为黑色即可使整棵树满足RB树的定义
while (__x != __root && (__x == 0 || __x->_M_color == _S_rb_tree_black))
if (__x == __x_parent->_M_left)
{
///w为被删结点的兄弟,由于删除操作,w子树比x子树多一个黑结点
_Rb_tree_node_base* __w = __x_parent->_M_right;
if (__w->_M_color == _S_rb_tree_red)
{
///通过调整将w变为黑色,交由下面处理
__w->_M_color = _S_rb_tree_black;
__x_parent->_M_color = _S_rb_tree_red;
_Rb_tree_rotate_left(__x_parent, __root);
__w = __x_parent->_M_right;
}
///此时w一定为黑色,而且仍然比x子树多一个黑结点
if ((__w->_M_left == 0 ||
__w->_M_left->_M_color == _S_rb_tree_black) &&
(__w->_M_right == 0 ||
__w->_M_right->_M_color == _S_rb_tree_black)) ///w的两个孩子均为黑色
{
///将w染成红色,此时w子树减少了一个黑结点,和x子树黑结点数目相同
///但__x_parent子树比其兄弟子树少一个结点,因此令x=__x_parent,
///交由下次循环处理
__w->_M_color = _S_rb_tree_red;
__x = __x_parent;
__x_parent = __x_parent->_M_parent;
}
else ///w为黑色,其孩子一红一黑或者同为红色
{
if (__w->_M_right == 0 ||
__w->_M_right->_M_color == _S_rb_tree_black) ///w孩子节点左红右黑
{
if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
__w->_M_color = _S_rb_tree_red;
_Rb_tree_rotate_right(__w, __root);
__w = __x_parent->_M_right;
///此处w仍然为黑色,w子树的黑结点仍然比x子树多1,但w的孩子节点为左黑右红,交由下面处理
}
///此时此处w一定为黑色,w子树的黑结点一定比x子树多1,w的右孩子节点一定为红色
__w->_M_color = __x_parent->_M_color;
__x_parent->_M_color = _S_rb_tree_black;
if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
_Rb_tree_rotate_left(__x_parent, __root);
///至此处可保证整棵树符合RB树的定义
break;
}
}
else /// same as above, with _M_right <-> _M_left.
{
_Rb_tree_node_base* __w = __x_parent->_M_left;
if (__w->_M_color == _S_rb_tree_red)
{
__w->_M_color = _S_rb_tree_black;
__x_parent->_M_color = _S_rb_tree_red;
_Rb_tree_rotate_right(__x_parent, __root);
__w = __x_parent->_M_left;
}
if ((__w->_M_right == 0 ||
__w->_M_right->_M_color == _S_rb_tree_black) &&
(__w->_M_left == 0 ||
__w->_M_left->_M_color == _S_rb_tree_black))
{
__w->_M_color = _S_rb_tree_red;
__x = __x_parent;
__x_parent = __x_parent->_M_parent;
}
else
{
if (__w->_M_left == 0 ||
__w->_M_left->_M_color == _S_rb_tree_black)
{
if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
__w->_M_color = _S_rb_tree_red;
_Rb_tree_rotate_left(__w, __root);
__w = __x_parent->_M_left;
}
__w->_M_color = __x_parent->_M_color;
__x_parent->_M_color = _S_rb_tree_black;
if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
_Rb_tree_rotate_right(__x_parent, __root);
break;
}
}
if (__x) __x->_M_color = _S_rb_tree_black;
}
return __y;
}
/// In order to avoid having an empty base class, we arbitrarily
///move one of rb_tree's data members into the base class.
template <class _Tp, class _Alloc>
struct _Rb_tree_base
{
typedef _Alloc allocator_type;
allocator_type get_allocator() const
{
return allocator_type();
}
_Rb_tree_base(const allocator_type&)
: _M_header(0)
{
_M_header = _M_get_node();
}
~_Rb_tree_base()
{
_M_put_node(_M_header);
}
protected:
_Rb_tree_node<_Tp>* _M_header; ///不存储数据元素,只存储指向根节点,最小节点,
///和最大结点的指针
typedef simple_alloc<_Rb_tree_node<_Tp>, _Alloc> _Alloc_type;
_Rb_tree_node<_Tp>* _M_get_node()
{
return _Alloc_type::allocate(1);
}
void _M_put_node(_Rb_tree_node<_Tp>* __p)
{
_Alloc_type::deallocate(__p, 1);
}
};
template <class _Key, class _Value, class _KeyOfValue, class _Compare,
class _Alloc = Stl_Default_Alloc >
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:
using _Base::_M_get_node;
using _Base::_M_put_node;
using _Base::_M_header;
protected:
_Link_type _M_create_node(const value_type& __x)
{
_Link_type __tmp = _M_get_node();
try
{
construct(&__tmp->_M_value_field, __x);
}
catch(...)
{
_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;
_Link_type& _M_root() const ///_M_header和_M_root互为父节点
{
return (_Link_type&) _M_header->_M_parent;
}
_Link_type& _M_leftmost() const ///_M_header->_M_left指向最小值,即最左端结点
{
return (_Link_type&) _M_header->_M_left;
}
_Link_type& _M_rightmost() const ///_M_header->_M_right指向最大值,即最右端结点
{
return (_Link_type&) _M_header->_M_right;
}
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);
}
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;
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;
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) ///copy constructor
: _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
/// __root, in iterator.operator++
_M_root() = 0;
_M_leftmost() = _M_header;
_M_rightmost() = _M_header;
}
public:
/// accessors:
_Compare key_comp() const
{
return _M_key_compare;
}
iterator begin()
{
return _M_leftmost();
}
const_iterator begin() const
{
return _M_leftmost();
}
iterator end()
{
return _M_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
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);
template <class _InputIterator>
void insert_unique(_InputIterator __first, _InputIterator __last);
template <class _InputIterator>
void insert_equal(_InputIterator __first, _InputIterator __last);
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;
};
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
inline bool
operator==(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
{
return __x.size() == __y.size() &&
equal(__x.begin(), __x.end(), __y.begin());
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
inline bool
operator<(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
{
return lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end());
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>&
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x)
{
if (this != &__x)
{
/// Note that _Key may be a constant type.
clear(); ///先将需要赋值的树清空
_M_node_count = 0;
_M_key_compare = __x._M_key_compare; ///比较函数赋值
if (__x._M_root() == 0)
{
_M_root() = 0;
_M_leftmost() = _M_header;
_M_rightmost() = _M_header;
}
else
{
_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;
}
}
return *this;
}
///v为要插入的值,x为要插入的位置,y为x的父节点
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)
{
_Link_type __x = (_Link_type) __x_;
_Link_type __y = (_Link_type) __y_;
_Link_type __z;
if (__y == _M_header || __x != 0 ||
_M_key_compare(_KeyOfValue()(__v), _S_key(__y)))
{
__z = _M_create_node(__v);
_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())
_M_leftmost() = __z; /// maintain _M_leftmost() pointing to min node
}
else
{
__z = _M_create_node(__v);
_S_right(__y) = __z;
if (__y == _M_rightmost())
_M_rightmost() = __z; /// maintain _M_rightmost() pointing to max node
}
_S_parent(__z) = __y;
_S_left(__z) = 0;
_S_right(__z) = 0;
_Rb_tree_rebalance(__z, _M_header->_M_parent);
++_M_node_count;
return iterator(__z);
}
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) ///寻找合适的插入点(一定为0),同时记录插入点的父节点
{
__y = __x;
__x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
_S_left(__x) : _S_right(__x);
}
return _M_insert(__x, __y, __v);
}
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的键值时向左子树移动,否则向右子树移动,因此,如果已有重复
///键值存在,x最终一定位于重复键值所在节点的右子树
__x = __comp ? _S_left(__x) : _S_right(__x);
}
///检查是否可以插入(键值是否有重复)
iterator __j = iterator(__y);
if (__comp) ///插入点是其父节点的左孩子
if (__j == begin())
{
///最左端结点,不可能位于某个节点的右子树,因此可判定无重复键值,可插入
return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
}
else
{
--__j; ///得到其父节点的直接前驱结点,若插入x,即成为x的直接前驱结点
}
///此时,j为若插入x后x的直接前驱结点.
if (_M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
return pair<iterator,bool>(__j, false);
}
///不可重复插入,先在指定位置插入,若指定位置插入不合法,
///再试图寻找合法位置插入
template <class _Key, class _Val, class _KeyOfValue,
class _Compare, class _Alloc>
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>
::insert_unique(iterator __position, const _Val& __v)
{
if (__position._M_node == _M_header->_M_left) /// begin()
{
if (size() > 0 &&
_M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node)))
{
/// first argument just needs to be non-null
return _M_insert(__position._M_node, __position._M_node, __v);
}
else
{
return insert_unique(__v).first;
}
}
else if (__position._M_node == _M_header) /// end()
{
if (_M_key_compare(_S_key(_M_rightmost()), _KeyOfValue()(__v)))
return _M_insert(0, _M_rightmost(), __v);
else
return insert_unique(__v).first;
}
else
{
iterator __before = __position;
--__before; ///找到插入位置的直接前驱
if (_M_key_compare(_S_key(__before._M_node), _KeyOfValue()(__v))
&& _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node)))
{
if (_S_right(__before._M_node) == 0)
return _M_insert(0, __before._M_node, __v);
else
return _M_insert(__position._M_node, __position._M_node, __v);
/// first argument just needs to be non-null
}
else
return insert_unique(__v).first;
}
}
template <class _Key, class _Val, class _KeyOfValue,
class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>
::insert_equal(iterator __position, const _Val& __v)
{
if (__position._M_node == _M_header->_M_left) /// begin()
{
if (size() > 0 &&
!_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v)))
return _M_insert(__position._M_node, __position._M_node, __v);
/// first argument just needs to be non-null
else
return insert_equal(__v);
}
else if (__position._M_node == _M_header) /// end()
{
if (!_M_key_compare(_KeyOfValue()(__v), _S_key(_M_rightmost())))
return _M_insert(0, _M_rightmost(), __v);
else
return insert_equal(__v);
}
else
{
iterator __before = __position;
--__before;
if (!_M_key_compare(_KeyOfValue()(__v), _S_key(__before._M_node))
&& !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v)))
{
if (_S_right(__before._M_node) == 0)
return _M_insert(0, __before._M_node, __v);
else
return _M_insert(__position._M_node, __position._M_node, __v);
/// first argument just needs to be non-null
}
else
return insert_equal(__v);
}
}
template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
template<class _II>
void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
::insert_equal(_II __first, _II __last)
{
for ( ; __first != __last; ++__first)
insert_equal(*__first);
}
template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
template<class _II>
void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
::insert_unique(_II __first, _II __last)
{
for ( ; __first != __last; ++__first)
insert_unique(*__first);
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
inline void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::erase(iterator __position)
{
_Link_type __y =
(_Link_type) _Rb_tree_rebalance_for_erase(__position._M_node,
_M_header->_M_parent,
_M_header->_M_left,
_M_header->_M_right);
destroy_node(__y);
--_M_node_count;
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::erase(const _Key& __x)
{
pair<iterator,iterator> __p = equal_range(__x);
size_type __n = 0;
distance(__p.first, __p.second, __n);
erase(__p.first, __p.second);
return __n;
}
///复制以__x作为根节点的子树,得到的树作为__p的子树
template <class _Key, class _Val, class _KoV, class _Compare, class _Alloc>
typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
_Rb_tree<_Key,_Val,_KoV,_Compare,_Alloc>
::_M_copy(_Link_type __x, _Link_type __p)
{
///整棵树所有的右子树都递归复制,所有的左子树都直接复制
/// structural copy. __x and __p must be non-null.
_Link_type __top = _M_clone_node(__x);
__top->_M_parent = __p;
try
{
if (__x->_M_right)
__top->_M_right = _M_copy(_S_right(__x), __top); ///递归复制x的右子树
__p = __top;
__x = _S_left(__x);
///直接复制x的左子树
while (__x != 0)
{
_Link_type __y = _M_clone_node(__x);
__p->_M_left = __y;
__y->_M_parent = __p;
if (__x->_M_right)
__y->_M_right = _M_copy(_S_right(__x), __y); ///继续递归复制右子树
__p = __y;
__x = _S_left(__x); ///x指向其左孩子,循环复制其左子树
}
}
catch(...)
{
_M_erase(__top);
}
return __top;
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::_M_erase(_Link_type __x)
{
/// erase without rebalancing
while (__x != 0)
{
_M_erase(_S_right(__x)); ///递归删除右子树
///循环删除左子树
_Link_type __y = _S_left(__x);
destroy_node(__x);
__x = __y;
}
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::erase(iterator __first, iterator __last)
{
if (__first == begin() && __last == end())
clear();
else
while (__first != __last) erase(__first++);
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::erase(const _Key* __first, const _Key* __last)
{
while (__first != __last) erase(*__first++);
}
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)
{
if (!_M_key_compare(_S_key(__x), __k)) ///k <= x的键值时
__y = __x, __x = _S_left(__x);
else ///k > x的键值时
__x = _S_right(__x);
}
///至此,x为k的可插入点,y为x的直接前驱,如果k存在,则j不可能为end(),
///而且应有j指向结点的键值和k相等
iterator __j = iterator(__y);
return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ?
end() : __j;
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k) const
{
_Link_type __y = _M_header;
_Link_type __x = _M_root();
while (__x != 0)
{
if (!_M_key_compare(_S_key(__x), __k))
__y = __x, __x = _S_left(__x);
else
__x = _S_right(__x);
}
const_iterator __j = const_iterator(__y);
return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ?
end() : __j;
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::count(const _Key& __k) const
{
pair<const_iterator, const_iterator> __p = equal_range(__k);
size_type __n = 0;
distance(__p.first, __p.second, __n);
return __n;
}
///返回"最小的"键值和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>
::lower_bound(const _Key& __k)
{
_Link_type __y = _M_header;
_Link_type __x = _M_root();
while (__x != 0)
{
///当__x的键值 == k时,寻找"更小的" 键值等于k的__x
if (!_M_key_compare(_S_key(__x), __k))
__y = __x, __x = _S_left(__x);
else /// x的键值 < k
__x = _S_right(__x);
}
return iterator(__y);
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::lower_bound(const _Key& __k) const
{
_Link_type __y = _M_header;
_Link_type __x = _M_root();
while (__x != 0)
if (!_M_key_compare(_S_key(__x), __k))
__y = __x, __x = _S_left(__x);
else
__x = _S_right(__x);
return const_iterator(__y);
}
///返回"最大的"键值和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>
::upper_bound(const _Key& __k)
{
_Link_type __y = _M_header;
_Link_type __x = _M_root();
while (__x != 0)
{
if (_M_key_compare(__k, _S_key(__x))) ///k小于x的键值
__y = __x, __x = _S_left(__x);
else ///当__x的键值 == k时,寻找"更大的" __x
__x = _S_right(__x);
}
return iterator(__y);
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::upper_bound(const _Key& __k) const
{
_Link_type __y = _M_header;
_Link_type __x = _M_root();
while (__x != 0)
if (_M_key_compare(__k, _S_key(__x)))
__y = __x, __x = _S_left(__x);
else
__x = _S_right(__x);
return const_iterator(__y);
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
inline
pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator,
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
::equal_range(const _Key& __k)
{
return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k));
}
template <class _Key, class _Value, class _KoV, class _Compare, class _Alloc>
inline
pair<typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator,
typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator>
_Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>
::equal_range(const _Key& __k) const
{
return pair<const_iterator,const_iterator>(lower_bound(__k),
upper_bound(__k));
}
///计算[__node,__root]之间黑色结点的个数,采用递归上溯法
inline int
__black_count(_Rb_tree_node_base* __node, _Rb_tree_node_base* __root)
{
if (__node == 0)
return 0;
else
{
int __bc = __node->_M_color == _S_rb_tree_black ? 1 : 0;
if (__node == __root)
return __bc;
else
return __bc + __black_count(__node->_M_parent, __root);
}
}
template <class _Key, class _Value, class _KeyOfValue,
class _Compare, class _Alloc>
bool _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
{
if (_M_node_count == 0 || begin() == end())
return _M_node_count == 0 && begin() == end() &&
_M_header->_M_left == _M_header && _M_header->_M_right == _M_header;
int __len = __black_count(_M_leftmost(), _M_root());
for (const_iterator __it = begin(); __it != end(); ++__it)
{
_Link_type __x = (_Link_type) __it._M_node;
_Link_type __L = _S_left(__x);
_Link_type __R = _S_right(__x);
if (__x->_M_color == _S_rb_tree_red) ///检验红色结点是否有红色孩子
if ((__L && __L->_M_color == _S_rb_tree_red) ||
(__R && __R->_M_color == _S_rb_tree_red))
return false;
///检验键值是否不大于其左孩子
if (__L && _M_key_compare(_S_key(__x), _S_key(__L)))
return false;
///检验键值是否不小于其右孩子
if (__R && _M_key_compare(_S_key(__R), _S_key(__x)))
return false;
///检验左右孩子到根节点路径的黑色结点数目是否相同
if (!__L && !__R && __black_count(__x, _M_root()) != __len)
return false;
}
///检验最大、小值指针指向是否正确
if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
return false;
if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
return false;
return true;
}
红黑树是STL中map/set的内部数据结构，红黑树是一种特殊的二叉查找树。
首先看什么是二叉查找树:
(1)若左子树不为空，则左子树的所有节点均小于根节点
（2）若右子树不为空，则右子树的所有节点均大于根节点
（3）左右子树也分别为二叉查找树
（4）节点中没有重复的元素
二叉查找树的插入、查找最好时间复杂度为lg(N) , 最差的时间复杂度为O(N)
再看红黑树：
红黑树在二叉查找树的基础上增加了一下特性：
（1）所有的节点都是红/黑色的
（2）根节点是黑色的
（3)空节点为黑色的
（4）若一个节点是红色的，则它的两个叶子节点都是黑色的
（5)从任意节点到其任意叶子节点的路径中经过的黑色节点数是相等的
这五个性质强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。为什么呢？性质4暗示着任何一个简单路径上不能有两个毗连的红色节点，这样，最短的可能路径全是黑色节点，最长的可能路径有交替的红色和黑色节点。同时根据性质5知道：所有最长的路径都有相同数目的黑色节点，这就表明了没有路径能多于任何其他路径的两倍长。
这样，红黑树的最坏情况和最好情况基本是一致的，插入/查找的时间复杂度都为lg(N)
这样的一颗红黑树只需要进行中序遍历就可以实现有序访问，这也是stl中map/set为什么是自动有序的原因。