走进STL - 红黑树，是圣诞树吗

typedef bool __rb_tree_color_type;
const __rb_tree_color_type __rbtree_red = false;	//红0
const __rb_tree_color_type __rbtree_black = true;	//黑1

struct __rb_tree_node_base
{
	typedef __rb_tree_color_type color_type;
	typedef __rb_tree_node_base* base_ptr;
	color_type color;
	base_ptr parent;
	base_ptr left;
	base_ptr right;

	static base_ptr minimum(base_ptr x)
	{ ··· }
	static base_ptr maximum(base_ptr x)
	{ ··· }
}

template <class Value>
struct __rb_tree_node :public __rb_tree_node_base
{
	typedef ____rb_tree_node<Value>* link_type;
	Value value_field;	//节点值
} 

template<class Key,class Value,class KeyOfValue,class Compare,class Alloc = alloc>
class rb_tree
{
protected:
	typedef void* void_pointer;
	typedef __rb_tree_node<Value> rb_tree_node;
	typedef	__rb_tree_node* base_ptr;
	typedef simple_alloc<rb_tree_node,Alloc> rb_tree_node_allocator;
	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 rb_tree_node* link_node;
	typedef size_t size_type;
	typedef	ptrdiff_t difference_type;

protected:
	···		
	link_type header;	//这是实现上的一个技巧
	Compare key_compare;	//节点间的键值大小比较准则
	
	//以下三个函数用于取得header的成员
	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; }

	···
	
};

//返回的是一个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 = 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:新值插入点  y:插入点之父节点  v:新值
}

template<class Key,class Value,class KeyOfValue,class Compare,class Alloc>
pair<typename rb_tree<Key,Value,KeyOfValue,Compare,Alloc>::iterator>		//	这一行是返回值类型
rb_tree<Key,Value,KeyOfValue,Compare,Alloc>::insert_unique(const Value& v)
{
	link_type y = header;
	link_type x = root();

	bool comp = true;
	while( x != 0 )
	{
		y = x;
		comp = key_compare(KeyOfValue()(v),key(x));
		 x = comp ? left(x) : right(x);	//左右转
	}
	//循环转出来之后，y所指的便是插入节点的父节点，此时y必为叶节点
	iterator j = iterator(y);	//令迭代器j指向插入y
	if(comp)	//y节点值大于新值
		if(j == begin())	//如果插入点的父节点为最左	
			return pair<iterator,bool>(__insert(x,y,v),true);
		else
			--j;	//调整j,回头准备测试（我也不知道要测试啥）
	if(key_compare(key(j.node)KeyOfValue(key())(v))	//y节点小于新值
		return pair<iterator,bool>(__insert(x,y,v),true);

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>::__insert(base_ptr x_,base_ptr y_,const Value& v)	
{
	link_type y = link_type y_;
	link_type x = link_type x_;
	link_type z;

	if(y == header || x!=0 || Key_compare(KeyOfValue()(v),key(y)))
	{
		z = create_node(v);	//产生一个新节点
		left(y) = z;
		if(y == header)
		{
			root() = z;
			rightmost() = z;
		}
		else if(y == leftmost())
			leftmost() = z;
	}
	else
	{
		z = create_node(v);
		right(y) = z;
		if(y == rightmost())
			rightmost() = z;
	}
	parent(z) = y;	//设定新节点的父节点
	left(z) = 0;
	right(z) = 0;

	__rb_tree_rebalalance(z,header->parent);
	++node_count;
	return iterator(z);	//返回一个迭代器，指向新节点
	
}

//函数功能：重新令树型平衡

inline void __rb_tree_rebalance(__rb_tree_node_base* x/* 新增节点*/,__rb_tree_node_base*& root)
{
	x->color = __rb_tree_red;
	while( x != root && x->parent->color == __rb_tree_red)	//父节点为红
	{
		if( x->parent == x->parent->parent->left )	//父节点为祖父节点的左子节点
		{
			__rb_tree_node_base* y = x->parent->parent->right;	//将y作为它的伯父节点
			if( y && y->color == __rb_tree_red)	//如果真的有伯父节点，且为红
			{
				x->parent->color = __rb_tree_black;	//将父节点改黑
				y->color = __rb_tree_black;	//将伯父也抹黑
				y->parent->color = __rb_tree_red;	//把爷爷放红
				x = x->parent->parent;	//自己当爷爷							
			}
			else	//没有伯父，或者伯父是非洲回来的
			{
				if( x == x->parent->right)	//如果新节点为父节点右孩子
				{
					x = x->parent;	//自己当爸爸
					__rb_tree_rotate_left(x,root);	//第一参数为左旋点
				}
				x->parent->color = __rb_tree_black;	//将父节点抹黑
				x->parent->parent->color = __rb_tree_red;	//把爷爷放红
				__rb_tree_rotate_right(x->parent->parent,root);	//第一参数为右旋点	
			}
		}	
		else	//父节点为祖父节点右子节点
		{
			__rb_tree_node_base* y = x->parent->parent->left;	//令y为伯父节点
			if( y && y->color == __rb_tree_red)	//如果真的有伯父节点，且为红
			{
				x->parent->color = __rb_tree_black;	//将父节点改黑
				y->color = __rb_tree_black;	//将伯父也抹黑
				y->parent->color = __rb_tree_red;	//把爷爷放红
				x = x->parent->parent;	//自己当爷爷							
			}
			else	//没有伯父，或者伯父是非洲回来的
			{
				if( x == x->parent->left)	//如果新节点为父节点左孩子
				{
					x = x->parent;	//自己当爸爸
					__rb_tree_rotate_right(x,root);	//第一参数为左旋点
				}
				x->parent->color = __rb_tree_black;	//将父节点抹黑
				x->parent->parent->color = __rb_tree_red;	//把爷爷放红
				__rb_tree_rotate_right(x->parent->parent,root);	//第一参数为右旋点	
			}
		}
	}	//while结束
	root->color = __rb_tree_black;	//根节点抹黑
}

//左旋

inline void __rb_tree_rotate_left(__rb_tree_node_base* x,__rb_tree_node_base*& root)
{
	__rb_tree_node_base* y = x->right;	//令y为旋转点的右子节点
	x->right = y->left;	//令旋转点的右子节点的左子节点为旋转点的右节点
	if(y->left != 0)
		y->left->parent = x;	//并不知道这个有什么意义
	y->parent = x->parent;

	//令y完全顶替x的位置
	if(x == root)
		root = y;
	else if(x == x->parent->left)
		x->parent->left = y;
	else
		x->parent->right = y;
	y->left = x;
	x->parent = y;
}

//右旋

inline void __rb_tree_rotate_right(__rb_tree_node_base* x,__rb_tree_node_base*& root)
{
	__rb_tree_node_base* y = x->left;	//令y为旋转点的左子节点
	x->left = y->right;	//令旋转点的右子节点的左子节点为旋转点的右节点
	if(y->right != 0)
		y->right->parent = x;	//并不知道这个有什么意义
	y->parent = x->parent;

	//令y完全顶替x的位置
	if(x == root)
		root = y;
	else if(x == x->parent->right)
		x->parent->right = y;
	else
		x->parent->left = y;
	y->right = x;
	x->parent = y;
}