红黑树实现

已于 2025-05-16 21:14:40 修改
阅读量983 收藏 22
点赞数 30
分类专栏： C++ 文章标签： 算法 c++
于 2025-05-16 21:10:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_82676216/article/details/147890017
版权

1.红黑树的概念

红黑树是一棵二叉搜索树，他的每个节点增加一个存储位来表示节点的颜色，可以是红丝或者黑色。通过对任何一条从根到叶子的路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。

1.1红黑树的规则

  1. 每个节点不是红色就是黑色
  2. 根结点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点必须是黑色的，也就是说任意一条路径不会有连续的红色节点。
  4. 对任意一个节点，从该节点到起所以NULL节点的简单路径上，均包含相同数量的黑色节点。

说明：《算法导论》等书籍上补充了一条每个叶子结点（NIL）都是黑色的规则。这里所指的叶子节点不是传统的意义上的叶子节点，而是我们所说的空节点，有些书籍上也把NIL叫做外部节点。NIL是为了方便准确的标识出所有路径。

1.2 红黑树如何确保最长路径不超过最短路径的2倍的？

  • 由规则4可知，从根到NULL节点的每条路径都有相同数量的黑色节点，所以极端场景下，最短路径就是全黑色节点的路径，假设最短路径长度为hb（black height）。
  • 由规则2和规则3可知，任意一条路径不会有连续的红色节点，所以极端场景下，最长路径就是由一黑一红间隔组成，那么最长路径的长度为2*hb。
  • 综合红黑树的4点规则而言，理论上得全黑最短路径和一黑一红的最长路径并不是在没棵红黑树都存在的。假设任意一条从根到NULL节点路径的长度为x ，那么hb < x < 2 * hb。

1.3 红黑树的效率

假设N是红黑树中结点的数量，h是最短路径的长度，那么2^{h} - 1 <= N < 2^{2*h} -1，由此推出h\approx\log N，也就意味着红黑树增删改查最坏也就是走最长路径2*logN，那么时间复杂度还是O(logN)。

红黑树的表达相对AVL树要抽象一些，AVL树通过高度差直观的控制了平衡。红黑树通过四条规则的颜色约束，间接实现了近似平衡，他们的效率都是同一档次，但是相对而言，插入相同数量的节点，红黑树的旋转次数是更少的，因为他对平衡的控制没那么严格。

2.红黑树的实现

2.1 红黑树的结构

enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	Colour _ col;

	RBTreeNode(const pair<K,V> &kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
	{}
};

template<class K, class V>
class RBTree
{
public:
	typedef RBTreeNode Node;


private:
	Node* _root = nullptr;
};

2.2 红黑树的插入

  1. 插入一个值按二叉搜索树规则进行插入，插入后我们只需要观察是否符合红黑树的4条规则
  2. 如果是空树插入，新增节点是黑色节点。如果是非空树插入，新增节点必须是红色节点，因为非空树插入，新增黑色节点就破坏了规则4，规则4是很难维护的。
  3. 非空树插入后，新增节点必须是红色节点，如果父亲节点是黑色的，则没有违反任何规则，插入结束。
  4. 非空树插入后，新增节点必须为红色节点，如果父亲是红色节点，则违反了规则3.进一步分析，c是红色，p也是红色，g必然为黑色，这三个颜色都固定了，关键看u的变化，需要根据u分为以下几种情况分别处理。

说明：下图中假设我们把插入新增节点标识为c(cur)，c的父亲标识为p(parent)，p的父亲标识为g(grandfather)，p的兄弟标识为u（uncle）。

2.2.1 情况1：变色

c为红，p为红，g为黑，u存在且为红，则将p和u变为黑色，g变红。再把g当做新的c，继续往上更新。

分析：因为p和u都是红色，g是黑色，把p和u变黑，左子树路径各增加一个黑色节点，g再变红，相当于保持g所在子树的黑色节点的数量不变，同时解决了c和p连续红色节点的问题，需要继续往上更新是因为，g是红色，如果g的父亲还是红色，那么就还需要继续处理；如果g的父亲是黑色，则处理结束了；如果g就是整棵树的根，再把g变回黑色。

情况1只变色，不旋转。所以无论c是p的左还是右，p是g的左还是右，都是上面的变色处理方式。

  • 跟AVL树类似，图0我们展示了一种具体情况，但是实际中需要这样处理的有很多种情况。
  • 图1将以上类似的处理进行抽象表达，d/e/f代表每条路径拥有hb个黑色节点的子树，a/b代表每条路径拥有hb-1个黑色节点的根为红的子树，hb>=0。

  • 图2/图3/图4，分别展示了hb == 0/hb == 1/ hb == 2的具体情况组合分析，当hb等于2时，这里组合情况上百亿种，这些样例是帮助我们理解的，不论情况多少种，多么复杂，处理方式都一样，变色再继续往上处理即可，所以我们看抽象图即可。

变色的代码：

//当父亲节点和当前节点都为红色时调整
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)//分成两种情况讨论，parent是grandfather的左还是右
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)//叔叔存在且为红色
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					//爷爷变为红色，可能破坏原先的规则接着向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
			}
		}

2.2.2 情况2： 单旋+变色

cur为红，parent为红，grandfather为黑，uncle不存在或者uncle存在且为黑，uncle不存在，则cur一定是新增节点；uncle存在且为黑，c则cur一定不是新增节点，cur之前是黑色的，是在cur的子树中插入，符合情况1，变色将cur从黑色节点变成红色，更新上来的。

分析：parent必须变成黑，才能解决连续红节点的问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要旋转+变色。

          g                              p

    p          u        -->    c              g

c                                                     u

如果p是g的左，c是p的左，那么以g为旋转点进行右单旋，再把p变成黑色，g变红即可(这里的树是一部分子树)。p变成这棵树新的根，这样子树黑色节点的数量不变，没有连续的红色节点了，且不需要往上更新，因为p的父亲是黑色还是红色或者空都不违反规则。

         g

   u          p

                   c

如果p是g的右，c是p的右，那么以g为旋转点进行左单旋，再把p变黑，g变红即可。p变成这棵树新的根，这样子树黑色节点的数量不变，没有连续的红色节点了，且不需要往上更新，因为p的父亲是黑色还是红色或者空都不违反规则。

单旋+变色的代码：


		//当父亲节点和当前节点都为红色时调整
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)//分成两种情况讨论，parent是grandfather的左还是右
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)//叔叔存在且为红色
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					//爷爷变为红色，可能破坏原先的规则接着向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//叔叔不存在或者叔叔为黑色
				{
					if (cur == parent->_left)
					{
						RotateRight(parent);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//cur在parent的右边，进行左右双旋
					{

					}
				}
			}
		}

2.2.3 情况3：双旋+变色

c为红，p为红，g为黑，u不存在或者u存在且为黑，u不存在，则c一定是新增节点，u存在且为黑，则c一定不是新增，c之前是黑色的，是在c的子树中插入，符合情况1，变色将c从黑色变成红色，更新上来的。（这里的情况其实和情况2差不多的，只是基于cur和parent的相对位置不同导致的双旋，以及对应的变色操作）。

分析：p必须变黑，才能解决，连续红节点的问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要旋转+变色。

如果p是g的左，c是p的右，那么先以p为旋转点进行左单旋，再以g为旋转点进行右单旋，再把c变成黑，g变成红即可。c变成这棵树新的根，这样子树黑色节点的数量不变，没有连续的红色节点了，且不需要往上更新，因为c的父亲是黑色还是红色或者空都不违反规则。

如果p是g的右，c是p的左，那么先以p为旋转点进行右单旋，再以g为旋转点进行左单旋，再把c变黑，g变红即可。c变成这棵树的新根，这样子树黑色节点的数量不变，没有连续的红色节点了，且不需要往上更新，因为c的父亲是黑色还是红色或者空都不违反规则。

while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)//分成两种情况讨论，parent是grandfather的左还是右
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)//叔叔存在且为红色
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					//爷爷变为红色，可能破坏原先的规则接着向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//叔叔不存在或者叔叔为黑色
				{
					if (cur == parent->_left)
					{
						RotateRight(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//cur在parent的右边，进行左右双旋
					{
						RotateLeft(parent);
						RotateRight(grandfather);
						cur->_col = BLACK:
						grandfather->_col = RED;
					}
					break;//直接退出不需要再继续
				}
			}

插入的总体代码：

	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 (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 < cur->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//当父亲节点和当前节点都为红色时调整
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)//分成两种情况讨论，parent是grandfather的左还是右
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)//叔叔存在且为红色
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					//爷爷变为红色，可能破坏原先的规则接着向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//叔叔不存在或者叔叔为黑色
				{
					if (cur == parent->_left)
					{
						RotateRight(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//cur在parent的右边，进行左右双旋
					{
						RotateLeft(parent);
						RotateRight(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;//直接退出不需要再继续
				}
			}
			else
			{
				//parent是grandfather的右
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateLeft(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateRight(parent);
						RotateLeft(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;

		return true;
	}

	void RotateRight(Node* parent)//右单旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node* Pparent = parent->_parent;
		
		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (Pparent->_left == parent)
			{
				Pparent->_left = subL;
			}
			else
			{
				Pparent->_right = subL;
			}
			subL->_parent = Pparent;
		}
	}

	void RotateLeft(Node* parent)//左单旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

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

		Node* Pparent = parent->_parent;
		parent->_parent = subR;
		subR->_left = parent;

		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (Pparent->_left == parent)
			{
				Pparent->_left = subR;
			}
			else
			{
				Pparent->_right = subR;
			}
			subR->_parent = Pparent;
		}
	}

2.3 红黑树的查找

按⼆叉搜索树逻辑实现即可，搜索效率为 O ( logN ) 
Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

2.4 红黑树的验证

这里获得最长路径和最短路径，检查最长路径不超过最短路径的2倍是不可行的，因为就算满足这个条件，红黑树也可能因为颜色不满足规则，当前暂时没出问题的，后续继续插入还是会出现问题的。所以我们还是去检查4点规则，满足这4点规则，一定能保证最长路径不超过最短路径的2倍。

  1. 规则1枚举颜色类型，天然实现保证了颜色不是黑色就是红色。
  2. 规则2直接检查根即可。
  3. 规则3前序遍历检查，遇到红色节点查孩子不太方便，因为孩子有两个，且不一定存在，反过来检查父亲的颜色就方便多了。
  4. 规则4前序遍历，遍历过程中用形参记录当前节点的blackNum（黑色节点的数量），前序遍历遇到黑色节点就++blackNum，走到空就计算出了一条路径的黑色节点数量。再任意一条路径黑色节点数量作为参考值，依次比较即可。


	bool Check(Node* root, int blacknum, const int reNum)
	{
		if (root == nullptr)
		{
			if (reNum != blacknum)
			{
				cout << "存在黑色节点的数量不相等的路径" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "存在连续的红色节点" << endl;
			return false;
		}
		if (root->_col == BLACK)
		{
			blacknum++;
		}

		return Check(root->_left, blacknum, reNum) && Check(root->_right, blacknum, reNum);
	}


    bool IsBalance()
	{
		if (_root == nullptr)
		{
			return true;
		}

		if (_root->_col == RED)
		{
			return false;
		}

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

		return Check(_root, 0, retnum);
	}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值