【C++】红黑树的调整

红黑树（Red-Black Tree）是一种自平衡的二叉搜索树，通过颜色约束 + 旋转 + 变色 来保证树的高度始终为 O(logn)。插入和删除后可能破坏红黑性质，需进行调整（fixup）。

红黑树要满足以下几个条件：

根节点为黑色
红色节点的孩子必须是黑色节点
任意一条路径上的黑色节点数量相等
最长路径上的节点数量不超过最短路径节点数量的两倍

接下来就来详细介绍红黑树旋转 + 变色的几种情况。

一、叔节点 u 是红色

cpp 复制代码

       g(B)                g(R)
      /    \              /    \
   p(R)    u(R)   →    p(B)    u(B)
   /                   /
 z(R)               z(R)

这时只需要将grandpa变为红色，parent和uncle介蒂安变为黑色。由于grandpa节点变成红色，此时需要继续向上检查。

二、叔节点为黑色或为空

在这种情况下就会变得复杂得多，涉及到旋转和变色。

2.1、RR型

cpp 复制代码

   g(B)                     p(B)
  /    \                   /    \
u(B)  p(R)      →       g(R)   z(R)
        \               /
       z(R)          u(B)

叔节点为黑色或为空时，在RR型中需要将grandpa节点进行左旋，并且将parent节点变成黑色grandpa节点变成红色。注意这里由于parent节点已经变成黑色，不需要再向上进行调整。

2.2、RL型

cpp 复制代码

   g(B)                g(B)                   z(B)
  /    \              /    \                 /    \
u(B)  p(R)   →      u(B)  z(R)    →       g(R)   p(R)
      /                       \            /
    z(R)                     p(R)       u(B)

叔节点为黑色或为空时，在RL型中需要先将parent节点进行右旋转化为RR型，再对grandpa节点进行左旋。同时z节点变成黑色，grandpa节点变成红色。

2.3、LL型

cpp 复制代码

       g(B)                 p(B)
      /    \               /    \
   p(R)    u(B)   →     z(R)   g(R)
   /                             \
 z(R)                           u(B)

叔节点为黑色或为空时，在LL型中需要将grandpa节点进行右旋，并且将parent节点变成黑色grandpa节点变成红色。注意这里由于parent节点已经变成黑色，不需要再向上进行调整。

2.4、LR型

cpp 复制代码

       g(B)                  g(B)                 z(B)
      /    \                /    \               /    \
   p(R)    u(B)   →      z(R)    u(B)   →    p(R)   g(R)
      \                  /                          \
     z(R)             p(R)                        u(B)

叔节点为黑色或为空时，在LR型中需要先将parent节点进行左旋转化为LL型，再对grandpa节点进行右旋旋。同时z节点变成黑色，grandpa节点变成红色。

三、旋转与变色总结

况	叔叔颜色	当前节点位置	操作
Case 1	红色	任意	变色（p, u → 黑；g → 红），继续向上
Case 2	黑色	外侧（LL/RR）	单旋 + 变色（p 与 g 交换颜色）
Case 3	黑色	内侧（LR/RL）	双旋 + 变色（先转外侧，再单旋）

四、代码实现

cpp 复制代码

#include<iostream>

using namespace std;
enum color
{
	RED, BLACK
};

template<class T>
class RBNode {
public:
	RBNode(const T& val=T()):
		date(val),
		_parent(nullptr),
		_left(nullptr),
		_right(nullptr),
		col(RED)
	{

	}
	T date;
	RBNode<T>* _parent;
	RBNode<T>* _left;
	RBNode<T>* _right;
	color col;
};

template<class T>
class RBTree {
public:
	typedef RBNode<T> Node;
	RBTree():_root(nullptr){}



	void insert(const T& x)
	{
		//插入节点
		Node* cur = _root, * parent = nullptr, * nn = new Node(x);
		while (cur)
		{
			parent = cur;
			if (x < cur->date) { cur = cur->_left; }
			else
			{
				cur = cur->_right;
			}
		}
		if (parent == nullptr)//如果是空树
		{
			_root = nn;
		}
		else
		{
			nn->_parent = parent;
			if (nn->date < parent->date) parent->_left = nn;
			else
			{
				parent->_right = nn;
			}
			cur = nn;
		}

		//修善红黑树
		while (parent && parent->col == cur->col && cur->col == RED)
		{
			Node* uncle;
			Node* grandpa = parent->_parent;
			if (grandpa)
			{
				if (parent == grandpa->_left)
				{
					uncle = grandpa->_right;
					if (uncle && uncle->col == RED)//uncle是红色
					{
						grandpa->col = RED;
						parent->col = uncle->col = BLACK;
						cur = grandpa;
						parent = cur->_parent;
						if (parent) grandpa = parent->_parent;
						else
						{
							grandpa = nullptr;
						}
					}
					else
					{
						if (cur == parent->_left)
						{
							rotateRight(grandpa);
							parent->col = BLACK;
							grandpa->col = RED;
						}
						else
						{
							rotateLeft(parent);
							rotateRight(grandpa);
							cur->col = BLACK;
							grandpa->col = RED;
						}
						break;
					}
				}
				else
				{
					uncle = grandpa->_left;
					if (uncle && uncle->col == RED)//uncle是红色
					{
						grandpa->col = RED;
						grandpa->col = RED;
						parent->col = uncle->col = BLACK;
						cur = grandpa;
						parent = cur->_parent;
						if (parent) grandpa = parent->_parent;
						else
						{
							grandpa = nullptr;
						}
					}
					else
					{
						if (cur == parent->_right)
						{
							rotateLeft(grandpa);
							parent->col = BLACK;
							grandpa->col = RED;
						}
						else
						{
							rotateRight(parent);
							rotateLeft(grandpa);
							cur->col = BLACK;
							grandpa->col = RED;
						}
						break;
					}
				}

			}
		}
		_root->col = BLACK;//根节点常置为black
	}

	void rotateLeft(Node* node)
	{
		Node* parent = node->_parent, * rc = node->_right, * rlc = node->_right->_left;
		node->_right = rlc;
		if (rlc) rlc->_parent = node;
		rc->_left =node;
		node->_parent = rc;
		if (parent == nullptr)
		{
			rc->_parent = nullptr;
			_root = rc;
		}
		else
		{
			rc->_parent = parent;
			if (parent->_left == node)
			{
				parent->_left = rc;
			}
			else
			{
				parent->_right = rc;
			}
		}
	}

	void rotateRight(Node* node)
	{
		//      node
		//   lc
		//      lrc
		Node* parent = node->_parent, * lc = node->_left, * lrc = node->_left->_right;
		node->_left = lrc;
		if (lrc) lrc->_parent = node;
		lc->_right = node;
		node->_parent = lc;
		if (parent == nullptr)
		{
			lc->_parent = nullptr;
			_root = lc;
		}
		else
		{
			if (parent->_left == node)
			{
				parent->_left = lc;
				lc->_parent = parent;
			}
			else
			{
				parent->_right = lc;
				lc->_parent = parent;
			}
		}
	}

	void InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		InOrder(root->_left);
		//cout << root->_date << " ";
		cout << root->_date <<"##";

		InOrder(root->_right);
	}

	void PreOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		cout << root->_date << "##";
		PreOrder(root->_left);
		PreOrder(root->_right);
	}
	Node* getRoot()
	{
		return _root;
	}
	bool isRBTree()
	{
		return isRBTree(_root, 0);
	}


private:
	bool isRBTree(Node* node, int cb)
	{
		if (node == nullptr)
		{
			if (cb == countBlack()) return true;
			else
			{
				return false;
			}
		}
		if (node->col == RED && node->_parent->col == RED)
		{
			return false;
		}
		int i = 0;
		if (node->col == BLACK) i++;
		return isRBTree(node->_left, cb + i) && isRBTree(node->_right, cb + i);
	}
	int countBlack()
	{
		int count = 0;
		Node* tmp = _root;
		while (tmp)
		{
			if (tmp->col == BLACK)
			{
				count++;
			}
			tmp = tmp->_right;
		}
		return count;
	}
	Node* _root;

};