引言

我前面的博客中有写到AVL树，AVL树的优点是查询效率很高，但是AVL树也有显著的劣势，当进行插入的时候，由于平衡因子的限制，会旋转很多次，从而导致性能十分低下。那么我们需要引入一个更好的数据结构，红黑树就应运而生。

红黑树的概念

红黑树实际上也是一个二次搜索树，但在每一个节点上加入一个存储位表示节点的颜色。通过对于根到叶子节点的颜色限制，红黑树确保最长路径上的长度不超过最短路径的二倍。

性质

节点的颜色不是红色就是黑色
根节点一定是黑色
红色节点的孩子一定是黑色的
每个节点到叶子节点上的路径上，黑色节点的数量是相同的
每个叶子节点的颜色是黑色

为什么红黑树确保最长路径上的长度不超过最短路径的二倍。

根据性质，最短路径为全黑，最长路径为黑红相间，黑色又一样，自然就是两倍了。

红黑树节点的定义

对于一个红黑树的节点，要保证三叉链的实现，所以要有左右孩子，还有父节点，不仅如此，还要有颜色描述，节点的数据值。

// 节点的颜色

enum Color{RED, BLACK};

// 红黑树节点的定义

template<class ValueType>

struct RBTreeNode

{

RBTreeNode(const ValueType& data = ValueType()，Color color = RED)

: _pLeft(nullptr), _pRight(nullptr), _pParent(nullptr)

, _data(data), _color(color)

{}

RBTreeNode<ValueType>* _pLeft; // 节点的左孩子

RBTreeNode<ValueType>* _pRight; // 节点的右孩子

RBTreeNode<ValueType>* _pParent; // 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)

ValueType _data; // 节点的值域

Color _color; // 节点的颜色

};

为什么节点的默认颜色为红色

因为插入红色不会影响规则，插入黑色会影响对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点

红黑树的插入

我们说红黑树可以维持自平衡，那么它是如何维持自平衡的。

左旋。以某个结点作为支点(旋转结点)，其右子结点变为旋转结点的父结点，右子结点的左子结点变为旋转结点的右子结点，左子结点保持不变

2. 右旋。以某个结点作为支点(旋转结点)，其左子结点变为旋转结点的父结点，左子结点的右子结点变为旋转结点的左子结点，右子结点保持不变。

3. 变色。节点的颜色变化

再进一步

对于插入，要找到插入位置，然后进行平衡。

找到插入位置 先从根节点开始查找，把根节点设置为当前节点。key大于当前节点，右子节点就是当前节点，否则就是左子节点。

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			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 < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
      }

然后就是改变颜色控制平衡

因为新节点的默认颜色是红色，所以当双亲的颜色是黑色时就符合规则不用改变颜色，但是当双亲是黑色的时候，就违反规则了，这时就需要进行调整了。

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

cur为红，p，u为红色节点，g为黑色节点

这里如果g是根节点就变为黑色，如果不是那就继续向上调整，直到平衡为止。 2. cur为红，p为红，g为黑，u不存在或者u为黑

当u的节点不存在时，这里的cur是新节点

如果u存在时，一定是黑色的，cur节点原来的颜色一定是黑色的， p为g的左孩子，cur为p的右孩子，进行右单旋，相反进行左单旋，pg变色，p变黑，g变红。 3. cur为红，p为红，g为黑，u不存在或者u为黑

代码如下

template<class K, class T, class KeyOfT>

struct RBTree

{

typedef RBTreeNode<T> Node;

public:

typedef RBTreeIterator<T, T&, T*> iterator;



iterator begin()

{

	Node* min = _root;

	while (min && min->_left)

	{

		min = min->_left;

	}



	return iterator(min);

}



iterator end()

{

	return iterator(nullptr);

}



RBTree()

	:_root(nullptr)

{}



bool Insert(const T& data)

{

	if (_root == nullptr)

	{

		_root = new Node(data);

		_root->_col = BLACK;

		return true;

	}



	KeyOfT kot;



	Node* parent = nullptr;

	Node* cur = _root;

	while (cur)

	{

		if (kot(cur->_data) < kot(data))

		{

			parent = cur;

			cur = cur->_right;

		}

		else if (kot(cur->_data) > kot(data))

		{

			parent = cur;

			cur = cur->_left;

		}

		else

		{

			return false;

		}

	}



	cur = new Node(data);

	cur->_col = RED; // 新增节点

	if (kot(parent->_data) < kot(data))

	{

		parent->_right = cur;

		cur->_parent = parent;

	}

	else

	{

		parent->_left = cur;

		cur->_parent = parent;

	}



	// 控制平衡

	while (parent && parent->_col == RED)

	{

		Node* grandfather = parent->_parent;

		if (parent == grandfather->_left)

		{

			Node* uncle = grandfather->_right;

			// 1、uncle存在且为红

			if (uncle && uncle->_col == RED)

			{

				// 变色+继续向上处理

				parent->_col = uncle->_col = BLACK;

				grandfather->_col = RED;



				cur = grandfather;

				parent = cur->_parent;

			}

			else // 2 + 3、uncle不存在/ 存在且为黑

			{

				//        g

				//     p

				//  c



				//        g

				//     p

				//        c



				if (cur == parent->_left)

				{

					// 单旋

					RotateR(grandfather);

					parent->_col = BLACK;

					grandfather->_col = RED;

				}

				else

				{

					// 双旋

					RotateL(parent);

					RotateR(grandfather);

					cur->_col = BLACK;

					grandfather->_col = RED;

				}



				break;

			}

		}

		else // parent == grandfather->_right

		{

			Node* uncle = grandfather->_left;

			if (uncle && uncle->_col == RED)

			{

				// 变色+继续向上处理

				parent->_col = uncle->_col = BLACK;

				grandfather->_col = RED;



				cur = grandfather;

				parent = cur->_parent;

			}

			else // 2 + 3、uncle不存在/ 存在且为黑

			{

				//  g    

				//     p

				//        c



				//  g

				//     p

				//  c

				if (cur == parent->_right)

				{

					RotateL(grandfather);

					parent->_col = BLACK;

					grandfather->_col = RED;

				}

				else

				{

					RotateR(parent);

					RotateL(grandfather);

					cur->_col = BLACK;

					grandfather->_col = RED;

				}



				break;

			}

		}

	}



	_root->_col = BLACK;



	return true;

}



void RotateL(Node* parent)

{

	Node* subR = parent->_right;

	Node* subRL = subR->_left;



	parent->_right = subRL;

	if (subRL)

	{

		subRL->_parent = parent;

	}



	Node* parentParent = parent->_parent;

	subR->_left = parent;

	parent->_parent = subR;



	if (_root == parent)

	{

		_root = subR;

		subR->_parent = nullptr;

	}

	else

	{

		if (parentParent->_left == parent)

			parentParent->_left = subR;

		else

			parentParent->_right = subR;

		subR->_parent = parentParent;

	}

}



void RotateR(Node* parent)

{

	Node* subL = parent->_left;

	Node* subLR = subL->_right;



	parent->_left = subLR;

	if (subLR)

		subLR->_parent = parent;



	Node* parentParent = parent->_parent;



	subL->_right = parent;

	parent->_parent = subL;



	if (parent == _root)

	{

		_root = subL;

		_root->_parent = nullptr;

	}

	else

	{

		if (parentParent->_left == parent)

			parentParent->_left = subL;

		else

			parentParent->_right = subL;



		subL->_parent = parentParent;

	}

}

private:

Node* _root;

};

描述一下红黑树

引言