红黑树（BTree）

一、红黑树

1. 红黑树的概念及性质

概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

性质

1. 每个结点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点
个数的两倍？

2、红黑树节点的定义（描述）

enum colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_col(RED)
	{}
};

思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？

3、红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

1. 按照二叉搜索的树规则插入新节点；
2. 检测新节点插入后，红黑树的性质是否造到破坏；

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何
性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连
在一起的红色节点，此时需要对红黑树分情况来讨论：
约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

情况一: cur为红，p为红，g为黑，u存在且为红
解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整，具体操作见下图：

情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑
说明u的两种情况：

1. 如果u不存在，则cur一定是新插入的节点，因为如果cur不是新插入的节点，那么cur和p一定有一个节点是黑色的，那么就不满足性质4：每条路径的所有黑色节点数量相同
2. 如果u存在且其颜色也为黑色，那么cur原来一定是黑色，现在看到红色是由黑色变过来的

情况二会有四种子情况，不同的解决方式也不同，具体见下图：

大情况	具体小情况	解决方式
u存在且为红	cur为红，p为红，g为黑，u存在且为红	将p,u改为黑，g改为红，然后把g当成cur，继续向上调整
u不存在或u存在且为黑	p为g的左孩子，cur为p的左孩子 （LL型）	以g做右单旋转，p变黑，g变红
	p为g的左孩子，cur为p的右孩子（LR型）	p做左单旋转，转化为LL型，然后g做右单旋，cur变黑，g变红
	p为g的右孩子，cur为p的右孩子（RR型）	以g做左单旋转，p变黑，g变红
	p为g的右孩子，cur为p的左孩子（RL型）	p做右单旋转，转化为RR型，然后g做左单旋，cur变黑，g变红

代码实现：

	bool Insert(const pair<K, V>& kv)
	{
		if (nullptr == _root)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while(cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		cur->_col = RED;
		if (parent->_kv.first < kv.first)
		{
			
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

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

					cur = grandfather;
					parent = cur->_parent;
				}
				else// (nullptr == uncle || uncle && uncle->_col == BLACK)
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);//右单旋
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateL(parent);//左单旋
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else// (nullptr == uncle || uncle && uncle->_col == BLACK)
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
			}
			_root->_col = BLACK;
		}
		return true;
	}

左 、右单旋不清楚，请移步至AVL树

4、红黑树的验证

红黑树的检测分为两步：

1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)

2. 检测其是否满足红黑树的性质

	void Height()
	{
		cout << "最大高度为::" << _maxheight(_root) << endl;
		cout << "最小高度为::" << _minheight(_root) << endl;
	}
	bool IsValidRBTree()
	{
		if (nullptr == _root)
			return true;

		if (_root->_col != BLACK)
			//如果根节点不为黑色，则违反性质 2、根节点是黑色的
			return false;

		Node* cur = _root;
		size_t BlackCount = 0;
		size_t k = 0;
		//记录最左路路径的黑色节点个数
		while (cur)
		{
			if (cur->_col == BLACK)
				BlackCount++;
			cur = cur->_left;
		}

		return _IsValidRBTree(_root,BlackCount,k);//检查性质3和4
	}

int _maxheight(Node* root)
	{
		if (nullptr == root)
			return 0;

		int leftheight = _maxheight(root->_left);
		int rightheight = _maxheight(root->_right);

		return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
	}

	int _minheight(Node* root)
	{
		if (nullptr == root)
			return 0;

		int leftheight = _maxheight(root->_left);
		int rightheight = _maxheight(root->_right);

		return leftheight < rightheight ? leftheight + 1 : rightheight + 1;
	}

	bool _IsValidRBTree(Node* root,const size_t BlackCount, size_t k)
	{
		if (nullptr == root)
		{
			if (k != BlackCount)
				return false;
			return true;
		}

		if (root->_col == BLACK)
			++k;

		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "违法了不可存在连续的红节点的性质" << endl;
			return false;
		}		

		return _IsValidRBTree(root->_left, BlackCount, k) && _IsValidRBTree(root->_right, BlackCount, k);//递归判断每一条路径
	}