标签：
红黑树也是一种而叉搜索树，因此二叉搜索树的性质红黑树都具有，同时，我们知道为了避免最坏情况下的二叉搜索树（就是高度不平衡的情况）衍生出了AVL树，使其任何节点的左右子树的高度差相差最多1，从而达到平衡，以确保最坏情况下的搜索效率。当然红黑树为了比较好的搜索效率降低了对平衡的要求，但是红黑树仍然具有良好的平衡状态。
AVL树与RB_tree
AVL树也称为高度平衡树，其插入，删除，查找在平均和最坏情况下都是O(log n),增加和删除要通过一次或多次树的旋转来重新平衡这个树。
RB_tree并不追求完全平衡，只要求部分达到平衡要求，降低了对旋转的要求，从而提高了性能，红黑树能够以O(log 2 n)的时间复杂度进行插入，删除，查找，此外由于它的设计任何不平衡都会在3次旋转之内解决。相比较而言红黑树和AVL树的算法时间复杂度相同，但统计性能比AVL树高。同时，红黑树的应用比AVL树广泛
例如：（1）红黑树广泛应用于c++的STL中，比如关联式容器set, map,multiset, multimap都以RB_tree为底层机制。
（2）epoll在内核中的实现，用红黑树管理事件块。
（3）linux进程调度上，用红黑树管理进程控制块。
（4）nginx中用红黑树管理timer
下面自己分析了SGI中的stl_tree.h源码的分析
#ifndef __SGI_STL_INTERNAL_TREE_H
#define __SGI_STL_INTERNAL_TREE_H
//RB-tree的节点设计
//设计思路节点设计分为两层__rb_tree_node继承__rb_tree_node_base以达到将指针和数据分开
typedef bool __rb_tree_color_type;
const __rb_tree_color_type __rb_tree_red = false;
const __rb_tree_color_type __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 color;
base_ptr parent;
base_ptr left;
base_ptr right;
//找到存储的最小值
static base_ptr minimum(base_ptr x)
{
wile(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<class Value>
struct __rb_tree_node : public __rb_tree_node_base
{
typedef __rb_tree_node<Value>* link_type;
Value value_field;
};
//RB_tree迭代器结构设计，也是采用双层迭代其结构
struct __rb_base_iterator
{
typedef __rb_tree_node_base::base_ptr base_ptr;
typedef bidirectional_iterator_tag iterator_category;
typedef ptrdiff_t difference_type;
base_ptr node;
//迭代器的前进操作operator++()调用了基层迭代器的increment()
//(1)如果node有右子树，但这个右子树没有左子节点，那么node前进一个节点为node->right.如果这个右子 树有左子树，那么node后面的节点就是这个左子树的最左边的那个节点。
//(2)如果node没有右子树，并且node是node->parent的左子树，那么node后面的节点是node->parent。如果node是node->parent的右子树，则一直上朔，直到不再是右子节点比如为y，那么node后面的节点是就是y->parent这个节点
void increment()
{
if(node->right != 0){
node = node->right;
while(node->left != 0){
node = node->left;
}
}
else{
base_ptr y = node->parent;
while(node == y->right){
node = y;
y = y->parent;
}
if(node->right != y){
node = y;
}
}
}
//迭代器的后退操作operator--()调用基层迭代器ecrement()
//(1)node有左子树，且node的左子树没有右子树，那么node前面的节点就是node->left。如果node的左子树有右子树，那么node前面的节点就是这个右子树的最右边的节点。
//(2)node没有左子树，且node为其父节点的左节点，那么就上朔直到node不为node->parent的左节点，那么node的前面的节点就是这个node->parent。如果为其父节点的右节点，那么node的前面的节点就是node->parent。
void decrement()
{
//判断node就是header这个虚节点
if(node->color == __rb_tree_red && node->parent->parent == node){
node = node->right;
}
else if(node->left != 0){
base_ptr y = node->left;
while(y->right != 0){
y = y->right;
}
node = y;
}
else{
base_ptr y = node->parent;
while(node == y->left){
node = y;
y = y->parent;
}
node = y;
}
}
};
template<calss 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){node = x;}
__rb_tree_iterator(const iterator& it){ode = it.node;}
self& operator++() { increment(); return *this; }
self operator++(int) {
self tmp = *this;
increment();
return tmp;
}
self& operator--() { decrement(); return *this; }
self operator--(int) {
self tmp = *this;
decrement();
return tmp;
}
};
inline bool operator==(const __rb_tree_base_iterator& x,
const __rb_tree_base_iterator& y)
{
return x.node == y.node;
}
inline bool operator!=(const __rb_tree_base_iterator& x,
const __rb_tree_base_iterator& y)
{
return x.node != y.node;
}
//RB_tree数据结构
template <class Key, class Value, class KeyOfValue, class Compare,
class Alloc = alloc>
class rb_tree {
protected:
typedef void* void_pointer;
typedef __rb_tree_node_base* base_ptr;
typedef __rb_tree_node<Value> rb_tree_node;
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 const value_type& const_reference;
typedef rb_tree_node* link_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
public:
rb_tree(const Compare& comp = Compare())
: node_count(0), key_compare(comp) { init(); }
~rb_tree() {
clear();
put_node(header);
}
rb_tree<Key, Value, KeyOfValue, Compare, Alloc>&
operator=(const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x);
protected:
get_node(){return rb_tree_node_allocator::allocate();}
void put_node(link_type p) { rb_tree_node_allocator::deallocate(p); }
link_type create_node(const value_type& x) {
link_type tmp = get_node();
put_node(tmp);
return tmp;
}
//复制一个节点
link_type clone_node(link_type x) {
link_type tmp = create_node(x->value_field);
tmp->color = x->color;
tmp->left = 0;
tmp->right = 0;
return tmp;
}
void destroy_node(link_type p) {
destroy(&p->value_field);
put_node(p);
}
protected:
size_type node_count; // keeps track of size of tree
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; }
//这六个函数方便取得节点x的成员（自身做参数）自己对这12个函数没有具体搞明白为什么写两种
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; }
static const Key& key(link_type x) { return KeyOfValue()(value(x)); }
static color_type& color(link_type x) { return (color_type&)(x->color); }
//这六个函数方便取得节点x的成员（以父类类型的节点做参数）
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 ((link_type)x)->value_field; }
static const Key& key(base_ptr x) { return KeyOfValue()(value(link_type(x)));}
static color_type& color(base_ptr x) { return (color_type&)(link_type(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);
}
public:
typedef __rb_tree_iterator<value_type, reference, pointer> iterator;
typedef __rb_tree_iterator<value_type, const_reference, const_pointer>
const_iterator;
};
#endif
由于内容比较多，还没有整理完，明天将继续进行源码的分析。
标签：
原文地址：http://blog.csdn.net/xixihaha331/article/details/51363497
