//
// RB_tree_STL.cpp
// 笔记
//
// Created by fam on 15/3/21.
//
//
#include "RB_tree_STL.h"
//---------------------------15/03/21----------------------------
RB_tree
{
/*
一个由上而下程序:
为了避免父子节点皆为红色的情况持续向上层发展，形成处理时效上的瓶颈，可以从上向下处理，
假设新增的节点为a，那就沿着a的路径，只要看到一个节点的两个子节点都是红色，就把这个节点改为红色
其他两个子节点改成黑色。
*/
//RB_tree的节点设计
typedef
bool __rb_tree_color_type;
const __rb_tree_color_type __rb_tree_red =
const __rb_tree_color_type __rb_tree_black =
true;
//__rb_tree_node_base
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)
{
while (x->left !=
)
x=x->left;
return x;
}
//一直向右走
static base_ptr maximum(base_ptr x)
{
while (x->right !=
)
x=x->right;
return x;
}
};
//__rb_tree_node
template<class Value>
struct __rb_tree_node :
public __rb_tree_node_base
{
typedef __rb_tree_node<Value>* link_type;
Value value_field;
};
//节点设计结束
/*
re_tree的迭代器
re_tree的迭代器和slist的迭代器很相似，都是分成两层结构
re_tree属于双向迭代器，但是不具备随机定位的能力
*/
//__rb_tree_base_iterator
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 node;
void increment()
{
if(node->right !=
)
{
node = node->right;
while (node->left !=
)
node =node->left;
}
//只要node是他父节点的右儿子，他就比他父亲大，我们要找比node大的
else
{
base_ptr y= node->parent;
while(node == y->right)
{
node = y;
y = y->parent;
}
if(node->right != y)//如果node是根节点，而且没有右儿子
node=y;
}
}
void decrement()
{
//这个发生在node时header或者end()时
if(node->color == __rb_tree_red &&
node->parent->parent == node)
node =node->right;
else
)
{
base_ptr y = node->left;
while(y->right !=
)
y = y->right;
node = y;
}
else
{
base_ptr y =node->parent;
while(node == y->left)
{
node = y;
y = y->parent;
}
node = y;
}
}
//原文说increment有4种状况，其实只有三种，状况2并不是一种结果
};
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;
//经过多日的stl熏陶，感觉有些明白self和iterator的关系了，self是当前的节点本身(因为self用到的地方
//很多，可以简化书写，iterator是一个类型属性供别人使用的。
typedef __rb_tree_node<Value>* link_type;
//构造函数
__rb_tree_iterator(){}
__rb_tree_iterator(link_type x) {node = x;}
__rb_tree_iterator(const iterator& x) {node = it.node;}
referenceoperator*()
const {return link_type(node)->value_field;}
#ifdef __SGI_STL_NO_ARROW_OPERATOR
pointeroperator->()
const {return &(operator*());}
#endif
//++ --操作
self&operator++() {increment();
return *this;}
self&operator++(){increment();return *this;}
selfoperator++(int)
{
self tmp = *this;
increment();
return tmp;
}
self&operator--(){decrement();return *this;}
selfoperator--(int)
{
self tmp = *this;
decrement();
return tmp;
}
}
//class rb_tree
template<class Key,class Value,
class KeyOfValue,class Compare,
class Alloc = alloc>
class rb_tree
{
protected:
typedef
void* void_point;
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;
protected:
//内存分配和释放
link_type get_node()
{
return rb_tree_node_allocator::allocate();
}
void put_node(link_type p)
{
rb_tree_node_allocator::deallocate(p);
}
//申请内存并调用构造函数等于new操作
link_type create_node(const value_type& x)
{
link_type tmp = get_node();
__STL_TRY
{
construct(&tmp->value_field,x);
}
__STL_UNWIND(put_node(tmp));
return tmp;
}
//克隆一个节点,只有颜色和键值，不会拷贝关系(左右儿子) 有个疑问，为什么parent没有赋0
link_type clone_node(link_type x)
{
link_type tmp = create_node(x->value_field);
tmp->color = x->color;
tmp->left =;
tmp->right =;
return temp;
}
void destroy_node(link_type p)
{
destroy(&p->value_field);
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;}
//一下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);
}
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;
private:
iterator __insert(base_ptr x, base_ptr y,const value_type& v);
link_type __copy(link_type x, link_type p);
void __erase(link_type x);
//初始化，给header申请一个节点的内存，让root(header->parent)为0，让左右最值都为header,并设置成红色
void init()
{
header = get_node();
color(header) = __rb_tree_red;
root() =;
leftmost() = header;
rightmost() =header;
}
public:
rb_tree(const Compare& comp=Compare()
: node_count(), 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);
public:
//各种基础操作
Compare key_comp()const {return key_compare;}
iterator begin() {return leftmost();}
iterator end() {return header;}
bool empty()
;}
size_type size()const {return node_count;}
size_type max_size());}
public:
pair<iterator,bool> insert_unique(const value_type& x);
};