/*****************************************************************************************\
* 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>
#endif
typedef 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 not
typedef 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_VER
template < typename Key, typename Value, typename KeyOfValue,
typename Compare=less<Key>, typename Alloc = allocator<Value> >
#else // SGI STL
template < typename Key, typename Value, typename KeyOfValue,
typename Compare=less<Key>, typename Alloc = alloc >
#endif
class 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_VER
typedef allocator<rb_tree_node> rb_tree_node_allocator ;
rb_tree_node_allocator msc_alloc ;
#else
typedef simple_alloc<rb_tree_node, Alloc> rb_tree_node_allocator ;
#endif
public:
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_VER
return msc_alloc.allocate(1) ; // 调用operator new
#else
return rb_tree_node_allocator::allocate() ; // 调用malloc
#endif
}
/* 释放一个节点的空间 */
void put_node( link_type p )
{
#ifdef _MSC_VER
msc_alloc.deallocate(p,0) ; // 调用operator delete
#else
rb_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 ) ;
#else
construct( &tmp->value_field, x ) ; //调用 placement new
#endif
return tmp ;
}
/* 复制一个节点 */
link_type clone_node( link_type x )
{
#ifdef _MSC_VER
#else
link_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 ) ;
#else
destroy( &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->parent
leftmost() = header ; // leftmost: header->left
rightmost() = 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_define
typename 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_define
itself& 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_define
pair< 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 ) ;
else
tmp = pre( tmp ) ; // tmp 是 x 的前驱,所以有：tmp->key <= x->key, 即有 tmp->key <= v.key
}
if ( key_compare( key(tmp), KeyOfValue()(v) ) ) // tmp->key < v.key
return pair< link_type, bool >( __insert( x, y, v ), true ) ;
return pair< link_type, bool >( tmp, false ) ; // tmp->key == v.key
} ;
tmp_define
typename 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_define
typename 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_define
typename 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_define
void 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_define
void itself::__erase( link_type x )
{
link_type tmp ;
while ( x != 0 )
{
__erase( right(x) ) ;
tmp = left(x) ;
destroy_node( x ) ;
x = tmp ;
}
}
///
/* 查找，如果有多个相同关键字，返回最小的一个,如果没有，返回header */
tmp_define
typename 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) ;
else
x = right(x) ;
}
return ( y == header || key_compare( k, key(x) ) ) ? header : y ;
}
///
/* */
tmp_define
pair< 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_define
typename 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) ;
else
x = right(x) ;
}
return y ;
}
/* 注意STL中区间是左闭右开，返回的y是第一个大于k的节点 */
tmp_define
typename 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) ;
else
x = 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) ;
else
x = 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 ;
else
x->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： 通过变色和旋转，又转移到情况1
x->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： 通过变色和旋转，又转移到情况1
x->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 parent
y->right = z->right ;
z->right->parent = y ;
} // 上面还未设置 y->parent
else
x_parent = y ;
//
if ( root == z )
root = y ;
else if ( z->parent->left == z )
z->parent->left = y ;
else
z->parent->right = y ;
y->parent = z->parent ;
swap( y->color, z->color ) ;
y = z ; // 这个要删除，destroy
}
else // y == z
{
// 删除节点y
x_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 ;
else
z->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 == 0
rightmost = z->parent ;
else
rightmost = 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的孩子结点都是黑色 // 情况2
if ( ( 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 存在，且是红色 // 情况3
if ( 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 ) ;// 转移到情况4
w = x_parent->right ;
}
// w->right == 红色或不存在 // 情况4
w->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的孩子结点都是黑色 // 情况2
if ( ( 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 存在，且是红色 // 情况3
if ( 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 ) ;// 转移到情况4
w = x_parent->left ;
}
// w->left == 红色或不存在 // 情况4
w->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 ;
}
/*
10
1 mynameishp
2 helloword
3 youaresb
4 sbsb
5 youarenotright
5 sba
6 11111
7 hphp
8 hpisasb
9 hp_hp
*/
170万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
