【C++】红黑树的插入实现

前言
本篇文章中红黑树的插入用到左单旋和右单旋在AVL树的插入中已经有做了很详细的介绍了，如果有不清楚可以在熟悉熟悉，链接如下。如果对左单旋和右单旋都很熟悉的就可以阅读本篇文章了。

【C++】AVL树的插入实现

红黑树的概念

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

红黑树的性质

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

为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？
根据上面的性质可以做出以下结论
最短路径是：全黑
最长路径是：一黑一红

红黑树节点的定义

代码演示

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)//如果是黑色，所以路径都要调整，才能满足红黑树的特点。
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv);
private:
	Node* _root = nullptr;
};

在节点的定义中，为什么要将节点的默认颜色给成红色的？
因为如果定义为黑色结点，那整个树的所有路径都需要改变，红黑树要求每条路径上都有相同数目的黑色结点。

红黑树的插入操作

代码演示

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);
		if (parent->_kv.first < cur->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		//链接父结点
		cur->_parent = parent;
		//检测新节点插入后，红黑树的性质是否造到破坏
		return true;
	}

检测新节点插入后，红黑树的性质是否造到破坏
因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整 ; 但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点， 此时需要对红黑树分情况来讨论：

约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

当p(父节点)在g(祖父节点)左子树grandfather->_left == parent

情况一: cur为红cur == parent->left，p为红，g为黑，u存在且为红

情况二: cur为红cur == parent->_left，p为红，g为黑，u不存在/u存在且为黑

情况三: cur为红cur == parent->_right，p为红，g为黑，u不存在/u存在且为黑

下面的和上面的情况一相似只是方向不一样。

当p(父节点)在g(祖父节点)右子树grandfather->_right == parent

情况一: cur为红cur == parent-_right，p为红，g为黑，u存在且为红

情况二: cur为红cur == parent->_right，p为红，g为黑，u不存在/u存在且为黑

情况三: cur为红cur == parent->_left，p为红，g为黑，u不存在/u存在且为黑

代码演示

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);
	if (parent->_kv.first < cur->_kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	//链接父结点
	cur->_parent = parent;

	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		if (grandfather->_left == parent)
		{
			Node* uncle = grandfather->_right;
			//情况一: cur为红，p为红，g为黑，u存在且为红
			//            g(黑)
			//     p(红)        u(红)
			//c(红)
			//解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。
			//            g(红)
			//     p(黑)        u(黑)
			//c(红)
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
			//cur为红，p为红，g为黑，u不存在/u存在且为黑
			
				if (cur == parent->_left)//cur插入在parent的左边
				{
			// u不存在
			//            g(黑)
			//     p(红)        
			//c(红)
			// 解决方式：则进行右单旋转
			//            p(黑)
			//     c(红)        g(红)
			// -------------------------------------------------
			//u存在且为黑（一定是由情况一变换而来的），p的右子树和c的左右子树一定存在，并且都存在黑结点
			//              g(黑)
			//        p(红)       u(黑) 
			//   c(红)
			// 解决方式：则进行右单旋转
			//            p(黑)
			//     c(红)        g(红)
			//                        u(黑)
					RotateR(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
					//cur->_col = RED;
				}
				else//cur插入在parent的右边
				{
			// u不存在
			//            g(黑)
			//     p(红)        
			//         c(红)
			//解决方式：p点进行左单选，g点进行右单选
			//左单选       g(黑)
			//     c(红)        
			//p(红)
			//右单选       
			//     c(黑)        
			//p(红)      g(红)
			//---------------------------------------------------------------------
			// u存在
			//              g(黑)
			//     p(红)            u(黑) 
			//          c(红)
			//解决方式：p点进行左单选，g点进行右单选
			//左单选       g(黑)
			//     c(红)           u(黑)
			//p(红)
			//右单选       
			//     c(黑)        
			//p(红)      g(红)
			//		          u(黑)
					RotateL(parent);
					RotateR(grandfather);
					grandfather->_col = RED;
					//parent->_col = RED;
					cur->_col = BLACK;
				}
				break;
			}
		}
		else//grandfather->_right == parent
		{
			Node* uncle = grandfather->_left;
			
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				if (cur == parent->_right)
				{
					RotateL(grandfather);//RotateR
					grandfather->_col = RED;
					parent->_col = BLACK;
					//cur->_col = RED;
				}
				else
				{

					RotateR(parent);
					RotateL(grandfather);
					grandfather->_col = RED;
					//parent->_col = RED;
					cur->_col = BLACK;
				}

				break;
			}
		}
	}

	_root->_col = BLACK;
	return true;
}

//右子树高，进行左单旋
void RotateL(Node* parent)
{
	Node* childR = parent->_right;
	Node* childRL = childR->_left;

	parent->_right = childRL;
	if (childRL)//如果childRL不为空，要链接父节点
		childRL->_parent = parent;

	Node* pparent = parent->_parent;
	childR->_left = parent;
	parent->_parent = childR;

	if (nullptr == pparent)//说明是根结点
	{
		_root = childR;
		//_root->_parent = nullptr;
		childR->_parent = nullptr;
	}
	else
	{
		if (pparent->_left == parent)
		{
			pparent->_left = childR;
		}
		else
		{
			pparent->_right = childR;
		}

		childR->_parent = pparent;//链接父结点
	}
}
//左子树高，进行右单旋
void RotateR(Node* parent)
{
	Node* childL = parent->_left;
	Node* childLR = childL->_right;

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

	Node* pparent = parent->_parent;
	childL->_right = parent;
	parent->_parent = childL;

	if (_root == parent)//说明是根结点
	{
		_root = childL;
		_root->_parent = nullptr;
	}
	else
	{
		if (pparent->_left == parent)
		{
			pparent->_left = childL;
		}
		else
		{
			pparent->_right = childL;
		}

		childL->_parent = pparent;//链接父结点
	}
}