浅析平衡搜索树之——红黑树

红黑树概念

红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是Red或Black。通过对任何一条从根到叶子简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似于平衡。

特性如下：

1. 每个节点，不是红色就是黑色的
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个子节点是黑色的

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

本文主要介绍红黑树的插入。

红黑树的插入主要分为两大种情况：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

第一种：父亲节点p是祖父节点g的左孩子（分两种情况）

①cur为红，p为红，g为黑，u存在且为红->将p,u改为黑，g改为红，然后把g当成cur，继续向上调整:

②cur为红，p为红，g为黑，u不存在/u为黑->p、g变色--p变黑，g变红：(分两种情况)

A. cur为p的左孩子，进行右单旋转：

B. cur为p的右孩子，进行左右双旋（其实是先进行左旋转换为A情况，在进行右旋）：

第二种：父亲节点p是祖父节点g的右孩子（分两种情况）

①cur为红，p为红，g为黑，u存在且为红->将p,u改为黑，g改为红，然后把g当成cur，继续向上调整:

②cur为红，p为红，g为黑，u不存在/u为黑->p、g变色--p变黑，g变红：(分两种情况)

A.cur为p的右孩子，进行左单旋转：

B.cur为p的左孩子，进行右左双旋（其实是先进行右旋，转换成A的情况）

最后看一下总体逻辑图：

红黑树的判断：

对于判端一棵树是否是红黑树，其实思路很简单，就是判断红黑树以及它的子树是否满足上述红黑树的特点就好了。

所以，总结下来也就是：

• 根节点为黑色

• 没有连续红色节点

• 每条路径上有相同的黑色节点数

当满足这三个条件的时候，我们就可以认为这棵树是合法的红黑树。

源代码：（没有插入的代码，后面会更新）

#include<iostream>
#include<utility>
using namespace std;


enum Color
{
	RED,
	BLACK
};

template<class K>
struct RBTreeNode
{
	RBTreeNode<K>* _left;
	RBTreeNode<K>* _right;
	RBTreeNode<K>* _parent;
	K _key;
	Color _color;

	RBTreeNode(const K key)
		:_left(NULL)
		, _right(NULL)
		, _parent(NULL)
		, _key(key)
		, _color(RED)
	{}
};

template<class K>
class RBTree
{
	typedef RBTreeNode<K> Node;
public:
	RBTree()
		: _root(NULL)
	{}

	bool Insert(const K& key)
	{
		if (_root == NULL)//如果根节点为空则直接插入
		{
			_root = new Node(key);
			_root->_color = BLACK;
		}

		Node* cur = _root;
		Node* parent = NULL;
		//寻找插入位置
		while (cur)
		{
			if (key < cur->_key)//插入节点比当前节点小，向左走
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)//插入节点比当前节点大，向左走
			{
				parent = cur;
				cur = cur->_right;
			}
			else//插入节点与当前节点相等，说明该树含有该值，直接返回
			{
				return false;
			}
		}

		//程序走到这里说明找到了需要插入的位置
		//需要判断插入左边还是右边
		cur = new Node(key);
		if (key < parent->_key)//小于父节点，插左边
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else//大于父节点，插右边
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		//插完节点后要判断平衡，并进行调整
		while (parent && parent->_color == RED)
		{
			Node* pparent = parent->_parent;//用来记录祖先节点

			//parent为祖先节点的左孩子
			if (parent == pparent->_left)
			{
				Node* uncle = pparent->_right;//用来记录叔叔节点

				if (uncle && uncle->_color == RED)//叔叔存在且为红
				{
					parent->_color = uncle->_color = BLACK;//将父节点和叔叔节点置黑
					pparent->_color = RED;//祖先节点
					cur = pparent;//向上回溯
					parent = cur->_parent;
				}
				else//叔叔不存在或叔叔为黑——又分为两种情况①cur为parent的左，进行右单旋
								    //②cur为parent的右，进行左右双旋
				{
					if (cur == parent->_right)//cur为parent的右
					{
						RotateL(parent);//左旋
						swap(parent,cur);
					}
					RotateR(pparent);//右旋
					parent->_color = BLACK;
					pparent->_color = RED;
				}
			}
			//parent为祖先节点的右孩子
			else
			{
				Node* uncle = pparent->_right;//记录叔叔节点
				if (uncle && uncle->_color == RED)//叔叔存在且为红
				{
					parent->_color = uncle->_color = BLACK;//将父节点和叔叔节点置黑
					pparent->_color = RED;//祖先节点
					cur = pparent;//向上回溯
					parent = cur->_parent;
				}
				else//叔叔不存在或叔叔为黑——又分为两种情况①cur为parent的右，进行左单旋
							           //②cur为parent的左，进行右左双旋
				{
					if (cur == parent->_left)//cur为左孩子
					{
						RotateR(parent);
						swap(parent, cur);
					}

					RotateL(pparent);
					parent->_color = BLACK;
					pparent->_color = RED;
				}
			}
		}
		_root->_color = BLACK;//根节点一定要为黑
		return true;
	}

	//右单旋
	void RotateR(Node* parent)
	{
		Node* SubL = parent->_left;
		Node* SubLR = SubL->_right;
		Node* pparent = parent->_parent;

		parent->_left = SubLR;
		if (SubLR)//判断SubLR是否存在——这是一个三叉连要保证父子相连
			SubLR->_parent = parent;

		SubL->_right = parent;
		parent->_parent = SubL;
		//再判断parent是否为根节点
		if (pparent == NULL)//parent是根节点
		{
			_root = SubL;
		}
		else//不是根节点
		{
			//还需判断parent是祖先节点的左孩子还是右孩子
			if (parent == pparent->_left)//左孩子
			{
				pparent->_left = SubL;
			}
			else//右孩子
			{
				pparent->_right = SubL;
			}
			SubL->_parent = pparent;//保证父子相连
		}
		_root->_parent = NULL;
	}

	//左单旋
	void RotateL(Node* parent)
	{
		Node* SubR = parent->_right;
		Node* SubRL = SubR->_left;
		Node* pparent = parent->_parent;

		parent->_right = SubRL;
		if (SubRL)//判断SubRL是否存在
			SubRL->_parent = parent;//保证父子相连

		SubR->_left = parent;
		parent->_parent = SubR;
		//判断parent是否为根节点
		if (pparent)//是根节点
		{
			_root = SubR;
		}
		else//不是根节点
		{
			//再判断parent是根节点的左孩子还是右孩子
			if (pparent->_left == parent)//左孩子
			{
				pparent->_left = SubR;
			}
			else//右孩子
			{
				pparent->_right = SubR;
			}
			SubR->_parent = pparent;//保证父子相连
		}
		_root->_parent= NULL;
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}

	void _Inorder(Node* root)
	{
		if (root == NULL)
			return;

		if (root)
		{
			_Inorder(root->_left);
			cout << root->_key<<" ";
			_Inorder(root->_right);
		}
	
	}

	bool IsBalance()//判断方法——①每条路径上黑节点的数量相等②不存在连续的红节点③根节点不为红
	{
		if (_root && _root->_color == Red)//根节点为红
		{
			return false;
		}

		int k = 0;//用来记录最左路径上的黑节点
		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == BLACK)
				++k;
			cur = cur->_left;//一直向左走
		}

		int blacknum = 0;//用来记录其他路径上黑节点的个数和k进行比较
		return _IsBalance(_root,k,blacknum);
	}

	bool _IsBalance(Node* cur,int k,int blacknum)
	{
		if (cur == NULL)//一条路径
		{
			if (k != blacknum)//判断两条路径的黑节点是否相等
			{
				cout << "黑节点个数不同" << endl;
				return false;
			}
			return true;
		}
	
		//再判断是否存在连续的红节点
		if (cur->_color == RED && cur->_parent->_color == RED)
			return false;

		if (cur->_color == BLACk)
			++blacknum;

		return _IsBalance(cur->_left, k, blacknum)
			&& _IsBalance(cur->_right,k,blacknum);
	}

	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else//找到目标值
			{
				return true;
			}
		}
		return false;
	}

private:
	Node* _root;
};