【红黑树的核心思想】

于 2024-11-25 16:28:37 发布
阅读量755 收藏 14
点赞数 31
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/double__main__/article/details/144007303
版权

1 红黑树

1.1 红黑树的概念

红黑树是一种二叉搜索树，它在每个节点上增加了一个颜色属性，颜色可以是红色（Red）或黑色（Black）。通过限制从根节点到叶节点的每条路径上节点的着色方式，红黑树能够保证任意路径的长度差不超过两倍，从而实现接近平衡。
红黑树示例图

1.2 红黑树的性质

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

思考1：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？
最短路径：全黑
最长路径：一黑一红间隔

思考2：数下面树有几条路径。
红黑树的判定

1.3 红黑树节点的定义

// 节点的颜色
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)
	{}
};

思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？
如果插入节点默认是黑色，不管双亲是什么颜色，所有节点都要调整（破坏了规则4，很麻烦）。
如果插入节点默认是红色，并且双亲是黑色，则不需要调整。（侥幸，有一定几率不修改）。

1.4 红黑树的插入操作

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

  1. 按照二叉搜索的树规则插入新节点。
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_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);
		cur->_col = RED;
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		return true;
	}

private:
	Node* _root = nullptr;
};
  1. 检测新节点插入后，红黑树的性质是否造到破坏。

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

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

  • 情况一: cur为红，p为红，g为黑，u存在且为红。
    在这里插入图片描述
    如果cur是新增节点且为红，则违反了性质3（不能出现连续的红色节点）。
    解决办法：将p,u改为黑，g改为红。

      - 如果g是根节点，调整完成后，需要将g改为黑色。
  - 如果g是子树，g一定有双亲，且g的双亲如果是红色，需要继续向上调整。
    即：把g当成cur，继续向上调整。
  • 情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑。
    • 如果p为g的左孩子，cur为p的左孩子，则进行右单旋转。
    • 相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转。
    • 旋转后，p、g变色–p变黑，g变红。

说明：u的情况有两种。

**第一种：**如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。
在这里插入图片描述

第二种：如果u节点存在且为黑，那么cur节点原来的颜色一定也是黑色的，现在看到其是红色，是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成了红色。
在这里插入图片描述

  • 情况三: cur为红，p为红，g为黑，u不存在/u存在且为黑。
    • p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，
    • p为g的右孩子，cur为p的左孩子，则针对p做右单旋转。
    • 则转换成了情况2。

u还是存在两种情况：
第一种：u不存在
在这里插入图片描述
第二种：u存在且为黑
在这里插入图片描述
图理解完毕，现在开始检测新节点插入后，红黑树的性质是否造到破坏
补充核心代码：

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_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);
	cur->_col = RED;
	if (parent->_kv.first < kv.first)
	{
		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)
		{
			//     g
			//   p   u
			// c
			Node* uncle = grandfather->_right;
			
			// 情况一: cur为红，p为红，g为黑，u存在且为红。
			if (uncle && uncle->_col == RED)
			{
				// 变色
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				// 继续往上更新处理
				cur = grandfather;
				parent = cur->_parent;
			}
			// cur为红，p为红，g为黑，u不存在/u存在且为黑。
			else
			{
				if (cur == parent->_left)
				{
					// 单旋
					//     g
					//   p
					// c
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					// 双旋
					//     g
					//   p
					//     c
					RotateL(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}

				break;
			}
		}
		else  // parent == grandfather->_right
		{
			//     g
			//   u   p 
			//          c
			//
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED)
			{
				// 变色
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				// 继续往上处理
				cur = grandfather;
			}
			else
			{
				if (cur == parent->_right)
				{
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//     g
					//   u   p 
					//     c
					//
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}

				break;
			}
		}
	}

	_root->_col = BLACK;

	return true;
}

左旋和右旋的代码可以抄上一节AVL树的代码：

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		subR->_left = parent;

		Node* parentParent = parent->_parent;

		parent->_parent = subR;
		if (subRL)
			subRL->_parent = parent;

		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 (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}

			subL->_parent = parentParent;
		}
	}

1.5 红黑树与AVL树的比较

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

写完了红黑树的整体逻辑了(红黑树的验证和节点的删除省了，太难了)，要涨脑子了！！！进化

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值