树

/*二叉搜索树
任何节点的键值一定大于其左子树并小于其右子树
１：插入－－从根节点开始，遇键值较大则向左，键值较小就向右，知道尾端。

２：删除－－１）目标结点只有一个子节点：直接将其子节点连到其父节点
－－２）目标结点有２个子节点：以右子树中的最小值取而代之
*/

/*平衡二叉搜索树
１：ＡＶＬ tree:保证整数深度为Ｏ（ｌｏｇＮ），要求任何节点的左右子树高度相差最多１
当插入节点后，平衡被破坏：
１）插入点位于根节点左节点的左子树－－左左
２）插入点位于根节点右节点的左子树－－右右
３）插入点位于根节点左节点的右子树－－左右
４）插入点位于根节点右节点的左子树－－右左

１）２）采用单旋转解决
３）４）采用双旋转解决

（１）－－单旋转：向左或向右下降根节点，再根据平衡二叉树平衡条件调整。修正外侧插入导致的不平衡
（２）－－双旋转：两次单旋转（子树旋转等），修正内测插入导致的不平衡

２：ＲＢ－ｔｒｅｅ
规则：１）节点不为黑就为红
　２）根节的为黑
　３）若结点为红其子节点必为黑
４）任意节点到ＮＵＬＬ的任何路径，所含黑节点数必同 。－－新增点必为红其父节点必为黑

*/

//SGI STL代码
//节点设计
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)
{
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 <class Value>
struct __rb_tree_node : __rb_tree_node_base
{
typedef __rb_tree_node<Value>* link_type;
Value value_field;
}
};

//迭代器
//基层迭代器
struct __rb_tree_base_iterator
{
typedef __rb_tree_node_base::base_ptr base_ptr;
typedef bidirectional_iterator_tag iterator_category;
typedef ptrdiff_t difference_typedef;
base_ptr node;

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;
}
}

//减少节点
void decrement()
{
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;
}
}
};

//RB-tree正规迭代器
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;
typedef __rb_tree_node<Value>* link_type;

__rb_tree_iterator() {}
__rb_tree_iterator(link_type x) { node = x; }
__rb_tree_iterator(const iterator& it) { node = it.node; }

reference operator*() const { return link_type(node)->value_filed; }
pointer operator->() const { return &(operator*()); }
self& operator++() const { increment(); return *this; }
self operator++(int)
{
self tmp = *this;
increment();
return tmp;
}
self& operator--() const { decrement(); return *this; }
self operator--(int)
{
self tmp = *this;
decrement();
return tmp;
}
};

//数据结构
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,Allco> rb_tree_node_allocator;
typedef __rb_tree_color_type color_type;
public:
typedef Key
};