红黑树

红黑树

     红黑树也是二叉搜索树，只是每个结点增加颜色表示。

     红黑树有以下规则：

1. 每个结点不是red就是black

2. 根结点为black

3. 若结点为red，则它的两个子节点为black

4. 从每一条路径（根到叶）均有相同数目的black

*红黑树保证最长路径不超过最短路径的两倍

二叉树在插入时的几种需要转换的情况：

情况1

情况2

情况3：

代码实现；

enum color
{
	RED,
	BLACK,
};

template

struct RBTreeNode
{

	K _key;
	V _value;

	RBTreeNode *_left;
	RBTreeNode * _right;
	RBTreeNode * _parent;
	
	color _col;

	RBTreeNode(const K&key,const V&value)
		:_key(key)
		, _value(value)
		, _left(NULL)
		, _right(NULL)
		, _parent(NULL)
		, _col(RED)
	{}
};
template
class RBTree
{
public:
	RBTree()
		:_root(NULL)
	{}
	bool Insert(const K& key, const V& value)
	{
		if (_root == NULL)
		{
			_root = new RBTreeNode(key, value);
			_root->_col = BLACK;
			return true;
		}
		RBTreeNode* parent = NULL;
		RBTreeNode* cur = _root;
		while (cur)//找到要插入的位置
		{
			parent = cur;
			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else
				return false;
		}
		cur = new RBTreeNode(key, value);
		if (parent->_key>key)
		{
			parent->_left=cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		while (cur != _root&&parent->_col == RED)//cur!=_root则父节点一定存在，若父节点的颜色为red则一定不是根结点
		{
			RBTreeNode *grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				RBTreeNode*uncle = grandfather->_right;
				if (uncle&&uncle->_col == RED)
				{
					//情况1
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2和情况3
				{
					if (parent->_right==cur)
					{
						_RotateL(parent);
						swap(cur, parent);
					}
					
					parent->_col = BLACK;
					grandfather->_col = RED;
					_RotateR(grandfather);
				}
			}
			else
			{
				RBTreeNode*uncle = grandfather->_left;
				if (uncle&&uncle->_col == RED)
				{
					uncle->_col = BLACK;
					parent->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						_RotateR(parent);
						parent->_col = BLACK;
						grandfather->_col = RED;
						_RotateL(grandfather);
					}
					_root->_col = BLACK;
					return true;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
protected:
	void _Inorder(RBTreeNode*root)
	{
		if (root == NULL)
			return;
		_Inorder(root->_left);
		cout << _root->_key << " ";
		_Inorder(_root->_right);
	}
	void _RotateL(RBTreeNode*parent)
	{
		RBTreeNode*subR = parent->_right;
		RBTreeNode*subRL = subR->_left;

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

		subR->_left= parent;
		RBTreeNode*ppNode = parent->_parent;
		parent->_parent = subR;
		subR->_parent = ppNode;
		if (ppNode == NULL)
		{
			_root = subR;
		}
		else
		{
			if (ppNode->_left == parent)
				ppNode->_left = subR;
			else
				ppNode->_right = subR;
		}
	}
	void _RotateR(RBTreeNode*parent)
	{
		RBTreeNode*subL = parent->_left;
		RBTreeNode*subLR = subL->_right;

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

		subL->_right = parent;
		RBTreeNode*ppNode = parent->_parent;
		parent->_parent = subL;
		subL->_parent = ppNode;
		if (ppNode == NULL)
			_root = subL;
		else
		{
			if (ppNode->_left == parent)
				ppNode->_left = subL;
			else
				ppNode->_right = subL;
		}
	}
private:
	RBTreeNode *_root;

};