C++进阶-红黑树（map和set）

最新推荐文章于 2024-08-04 12:02:54 发布

bingo691

最新推荐文章于 2024-08-04 12:02:54 发布

阅读量932

点赞数 14

分类专栏： C++进阶文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/weixin_64423718/article/details/140614947

版权

C++进阶专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1. 红黑树

1.1 红黑树的定义

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

1.2 红黑树的性质

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

红色节点不能连续
每条路径上黑色节点个数相等
红黑树最长路径中节点个数可能会等于最短路径中节点个数的两倍
最短路径：全黑
最长路径：一黑一红

1.3 红黑树节点的定义

// 枚举
enum Colour
{
	RED,
	BLACK
};

// 节点类
template<class K,class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _parent;// 父亲节点
	RBTreeNode<K, V>* _left;// 左孩子节点
	RBTreeNode<K, V>* _right;// 右孩子节点
	pair<K, V> _kv;// 节点数据
	Colour _col;// 节点颜色


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

1.4 红黑树结构

为了后续实现关联式容器简单，红黑树的实现中增加一个头结点，因为跟节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点，pLeft域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点，如下

1.5 红黑树的插入操作

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

按照二叉搜索的树规则插入新节点

// 插入
bool Insert(const pair<K, V>& kv)
{
	// 判断是否为空
	if (_root == nullptr)
	{
		_root = new Node(kv);
		// 新插入节点，根节点必须为黑色
		_root->_col = BLACK;
		return true;
	}

	Node* cur = _root;
	Node* parent = nullptr;

	while (cur)
	{
		if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	cur = new Node(kv);
	// 新插入节点，插入红色，可能违反规则三
	// 插入黑色，必然违反规则四

	// 所以新增节点为红色
	cur->_col = RED;
	if (cur->_kv.first < parent->_kv.first)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;

	}
	cur->_parent = parent;

	//...

	return true
}

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

情况一: cur为红，p为红，g为黑，u存在且为红

解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。
x==0的情况

x==1的情况

注意：

如果g是根节点,调整完成后,需要将g改为黑色
如果g是子树,g一定有双亲,且g的双亲如果是红色,需要继续向上调整
不能有连续的红色节点
有连续红色的时候会发生颜色的改变

情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑

解决方案：
p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，
p为g的右孩子，cur为p的右孩子，则进行左单旋转
p、g变色–p变黑，g变红

主要分为u存在且为黑和u不存在:parent是左孩子是情况下

x==0情况

x==1的情况

parent为右孩子的情况与之相反，相反方向旋转，左单旋转

情况三: cur为红，p为红，g为黑，u不存在/u存在且为黑
也就是相当于情况二的新增节点的改变，变为parent的右孩子

解决方案：
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；
相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转

代码的编写流程如下：

// 插入
bool Insert(const pair<K, V>& kv)
{
	// 判断是否为空
	if (_root == nullptr)
	{
		_root = new Node(kv);
		// 新插入节点，根节点必须为黑色
		_root->_col = BLACK;
		return true;
	}

	Node* cur = _root;
	Node* parent = nullptr;

	while (cur)
	{
		if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	cur = new Node(kv);
	// 新插入节点，插入红色，可能违反规则三
	// 插入黑色，必然违反规则四

	// 所以新增节点为红色
	cur->_col = RED;
	if (cur->_kv.first < parent->_kv.first)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;

	}
	cur->_parent = parent;

	
	
	// 进行红黑树颜色调整
	// 分为三种情况：
	// 1.情况一: 新增cur为红，p为红，g为黑，u存在且为红
	// 2.情况二: 新增cur为红，p为红，g为黑，u不存在/u存在且为黑
	// 3.情况三: 新增cur为红，p为红，g为黑，u不存在/u存在且为黑
	// 情况2和3可以合并为一种进行

	// uncle有大方向，uncle存在、uncle不存在、uncle存在且wei

	// 以上情况的解决方案一般parent的颜色是黑色就结束了
	// 或者为根节点时，parent为空跳出循环
	while (parent && parent->_col == RED)
	{
		// grandfather节点
		Node* grandfather = parent->_parent;
		
		// 先看uncle和parent节点的关系
		// parent节点是grandfather节点的左孩子
		if (parent == grandfather->_left)
		{
			// uncle为右孩子
			Node* uncle = grandfather->_right;

			// 由于都是uncle节点在变化，关键看uncle节点
			// 看uncle是否存在,uncle节点的颜色
			// 情况一: 新增cur为红，p为红，g为黑，u存在且为红
			// 解决方案：p，u变为黑色，g变为红色
			// 如果为根节点，则g不变，g的parent为空会跳出循环，在循环外面更改_root节点
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				// 继续向上调整，直到调整到根节点
				// cur找g，g找g的祖父
				cur = grandfather;
				parent = cur->_parent;
				
			}
			else// 其他情况，u为空，或者u节点存在并且为黑色
			{
				// 情况2、3：新增cur为红，p为红，g为黑，u不存在/u存在且为黑
				
				// 用cur新增节点插入在parent的左右孩子，来将情况2，3分开
				// cur在左孩子
				if (cur == parent->_left)
				{
					//     g  
					//   p   u
					// c 
					// 进行右单旋
					RotateR(grandfather);

					//变色
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else// cur在左孩子
				{
					//      g  
					//   p     u
					//     c 
					// 进行左右旋转
					RotateL(parent);
					RotateR(grandfather);

					// 变色
					cur->_col = BLACK;
					grandfather->_col = RED;
				}

				break;
			}
		}
		else// parent节点是grandfather节点的右孩子
		{
			// uncle为左孩子
			Node* uncle = grandfather->_left;

			// 情况一: 新增cur为红，p为红，g为黑，u存在且为红
			// 解决方案：p，u变为黑色，g变为红色
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				// 向上调整
				cur = grandfather;
				parent = cur->_parent;

			}
			else
			{
				// 情况2、3：新增cur为红，p为红，g为黑，u不存在/u存在且为黑


				// 用cur新增节点插入在parent的左右孩子，来将情况2，3分开
				// cur在右孩子
				if (cur == parent->_right)
				{
					//	 g
					// u   p
					//       c
					// 进行左单旋
					RotateL(grandfather);

					//变色
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//	  g
					// u     p
					//     c
					// 进行右左单旋
					RotateR(parent);
					RotateL(grandfather);
					
					grandfather->_col = RED;
					cur->_col = BLACK;
				}
				// 旋转之后直接跳出循环
				break;
			}
		}


	}

	// 将根节点颜色变为黑色
	_root->_col = BLACK;

	return true;
}

右单旋代码：

// 右单旋
void RotateR(Node* grandfather)
{
	Node* parent = grandfather->_left;
	Node* subR = parent->_right;

	grandfather->_left = subR;
	if (subR != nullptr)
	{
		subR->_parent = grandfather;
	}

	parent->_right = grandfather;
	Node* ppNode = grandfather->_parent;
	grandfather->_parent = parent;

	// parent的节点最后与上面判断

	// 判断根节点
	if (ppNode == nullptr)
	{
		_root = parent;

	}
	else
	{
		// parent在ppnode的哪个孩子
		if (ppNode->_right == grandfather)
		{
			ppNode->_right = parent;
		}
		else
		{
			ppNode->_left=parent;
		}
		parent->_parent = ppNode;
	}


}

左单旋代码：

// 左旋转
void RotateL(Node* grandfather)
{
	Node* parent = grandfather->_right;
	Node* subL = parent->_left;


	grandfather->_right = subL;
	if (subL != nullptr)
	{
		subL->_parent = grandfather;
	}

	Node* ppNode = grandfather->_parent;
	grandfather->_parent = parent;
	parent->_left = grandfather;


	// 判断是否为根节点
	if (ppNode == nullptr)
	{
		_root = parent;
	}
	else
	{
		// parent在ppnode的哪个孩子
		if (ppNode->_right == grandfather)
		{
			ppNode->_right = parent;
		}
		else
		{
			ppNode->_left = parent;
		}

		parent->_parent = ppNode;
	}
}

1.6 红黑树的验证

红黑树的检测分为两步：

检测其是否满足二叉搜索树(中序遍历是否为有序序列)
检测其是否满足红黑树的性质

注意：

不能有连续的红色节点,遍历红色节点,检查父亲是不是红色
每条路径黑色节点的数量,每个节点记录一个值:跟到当前节点路径中黑色节点的数量,任意计算一条路径当左参考值,在之后和其他路径进行比较,用递归形参相当于拷贝，递归中的每一个变量都是一份拷贝，出了函数就销毁了。

	bool IsBalance()
	{
		// 判断根节点是否符合要求
		if (_root->_col == RED)
		{
			return false;
		}

		int refNum = 0;

		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				refNum++;
			}
			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}

private:

	//检查平衡基本
	bool Check(Node* root,int blackNum,const int refNum)
	{
		// 判断为空
		if (root == nullptr)
		{
			//cout << blackNum << endl;

			// 判断路径中的黑色节点
			if (blackNum != refNum)
			{
				cout << "存在黑色节点的数量不相等的路径" << endl;
				return false;
			}

			return true;
		}

		// 1.不能有连续的红色节点，遍历红色节点，检查红色节点的父亲节点是不是红色
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在有连续的红色节点" << endl;
			return false;
		}

		// 2.每条路径黑色节点的数量，每一个黑色节点，记录一下
		// 根节点到当前路径黑色节点的数量，任意计算一条路径当左参考值，之后与其他路径比较
		if (root->_col == BLACK)
		{
			blackNum++;
		}

		return Check(root->_left,blackNum, refNum) && Check(root->_left,blackNum, refNum);

	}

1.7 红黑树的删除

红黑树的删除本节不做讲解，有兴趣的同学可参考：《算法导论》或者《STL源码剖析》

1.8 红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O( $log_2 N$ )，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。