/*****************************************************************************************\ * rb_tree.cpp * 学习 SGI STL 中的实现 《STL源码剖析》 * 没有添加迭代器 *\*****************************************************************************************/#ifndef RB_TREE_H#define RB_TREE_H#include <cstddef>#include <algorithm>#include <iostream>#include <functional>using namespace std ;namespace std {#ifdef _MSC_VER/* 里面有VC STL内存分配之类的定义，如 allocator<> _Allocate _Construct _Destroy 等 */#include <xmemory> #else/* SGI STL 版本，包含construct destroy的定义 */#include <strl_construct.h>#endiftypedef bool hp_rb_tree_color_type ;const hp_rb_tree_color_type hp_rb_tree_red = false ;const hp_rb_tree_color_type hp_rb_tree_black = true ;struct hp_rb_tree_node_base{typedef hp_rb_tree_color_type color_type ;typedef hp_rb_tree_node_base* base_ptr ;color_type color ;base_ptr parent ;base_ptr left ;base_ptr right ;/* 后继节点，类似于迭代器中的定义 */static base_ptr increment( base_ptr x ){if ( x->right != 0 ){base_ptr y = x->right ;while ( y->left != 0 )y = y->left ;return y ;}/* * 经过测试，注意这种情况：只有一个节点*/else{base_ptr p = x->parent ;while ( p->right == x ){x = p ;p = p->parent ;}if ( x->right == p ) // 只有一个节点return x ;return p ;}}/* 前驱节点, 类似于迭代器中的定义 */static base_ptr decrement( base_ptr x ) {// x == header,也就是 end()。if ( x->color == hp_rb_tree_red && x->parent->parent == x )return x->right ;else if ( x->left != 0 ){base_ptr y = x->left ;while ( y->right != 0 )y = y->right ;return y ;}else // 仔细考虑这里，如果是mostright()节点++；返回的是header，和upper_bound一致 // 很强悍!{ base_ptr p = x->parent ; while ( p->left == x ){x = p ;p = p->parent ;}return p ;}}static base_ptr minimum( base_ptr x ){while ( 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 < typename Value >struct hp_rb_tree_node : public hp_rb_tree_node_base{// typedef __rb_tree_node* link_type ; // yes or nottypedef hp_rb_tree_node<Value>* link_type ; Value value_field ;} ;/* 感觉这样子定义会有很大的问题，如果对存储一种自定义的类，实例对象的大小比较 * 依赖于某个数据成员。那么， Value类型参数不能实例成 pair，否则不能调用类的 * 析构函数。 * 只能把 Value 类型参数实例成自定义的类，并且重写 KeyOfValue 仿函数，取得决定 * 类的实例大小的数据成员。 * * 另外： Compare 的定义一定要符合规范 * bool operator()( a, b ) * return a < b ; * 或者是 return a > b ; ***************************************************用sort测试,测试过，用point( x,y 二维数据 )*/#ifdef _MSC_VERtemplate < typename Key, typename Value, typename KeyOfValue, typename Compare=less<Key>, typename Alloc = allocator<Value> >#else // SGI STLtemplate < typename Key, typename Value, typename KeyOfValue, typename Compare=less<Key>, typename Alloc = alloc >#endifclass hp_rb_tree{protected:typedef hp_rb_tree_node_base* base_ptr ;typedef hp_rb_tree_node<Value> rb_tree_node ;typedef hp_rb_tree_color_type color_type ;// allocator#ifdef _MSC_VERtypedef allocator<rb_tree_node> rb_tree_node_allocator ; rb_tree_node_allocator msc_alloc ;#elsetypedef simple_alloc<rb_tree_node, Alloc> rb_tree_node_allocator ;#endifpublic:typedef Key key_type ;typedef Value value_type ; // 如果Key 和Value不是同值的话，Value要用pair表示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 ;// difference_type protected: /* 开辟一个节点的空间 */link_type get_node() {#ifdef _MSC_VERreturn msc_alloc.allocate(1) ; // 调用operator new#elsereturn rb_tree_node_allocator::allocate() ; // 调用malloc#endif}/* 释放一个节点的空间 */void put_node( link_type p ) {#ifdef _MSC_VERmsc_alloc.deallocate(p,0) ; // 调用operator delete#elserb_tree_node_allocator::deallocate(p) ; // 调用free#endif}/* 构造一个节点 */link_type create_node( const value_type & x ) {link_type tmp = get_node() ;#ifdef _MSC_VER_Construct( &tmp->value_field, x ) ;#elseconstruct( &tmp->value_field, x ) ; //调用 placement new#endifreturn tmp ;}/* 复制一个节点 */link_type clone_node( link_type x ) {#ifdef _MSC_VER#elselink_type tmp = create_node( x->value_field ) ;tmp->color = x->color ;tmp->left = 0 ;tmp->right = 0 ;return tmp ;#endif}/* 销毁一个节点 */void destroy_node( link_type p ) {#ifdef _MSC_VER_Destroy( &p->value_field ) ;#elsedestroy( &p->value_field ) ; // 调用析构函数#endif put_node(p) ; // 释放节点空间 }/* 数据部分 */ protected:size_type node_count ;link_type header ;Compare key_compare ;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 ; } 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 ; } // 先生成临时仿函数对象KeyOfValue()，再调用operator ()static const Key& key( link_type x ) { return KeyOfValue()(value(x)) ; }static color_type& color( link_type x ) { return x->color ; } 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 x->value_field ; } // 先生成临时仿函数对象KeyOfValue()，再调用operator ()static const Key& key( base_ptr x ) { return KeyOfValue()(value(x)) ; }static color_type& color( base_ptr x ) { return 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) ; }private: /* 拷贝整棵树 */link_type __copy( link_type x, link_type p ) ;/* 删除整棵子树，没有平衡，被clear调用而已 */void __erase( link_type x ) ;void init(){header = get_node() ;color(header) = hp_rb_tree_red ;root() = 0 ; // root == header->parentleftmost() = header ; // leftmost: header->leftrightmost() = header ; // rightmost:header->right} /* 前驱节点 */link_type pre( link_type x ){return (link_type)hp_rb_tree_node_base::decrement( (base_ptr)x ) ;} ;/* 后继节点 */link_type next( link_type x ){//link_type pn = (link_type)hp_rb_tree_node_base::increment( (base_ptr)x ) ;/* * *///if ( pn == 0 )//return header ;//return pn ;return (link_type)hp_rb_tree_node_base::increment( (base_ptr)x ) ;} ;/* 外部接口 */ public: /////////////////////////////////////////////////////////////////////////////////////////* 注意有默认参数，是指点仿函数的临时对象 */hp_rb_tree( const Compare& comp = Compare() ): node_count(0), key_compare(comp) { init() ; } ; // 使用对象初始化更好hp_rb_tree( const hp_rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x ): node_count(0), key_compare(x.key_compare){header = get_node() ;color(header) = hp_rb_tree_red ; if ( x.size == 0 ){root() = 0 ;leftmost() = 0 ;rightmost() = 0 ;}else{root() = __copy( x.root(), header ) ;leftmost() = minimum( root() ) ;rightmost() = maximum( root() ) ;node_count = x.size() ;}} ;/* 注意返回的是左值 */hp_rb_tree< Key, Value, KeyOfValue, Compare, Alloc>&operator= ( const hp_rb_tree< Key, Value, KeyOfValue, Compare, Alloc>& x ) ;~hp_rb_tree(){clear() ;put_node( header ) ; // 因为header是空节点，不用调用value_field的析构函数} ;///////////////////////////////////////////////////////////////////////////////////////// /* 若要添加迭代器，可以把link_type换成迭代器 */pair< link_type, bool > insert_unique( const value_type& v ) ;/* */link_type insert_equal( const value_type&v ) ; /* */link_type __insert( base_ptr x, base_ptr y, const value_type& v ) ; ////////////////////////////////////////////////////////////////////////////////////////* 查找，如果有多个相同关键字，返回最小的一个,如果没有，返回header */link_type find( const Key& k ) ;////////////////////////////////////////////////////////////////////////////////////////* */size_type erase( const Key& key ) ;void erase( link_type p ) ;/* 清空整棵树 */ void clear() {if ( node_count != 0 ){__erase( root() ) ; leftmost() = header ;rightmost() = header ;root() = 0 ;node_count = 0 ;}} ////////////////////////////////////////////////////////////////////////////////////////* 查找同一关键字 */pair< link_type, link_type > equal_range( const Key& k, size_type & n ) ;/* 注意这个函数，包含的东西很多，仔细揣摩 */// 返回相等关键字中“最小”的一个link_type lower_bound( const Key& k ) ;/* */link_type upper_bound( const Key& k ) ;/* 节点个数 */size_type size() const { return node_count ; } /* 同一关键字的个数 */size_type count( const Key& k ) ;////////////////////////////////////////////////////////////////////////////////////////* 测试时使用，输出整棵树，写的不够好 */ void display(){// 用层次遍历if ( root() == 0 ){cout << "no nodes" << endl ;return ;}link_type a[100], b[100] ;link_type *tpa, *tpb ;size_type cnta = 0, cntb = 0, i ;tpa = a ;tpb = b ;tpa[0] = root() ;++ cnta ;while ( cnta ){cntb = 0 ;for ( i = 0 ; i < cnta ; ++ i )cout << key(tpa[i]) << "--" << color( tpa[i] ) << " " ;cout << endl ;for ( i = 0 ; i < cnta ; ++ i ){if ( tpa[i]->left != 0 )tpb[cntb++] = left(tpa[i]) ;if ( tpa[i]->right != 0 )tpb[cntb++] = right(tpa[i]) ;}swap( tpa, tpb ) ;cnta = cntb ;}} ;} ; /********************************************** 成员函数外部定义 **********************************************/#define itself hp_rb_tree<Key, Value, KeyOfValue, Compare, Alloc>#define tmp_define template < typename Key, typename Value, typename KeyOfValue, \ typename Compare, typename Alloc >/* 拷贝整棵树 */tmp_definetypename itself::link_type itself::__copy( link_type x, link_type p ) {link_type tmp_x = clone_node( x ) ;tmp_x->parent = p ;if ( x->right != 0 )tmp_x->right = __copy( x->right, tmp_x ) ;p = tmp_x ;x = left(x) ;// 只是递归调用构造右子树，左子树用来循环！while ( x!= 0 ){link_type y = clone_node(x) ;y->parent = p ;if ( y != 0 )y->right = __copy( right(x), y ) ;p = y ;x = left(x) ;}return tmp_x ;}/* 赋值操作符 */tmp_defineitself& itself::operator= ( const itself& x ) {if ( this != &x ){clear() ;key_compare = x.key_compare ;if ( x.size() == 0 ){root() = 0 ;leftmost() = 0 ;rightmost() = 0 ;}else{root() = __copy( x.root(), header ) ;leftmost() = minimum( root() ) ;rightmost() = maximum( root() ) ;node_count = x.size() ;}}return *this ;}////////////////////////////////////////////////////////////////////////////////////////* 插入节点操作 */tmp_definepair< typename itself::link_type, bool > itself::insert_unique( const value_type& v ) {link_type y = header ;link_type x = root() ;bool comp = true ;/* 由于没有两次判断（从而得出是否相等），所以一定要到末尾 */while ( x != 0 ){//cout << left(y)->value_field ;y = x ; //cout << left(x)->value_field ;// 注意 key_compare 的定义, 在STL中，一般定义如下：// bool operator()( a, b ) { return a < b ; }// 又如MSDN的联机文档有：// bool UDgreater ( int elem1, int elem2 ) // { // return elem1 < elem2; // 不是 <= // }comp = key_compare( KeyOfValue()(v), key(x) ) ;x = comp ? left(x) : right(x) ;} /* 注意当 root() == 0 */link_type tmp = y ;if ( comp ) // v.key < x->key{if ( tmp == leftmost() )return pair< link_type, bool >( __insert( x, y, v ), true ) ;elsetmp = pre( tmp ) ; // tmp 是 x 的前驱,所以有：tmp->key <= x->key, 即有 tmp->key <= v.key } if ( key_compare( key(tmp), KeyOfValue()(v) ) ) // tmp->key < v.keyreturn pair< link_type, bool >( __insert( x, y, v ), true ) ;return pair< link_type, bool >( tmp, false ) ; // tmp->key == v.key} ;tmp_definetypename itself::link_type itself::insert_equal( const value_type&v ) {link_type y = header ;link_type x = root() ;while ( x != 0 ){y = x ;x = key_compare( KeyOfValue()(v), key(x) ) ? left(x) : right(x) ;}return __insert( x, y, v ) ;} ;/* 至今，我还不明白 x_ 有什么作用 */tmp_definetypename itself::link_type itself::__insert( base_ptr x_, base_ptr y_, const value_type& v ) {// x 为新插入点，是空节点，x插在y的下面，y一定是叶子节点link_type x = ( link_type) x_ ;link_type y = ( link_type)y_ ;link_type z ; z = create_node( v ) ;if ( y == header || x != 0 || key_compare( KeyOfValue()(v), key(y) ) ) // x 一定等于0吧{//z = create_node( v ) ;left(y) = z ;if ( y == header ){root() = z ;rightmost() = z ;}else if ( y == leftmost() )leftmost() = z ;}else{right(y) = z ;if ( y == rightmost() )rightmost() = z ;}parent(z) = y ;left(z) = 0 ;right(z) = 0 ;hp_rb_tree_rebalance( z, header->parent ) ;return z ;} ;////////////////////////////////////////////////////////////////////////////////////////////* 删除节点操作 *//* 删除同一关键字的节点,返回节点个数 */tmp_definetypename itself::size_type itself::erase( const Key& k ) {//cout << "void itself::erase( const Key& key ) " << endl ;size_type n = 0 ; pair< link_type, link_type > first_last = equal_range( k, n ) ; /*// 清空整棵树if ( first_last.first == leftmost() && first_last.second == header ){clear() ;return n ;} */ // 先慢点用clear link_type tmp, p ;p = first_last.first ;while ( p != first_last.second ){tmp = next(p) ; erase( p ) ;p = tmp ;}//while (first != last) erase(first++); return n ;}tmp_definevoid itself::erase( link_type p ) {link_type x = (link_type)hp_rb_tree_rebalance_for_erase( p, header->parent, header->left, header->right ) ; // header->parent 更好，用 root()要类型转换 destroy_node( x ) ;-- node_count ;}/* 删除整棵子树，没有平衡，仅仅被被clear调用而已 */tmp_definevoid itself::__erase( link_type x ) {link_type tmp ;while ( x != 0 ){__erase( right(x) ) ;tmp = left(x) ;destroy_node( x ) ;x = tmp ;}}////////////////////////////////////////////////////////////////////////////////////////////* 查找，如果有多个相同关键字，返回最小的一个,如果没有，返回header */tmp_definetypename itself::link_type find( const Key& k ) {link_type y = header ;link_type x = root() ;while ( x != 0 ){if ( !key_compare( key(x), k ) )y = x, x = left(x) ;elsex = right(x) ;}return ( y == header || key_compare( k, key(x) ) ) ? header : y ;}////////////////////////////////////////////////////////////////////////////////////////////* */tmp_definepair< typename itself::link_type, typename itself::link_type > itself::equal_range( const Key& k, size_type& n ) {link_type first, last, p ;first = lower_bound(k) ;last = upper_bound(k) ;n = 0 ;for ( p = first ; p != last ; p = next(p) )++ n ;return pair<link_type, link_type>( first, last ) ;}/* 返回相等关键字中“最小”的一个 */tmp_definetypename itself::link_type itself::lower_bound( const Key& k ) {link_type y = header ;link_type x = root() ; while ( x != 0 ){if ( !key_compare( key(x), k ) )y = x, x = left(x) ;elsex = right(x) ;}return y ;}/* 注意STL中区间是左闭右开，返回的y是第一个大于k的节点 */tmp_definetypename itself::link_type itself::upper_bound( const Key& k ) {/*link_type y = header ;link_type x = root() ;while ( x != 0 ){if ( !key_compare( k, key(x) ) )y = x, x = right(x) ;elsex = left(x) ;}return y ;*/ // 这段得到的y是：“最大”的节点（关键字==k）link_type y = header ;link_type x = root() ;while ( x != 0 ){if ( key_compare( k, key(x) ) )y = x, x = left(x) ;elsex = right(x) ;}/* 在STL中最右节点rightmost()的右节点是 header即是end()； 但是在这里没有实现迭代器，直接返回 0 。*///if ( y == header )//return (link_type)(0) ;return y ;}/********************** 全局函数*******************************************//* x 节点右旋, x不可能是header */inline void hp_rb_tree_rotate_right( hp_rb_tree_node_base* x, hp_rb_tree_node_base*& root ){ hp_rb_tree_node_base* y = x->left ; x->left = y->right ; if ( y->right != 0 ) { y->right->parent = x ; } y->parent = x->parent ; if ( x == root ) { root = y ; } else if ( x->parent->left == x ) { x->parent->left = y ; } else { x->parent->right = y ; } y->right = x ; x->parent = y ;} ;/* x节点左旋 */inline void hp_rb_tree_rotate_left( hp_rb_tree_node_base* x, hp_rb_tree_node_base*& root ){hp_rb_tree_node_base* y = x->right ;x->right = y->left ;if ( y->left != 0 )y->left->parent = x ;y->parent = x->parent ;if ( root == x )root = y ;else if ( x->parent->left == x )x->parent->left = y ;elsex->parent->right = y ;y->left = x ;x->parent = y ;} ;/* 保持红黑树的特性,加入了一个新节点 */inline void hp_rb_tree_rebalance(hp_rb_tree_node_base* x, hp_rb_tree_node_base*& root){// x 为新插入的节点hp_rb_tree_node_base* y ;x->color = hp_rb_tree_red ;while ( x != root && x->parent->color == hp_rb_tree_red ){if ( x->parent == x->parent->parent->left ){y = x->parent->parent->right ;if ( y != 0 && y->color == hp_rb_tree_red ) // 情况1{x->parent->color = hp_rb_tree_black ;y->color = hp_rb_tree_black ;x->parent->parent->color = hp_rb_tree_red ;x = x->parent->parent ;}else{if ( x == x->parent->right ) // 情况2，转移到情况3{x = x->parent ;hp_rb_tree_rotate_left( x, root ) ;} // 情况3： 通过变色和旋转，又转移到情况1x->parent->color = hp_rb_tree_black ;x->parent->parent->color = hp_rb_tree_red ;hp_rb_tree_rotate_right( x->parent->parent, root ) ;}}else{y = x->parent->parent->left ;if ( y != 0 && y->color == hp_rb_tree_red ) // 情况1{x->parent->color = hp_rb_tree_black ;y->color = hp_rb_tree_black ;x->parent->parent->color = hp_rb_tree_red ;x = x->parent->parent ;}else{if ( x == x->parent->left ) // 情况2，转移到情况3{x = x->parent ;hp_rb_tree_rotate_right( x, root ) ;} // 情况3： 通过变色和旋转，又转移到情况1x->parent->color = hp_rb_tree_black ;x->parent->parent->color = hp_rb_tree_red ;hp_rb_tree_rotate_left( x->parent->parent, root ) ;}}}root->color = hp_rb_tree_black ;} ;/* 删除一个节点，并保持平衡 */inline hp_rb_tree_node_base*hp_rb_tree_rebalance_for_erase(hp_rb_tree_node_base* z, hp_rb_tree_node_base*& root, hp_rb_tree_node_base*& leftmost, hp_rb_tree_node_base*& rightmost){hp_rb_tree_node_base* y = z ;hp_rb_tree_node_base* x ;hp_rb_tree_node_base* x_parent ;if ( y->left == 0 )x = y->right ;else{if ( y->right == 0 )x = y->left ;// 寻找真正要删除的节点y, z的节点不删除，只是更改value而已else{y = y->right ;while ( y->left != 0 )y = y->left ;x = y->right ;}} // y 只有一个孩子:x，但是 x 也可能为空if ( y != z ){z->left->parent = y ;y->left = z->left ;if ( z->right != y ){x_parent = y->parent ;if ( x != 0 )x->parent = x_parent ;y->parent->left = x ; // y must be left of its parenty->right = z->right ;z->right->parent = y ;} // 上面还未设置 y->parentelsex_parent = y ;// if ( root == z )root = y ;else if ( z->parent->left == z )z->parent->left = y ;elsez->parent->right = y ;y->parent = z->parent ;swap( y->color, z->color ) ;y = z ; // 这个要删除，destroy}else // y == z{// 删除节点yx_parent = y->parent ;if ( x != 0 )x->parent = y->parent ;if ( root == z )root = x ;// 这里我又犯了 z->parent->left = z 的错误else if ( z->parent->left == z )z->parent->left = x ;elsez->parent->right = x ;if ( leftmost == z ) if ( z->right == 0 ) // 即 x == 0 ，z为唯一节点leftmost = z->parent ;else// leftmost = x ;leftmost = hp_rb_tree_node_base::minimum(x) ; // 很正确if ( rightmost == z )if ( z->left == 0 ) // x == 0rightmost = z->parent ;elserightmost = hp_rb_tree_node_base::maximum(x) ;} // y 节点需要销毁// 按照BST的删除性质，删除一个节点，没有平衡处理。// 接下来就是平衡处理。 // x, x_parent if ( y->color == hp_rb_tree_black ) // 如果删除的是红节点，不会改变红黑树特性{// 刚开始，删除黑色的y，则从根到 x 少了一个黑色节点。// 如果 x 为红色，则直接染成黑色即可。// 所以，x 为黑色才进入循环，则 x_parent 也定是黑色// 同时也可以确定，x_parent 一定存在.while( x != root && ( x == 0 || x->color == hp_rb_tree_black ) ){if ( x == x_parent->left ){hp_rb_tree_node_base* w = x_parent->right ;if ( w->color == hp_rb_tree_red ) // 情况1{w->color = hp_rb_tree_black ;x_parent->color = hp_rb_tree_red ;hp_rb_tree_rotate_left( x_parent, root ) ;w = x_parent->right ;} // x_parent->right 一定是黑色// 把null节点当成黑色，则w的孩子结点都是黑色 // 情况2if ( ( w->left == 0 || w->left->color == hp_rb_tree_black ) && ( w->right == 0 || w->right->color == hp_rb_tree_black ) ){w->color = hp_rb_tree_red ;x = x_parent ;x_parent = x_parent->parent ;}else{// 即是 w->left 存在，且是红色 // 情况3if ( w->right == 0 || w->right->color == hp_rb_tree_black ) {w->color = hp_rb_tree_red ;if ( w->left != 0 ) // 不用判断 w->left->color = hp_rb_tree_black ;hp_rb_tree_rotate_right( w, root ) ;// 转移到情况4w = x_parent->right ;}// w->right == 红色或不存在 // 情况4w->color = x_parent->color ;x_parent->color = hp_rb_tree_black ;if ( w->right ) w->right->color = hp_rb_tree_black ;hp_rb_tree_rotate_left( x_parent, root ) ;break ; // 完全符合红黑树特性！}}else // swap( left, right ){hp_rb_tree_node_base* w = x_parent->left ;if ( w->color == hp_rb_tree_red ) // 情况1{w->color = hp_rb_tree_black ;x_parent->color = hp_rb_tree_red ;hp_rb_tree_rotate_right( x_parent, root ) ;w = x_parent->left ;} // x_parent->right 一定是黑色// 把null节点当成黑色，则w的孩子结点都是黑色 // 情况2if ( ( w->right == 0 || w->right->color == hp_rb_tree_black ) && ( w->left == 0 || w->left->color == hp_rb_tree_black ) ){w->color = hp_rb_tree_red ;x = x_parent ;x_parent = x_parent->parent ;}else{// 即是 w->right 存在，且是红色 // 情况3if ( w->left == 0 || w->left->color == hp_rb_tree_black ) {w->color = hp_rb_tree_red ;if ( w->right != 0 ) // 不用判断 w->right->color = hp_rb_tree_black ;hp_rb_tree_rotate_left( w, root ) ;// 转移到情况4w = x_parent->left ;}// w->left == 红色或不存在 // 情况4w->color = x_parent->color ;x_parent->color = hp_rb_tree_black ;if ( w->left ) w->left->color = hp_rb_tree_black ;hp_rb_tree_rotate_right( x_parent, root ) ;break ; // 完全符合红黑树特性！}}}if ( x != 0 )x->color = hp_rb_tree_black ;}return y ;}} // namespace std#endif/********************************************************************************************************************///测试代码#include <iostream>#include <string>#include "rb_tree.h"using namespace std ;/* */template < typename T >class __indentity: public unary_function<T,T>{public:const T& operator()( const T& x ) const { return x ; }} ;template < typename Pair > /* 实例时应该是个类似pair的类 */class __select1st: public unary_function<Pair, typename Pair::first_type>{public:const typename Pair::first_type& operator()( const Pair& x ) const{return x.first ;}} ;class cmp{bool operator()( const int & x1, const int & x2 ) const {return x1 < x2 ;}} ;int main(){/*hp_rb_tree< int, int, __indentity<int>, greater<int> > tree1 ;int n, i, x ;cin >> n ;for ( i = 0 ; i < n ; ++ i ){cin >> x ;tree1.insert_unique( x ) ;}tree1.display() ;tree1.clear() ;*///hp_rb_tree< int, int, __indentity<int>, greater<int> > tree2 ; typedef pair<int, string> VALUE ; hp_rb_tree< int, VALUE, __select1st<VALUE> > tree3 ;//VALUE buffer[100] ;VALUE* p ;int i, n ;cin >> n ;for ( i = 0 ; i < n ; ++ i ){p = new VALUE ;cin >> p->first >> p->second ;tree3.insert_unique( *p ) ;delete p ;}tree3.display() ;tree3.clear() ; return 0 ;}/*101 mynameishp2 helloword3 youaresb4 sbsb5 youarenotright5 sba6 111117 hphp8 hpisasb9 hp_hp*/
