RBTree

#pragma once


enum Colour
{
RED,
BLACK,
};


template<class ValueType>
struct RBTreeNode
{
ValueType _valueField;


RBTreeNode<ValueType>* _left;
RBTreeNode<ValueType>* _right;
RBTreeNode<ValueType>* _parent;


Colour _col;


RBTreeNode(const ValueType& v)
:_valueField(v)
,_left(NULL)
,_right(NULL)
,_parent(NULL)
,_col(RED)
{}
};


template<class ValueType>
struct __TreeIterator
{
typedef RBTreeNode<ValueType> Node;
typedef __TreeIterator<ValueType> Self;


Node* _node;


__TreeIterator(Node* node)
:_node(node)
{}


ValueType& operator*()
{
return _node->_valueField;
}


ValueType* operator->()
{
//return &_node->_valueField;
return &(operator*());
}


bool operator==(const Self& s)
{
return _node == s._node;
}


bool operator!=(const Self& s)
{
return _node != s._node;
}


Self& operator++()
{
if (_node->_right)
{
Node* subRight = _node->_right;
while (subRight->_left)
{
subRight = subRight->_left;
}


_node = subRight;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && cur == parent->_right)
{
cur = parent;
parent = cur->_parent;
}


_node = parent;
}


return *this;
}


Self operator++(int)
{
Self tmp(*this);


++(*this);


return tmp;
}


Self operator--()
{
if (_node->_left)
{
Node* subLeft = _node->_left;
while (subLeft->_right)
{
subLeft = subLeft->_right;
}


_node = subLeft;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;


while (parent && cur == parent->_left)
{
cur = parent;
parent = cur->_parent;
}


_node = parent;
}


return *this;
}


Self operator--(int)
{
Self tmp(*this);


--(*this);


return tmp;
}
};




template<class K, class V, class KeyOfValue>
class RBTree
{
typedef V ValueType;
typedef RBTreeNode<ValueType> Node;
public:
typedef __TreeIterator<ValueType> Iterator;


RBTree()
:_root(NULL)
{}


Iterator Begin()
{
Node* leftLeft = _root;
while (leftLeft && leftLeft->_left)
{
leftLeft = leftLeft->_left;
}


//return Iterator(leftLeft);
return leftLeft;
}


Iterator End()
{
return NULL;
}


Iterator RBegin()
{
Node* rightRight = _root;
while (rightRight && rightRight->_right)
{
rightRight = rightRight->_right;
}


return rightRight;
}


Iterator REnd()
{
return NULL;
}


pair<Iterator, bool> Insert(const ValueType& v)
{
if (_root == NULL)
{
_root = new Node(v);
_root->_col = BLACK;
return make_pair(Iterator(_root), true);
}


KeyOfValue keyOfValue;
Node* parent = NULL;
Node* cur = _root;
while(cur)
{
if (keyOfValue(cur->_valueField) < keyOfValue(v))//
{
parent = cur;
cur = cur->_right;
}
else if (keyOfValue(cur->_valueField) > keyOfValue(v))
{
parent = cur;
cur = cur->_left;
}
else
{
return make_pair(Iterator(cur), false);
}
}


cur = new Node(v);
Node* newNode = cur;


if (keyOfValue(parent->_valueField) < keyOfValue(v))
{
parent->_right = cur;
cur->_parent = parent;
}
else
{
parent->_left = cur;
cur->_parent = parent;
}


while (parent && parent->_col == RED)
{
Node* grandfther = parent->_parent;
if (parent == grandfther->_left)
{
Node* uncle = grandfther->_right;
if (uncle && uncle->_col == RED)
{
parent->_col = BLACK;
uncle->_col = BLACK;
grandfther->_col = RED;


cur = grandfther;
parent = cur->_parent;
}
else // u 不存在 u黑
{
if(cur == parent->_right) // 双旋
{
RotateL(parent);
swap(parent, cur);
}


RotateR(grandfther);
parent->_col = BLACK;
grandfther->_col = RED;
break;
}
}
else // parent == grandfther->_right
{
Node* uncle = grandfther->_left;
if (uncle && uncle->_col == RED)
{
uncle->_col = parent->_col = BLACK;
grandfther->_col = RED;


cur = grandfther;
parent = cur->_parent;
}
else // u不存在/存在且黑
{
if (cur == parent->_left)
{
RotateR(parent);
swap(parent, cur);
}


RotateL(grandfther);
grandfther->_col = RED;
parent->_col = BLACK;


break;
}
}
}


_root->_col = BLACK;
return make_pair(Iterator(newNode), true);
}


Iterator Find(const K& key)
{
KeyOfValue keyOfValue;
Node* cur = _root;
while (cur)
{
if (keyOfValue(cur->_valueField) > key)
{
cur = cur->_left;
}
else if (keyOfValue(cur->_valueField) < key)
{
cur = cur->_right;
}
else
{
return Iterator(cur);
}
}


return Iterator(NULL);
}


void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;


parent->_right = subRL;
if(subRL)
subRL->_parent = parent;


subR->_left = parent;
Node* parentParent = parent->_parent;
parent->_parent = subR;


if (parentParent == NULL)
{
_root = subR;
subR->_parent = NULL;
}
else
{
if (parentParent->_left == parent)
parentParent->_left = subR;
else
parentParent->_right = subR;


subR->_parent = parentParent;
}
}


void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;


parent->_left = subLR;
if(subLR)
subLR->_parent = parent;


subL->_right = parent;
Node* parentParent = parent->_parent;
parent->_parent = subL;


if (parentParent == NULL)
{
_root = subL;
subL->_parent = NULL;
}
else
{
if (parentParent->_left == parent)
parentParent->_left = subL;
else
parentParent->_right = subL;


subL->_parent = parentParent;
}
}


private:
Node* _root;
};


一、红黑树的性质：

1、每个节点不是红色就是黑色

2、根节点是黑色

3、如果一个节点是红色，则它的两个子节点是黑色

4、对每个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点

void TestRBTree()
{
/*RBTree<int, int> rbSet;
rbSet.Insert(3);
rbSet.Insert(0);
rbSet.Insert(2);
rbSet.Insert(1);


RBTree<int, int>::Iterator sIt = rbSet.Begin();
while (sIt != rbSet.End())
{
cout<<*sIt<<" ";
++sIt;
}
cout<<endl;


RBTree<int, int>::Iterator srIt = rbSet.RBegin();
while (srIt != rbSet.REnd())
{
cout<<*srIt<<" ";
--srIt;
}
cout<<endl;*/
}