【C++】红黑树

于 2023-04-08 19:19:09 发布
阅读量724 收藏 2
点赞数 2
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kdjjdjdjjejje128/article/details/130029331
版权

MarkDown输出x的平方和log以2为底的方法：
1、x2——英文输入法，输入x 加 ^ 加 2 加 ^
2、log2N——英文输入法，输入log 加 ~ 加 2 加 ~ 加 N

文章目录

1、红黑树概念

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

也就是说：红黑树中，最长的路径不超过最短路径的2倍

下面是红黑树的样例：
在这里插入图片描述

2、红黑树的性质

通过上面红黑树的概念加图片我们可以得到几个红黑树的性质（参考上面图片来观察）：

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

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

最长路径：一黑一红相间的路径
最短路径：一条路径节点全黑

这样一看，最长的路径节点个数不会超过最短路径节点个数的两倍

极端情况下的近似平衡：

最优情况：左右平衡。路径全黑或者每一条路径都是一黑一红相间的路径。满二叉树
最差情况：左右不平衡。左子树全黑，右子树一黑一红

全黑路径长度是h
2^h -1 + 红节点 = N（这里红节点远小于黑节点）
最短路径：log2N
最长路径：2*log2N

如果N是10亿，那么最短路径为30，最长路径为60，对于计算机来说30和60是在同一个量级的，所以差别并不大
在这里插入图片描述

所以：红黑树并没有AVL树那么严格，看起来就没有AVL树那么平衡，查找的效率也就没有AVL树那么高效（对比于AVL树来说）
但是AVL树高效的查找，是依赖于AVL严格的平衡，严格的平衡是通过不断旋转得到的，而旋转消耗是比较大的。而红黑树不那么平衡就表明红黑树没有AVL那么多次的旋转操作，消耗也就比较小了

3、红黑树的实现

3-1、红黑树节点的定义

enum colors
{
	RED,
	BLOCK,
};
template <class K, class V>
class RBTreeNode
{
public:
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;//左节点
	RBTreeNode<K, V>* _right;//右节点
	RBTreeNode<K, V>* _parent;//父节点

	colors _col;

	//初始化
	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}
};

3-2、红黑树的插入

红黑树的插入和AVL树的插入前面大差不差，就算少了平衡因子，多了颜色

template <class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)//前面与AVL树一样
		{
			_root = new Node(kv);
			_root->_col = BLOCK;//根节点是黑色的
			return true;
		}
		Node* parent = nullptr;//parent是cur的父节点
		Node* cur = _root;//cur往下走
		while (cur)
		{
			if (cur->_kv.first > kv.first)//我比你小，往左找
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)//我比你大，往右找
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;//不存在找到，因为AVL树不允许有重复值
			}
		}
		走到这里就表示找到我们要插入kv值的正确位置了
		cur = new Node(kv);

		cur->_col = RED;//这里插入一个节点，颜色设置为红色！！！
		//插入一个节点，设置为红色。我们就违背了红黑树规则3（红黑树的性质那里）
		//插入一个节点，设置为黑色。我们就违背了红黑树规则4
		// 
		//但是，我们可以仔细观察，发现违背规则3然后对红黑树进行修改，比违背规则4进行修改简单的多！！！
		//而且插入设置为红色不一定破环了规则3，就算违背规则3破坏的是一条路径，
		//而规则4是整棵树的全部路径。所以这里设置节点为红色比较容易控制

		if (parent->_kv.first < kv.first)//如果new的节点比父节点大，那么父节点的右指针指向new节点
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else//如果new的节点比父节点小，那么父节点的左指针指向new节点
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		//....开始插入了
		return true;
	}
private:
	Node* _root = nullptr;
};

我们先来看看下面的插入操作有哪些情况：

检测新节点插入后，红黑树的性质是否造到破坏

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

3-2-1、情况一

情况一: cur为红，p为红，g为黑，u存在且为红
这里g一定为黑，因为如果g为红，那么p为红的时候我们就要对p进行修改了，而cur是我们新增的红，
所以我们这个时候破坏了规则，开始对cur，p，g和u节点进行变色

在这里插入图片描述

cur和p均为红，违反了性质三，此处能否将p直接改为黑？

解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整

我们再来看看abcde（abcde可能有这无数层，这里我们就只是举个样例）：
1、abcde为空：
在这里插入图片描述
这个时候就和上面的处理情况一样了

2、abcde不为空

a、b为红：
在这里插入图片描述
c、d、e情况（后面还可能带着节点）：
在这里插入图片描述
这个时候在a、b下面新增节点：
在这里插入图片描述
这个时候就也变得和上面情况一样的，直接将p,u改为黑，g改为红，然后把g当成cur，继续向上调整

情况一变情况一
在这里插入图片描述

当然，我们把g当成cur向上调整，或者新插入红节点，并不就一定是上面的情况，比如cur为，u不为红。这个时候我们就要继续找其他的处理方法了！

3-2-2、情况二

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

1、u不存在，那么cur就算新增节点
在这里插入图片描述
这个时候：

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

在这里插入图片描述
2、u存在且u为黑，cur不是新增
这个时候cur不是新增节点了，因为p为红，u为黑，路径的黑节点数据个数不一样了！

在这里插入图片描述
情况一变情况二
这个时候就算上面的情况1了，我们进行处理：
在这里插入图片描述

注意：u存在且为黑，那么p和cur一定是由情况一变过来，p和cur为红的，因为如果开始p和cur为红，路径的黑节点数据个数不一样了

这个时候，我们就和处理abcde都不存在的方法一样了，p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转p、g变色–p变黑，g变红
在这里插入图片描述

在这里插入图片描述
p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转p、g变色–p变黑，g变红

3-2-3、情况三

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

1、u不存在，cur是新增
在这里插入图片描述
如果cur新增在p左边，那么就变成了情况二
如果新增在p的右变，这个时候就要进行双旋
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
这个时候就旋转成为了情况二
在这里插入图片描述
在进行第二次旋转
在这里插入图片描述

2、u存在且为黑，cur不是新增

情况一变情况三
在这里插入图片描述
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转

在这里插入图片描述
二次旋转
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转，则转换成了情况2
在这里插入图片描述
针对每种情况进行相应的处理即可

以上就是我们对红黑树的插入情况的分析，就算从AVL树的旋转加调整平衡因子，变成了旋转加变色

继续上面的代码：

while (parent && parent->_col == RED)//父亲颜色为黑就不需要处理了，颜色为红就要处理
		{
			Node* gf = parent->_parent;//
			if (parent == gf->_left)
			{
				Node* uncle = gf->_right;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLOCK;
					gf->_col = RED;
					cur = gf;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						//新增cur在父亲的左，右单旋
						RotateR(gf);
						parent->_col = BLOCK;
						gf->_col = RED;
					}
					else
					{
						//情况三，双旋
						RotateL(parent);
						RotateR(gf);
						cur->_col = BLOCK;
						gf->_col = RED;
					}
					break;//这里要break，因为这一层已经处理完了，上面有问题是上面的事，与这一层无关
				}
			}
			else
			{
				Node* uncle = gf->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLOCK;
					gf->_col = RED;

					cur = gf;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateL(gf);
						parent->_col = BLOCK;
						gf->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(gf);
						cur->_col = BLOCK;
						gf->_col = RED;
					}

					break;
				}
			}
		}
		_root->_col = BLOCK;

动态图

这里展示一下动态构建红黑树的演示图：
1、升序插入构建红黑树
在这里插入图片描述
2、降序插入构建红黑树
在这里插入图片描述
3、随机插入构建红黑树
在这里插入图片描述
4、右旋转
在这里插入图片描述

5、左旋转
在这里插入图片描述

4、红黑树的验证

这里我们不能直接比较最长路径和最短路径的差值，要缺点红黑树的规则全部正确才能证明该树是红黑树

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 （没有连续的红节点）
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点 （每条路径的黑节点个数相同）
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)
bool Check(Node* root, int blackNum, const int ref)
	{
		if (root == nullptr)
		{
			//cout << blackNum << endl;
			if (blackNum != ref)
			{
				cout << "违反规则：本条路径的黑色节点的数量跟最左路径不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "违反规则：出现连续红色节点" << endl;
			return false;
		}
		if (root->_col == BLOCK)
		{
			++blackNum;
		}
		return Check(root->_left, blackNum, ref) && Check(root->_right, blackNum, ref);
	}
	bool IsBalance()判断是否为红黑树，这里的IsBalance不是递归函数
	{
		if (_root == nullptr)//这里不需要递归，所以就使用_root，不用传参
			return true;
		if (_root->_col != BLOCK)//这里判断的是整棵树的根，不是每一个根都要为黑，
								//所以我们要再写一个函数来处理
			return false;

		int ref = 0;
		Node* left = _root;
		while (left)
		{
			if (left->_col == BLOCK)
				++ref;
			left = left->_left;
		}
		return Check(_root, 0, ref);
	}

5、红黑树的删除

与AVL树一样，我们不需要对红黑树的删除有深入的理解
所以红黑树的删除本节不做讲解，有兴趣的同学可参考：《算法导论》或者《STL源码剖析》
博客园地址

6、 红黑树与AVL树的比较

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

7、红黑树的应用

  1. C++ STL库 – map/set、mutil_map/mutil_set
  2. Java 库
  3. linux内核
  4. 其他一些库

8、红黑树代码

#pragma once
#include <assert.h>
#include <time.h>
using namespace std;
enum colors
{
	RED,
	BLOCK,
};
template <class K, class V>
class RBTreeNode
{
public:
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;//左节点
	RBTreeNode<K, V>* _right;//右节点
	RBTreeNode<K, V>* _parent;//父节点

	colors _col;

	//初始化
	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}
};

template <class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)//前面与AVL树一样
		{
			_root = new Node(kv);
			_root->_col = BLOCK;//根节点是黑色的
			return true;
		}
		Node* parent = nullptr;//parent是cur的父节点
		Node* cur = _root;//cur往下走
		while (cur)
		{
			if (cur->_kv.first > kv.first)//我比你小，往左找
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)//我比你大，往右找
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;//不存在找到，因为AVL树不允许有重复值
			}
		}
		走到这里就表示找到我们要插入kv值的正确位置了
		cur = new Node(kv);

		cur->_col = RED;//这里插入一个节点，颜色设置为红色！！！
		//插入一个节点，设置为红色。我们就违背了红黑树规则3（红黑树的性质那里）
		//插入一个节点，设置为黑色。我们就违背了红黑树规则4
		// 
		//但是，我们可以仔细观察，发现违背规则3然后对红黑树进行修改，比违背规则4进行修改简单的多！！！
		//而且插入设置为红色不一定破环了规则3，就算违背规则3破坏的是一条路径，
		//而规则4是整棵树的全部路径。所以这里设置节点为红色比较容易控制

		if (parent->_kv.first < kv.first)//如果new的节点比父节点大，那么父节点的右指针指向new节点
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else//如果new的节点比父节点小，那么父节点的左指针指向new节点
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		while (parent && parent->_col == RED)//父亲颜色为黑就不需要处理了，颜色为红就要处理
		{
			Node* gf = parent->_parent;//
			if (parent == gf->_left)
			{
				Node* uncle = gf->_right;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLOCK;
					gf->_col = RED;
					cur = gf;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						//新增cur在父亲的左，右单旋
						RotateR(gf);
						parent->_col = BLOCK;
						gf->_col = RED;
					}
					else
					{
						//情况三，双旋
						RotateL(parent);
						RotateR(gf);
						cur->_col = BLOCK;
						gf->_col = RED;
					}
					break;//这里要break，因为这一层已经处理完了，上面有问题是上面的事，与这一层无关
				}
			}
			else
			{
				Node* uncle = gf->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLOCK;
					gf->_col = RED;

					cur = gf;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateL(gf);
						parent->_col = BLOCK;
						gf->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(gf);
						cur->_col = BLOCK;
						gf->_col = RED;
					}

					break;
				}
			}
		}
		_root->_col = BLOCK;
		return true;
	}
	void RotateL(Node* parent)
	{
		Node* subr = parent->_right;
		Node* subrl = subr->_left;
		parent->_right = subrl;
		if (subrl)//上面的节点不可能为空，但是这里的subrl可能为空
		{
			subrl->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		subr->_left = parent;
		parent->_parent = subr;
		if (ppnode == nullptr)//如果
		{
			_root = subr;
			_root->_parent = nullptr;//这里要置空
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subr;
			}
			else
			{
				ppnode->_right = subr;
			}
			subr->_parent = ppnode;
		}
	}
	void RotateR(Node* parent)
	{
		Node* subl = parent->_left;
		Node* sublr = subl->_right;
		parent->_left = sublr;
		if (sublr)
		{
			sublr->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		subl->_right = parent;
		parent->_parent = subl;
		if (ppnode == nullptr)
		{
			_root = subl;
			subl->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subl;
			}
			else
			{
				ppnode->_right = subl;
			}
			subl->_parent = ppnode;
		}
	}
	void Inorder()//中序遍历
	{
		_Inorder(_root);
	}
	void _Inorder(Node* root)//中序遍历
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_Inorder(root->_right);
	}

	bool Check(Node* root, int blackNum, const int ref)
	{
		if (root == nullptr)
		{
			//cout << blackNum << endl;
			if (blackNum != ref)
			{
				cout << "违反规则：本条路径的黑色节点的数量跟最左路径不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "违反规则：出现连续红色节点" << endl;
			return false;
		}
		if (root->_col == BLOCK)
		{
			++blackNum;
		}
		return Check(root->_left, blackNum, ref) && Check(root->_right, blackNum, ref);
	}
	bool IsBalance()判断是否为红黑树，这里的IsBalance不是递归函数
	{
		if (_root == nullptr)//这里不需要递归，所以就使用_root，不用传参
			return true;
		if (_root->_col != BLOCK)//这里判断的是整棵树的根，不是每一个根都要为黑，
								//所以我们要再写一个函数来处理
			return false;

		int ref = 0;
		Node* left = _root;
		while (left)
		{
			if (left->_col == BLOCK)
				++ref;
			left = left->_left;
		}
		return Check(_root, 0, ref);
	}
private:
	Node* _root = nullptr;
};
ks不知火
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
C++红黑树实现过程
09-15
用C++实现的红黑树，没有BUG ，稍微改改就能直接运行了，最优的代码了，拿去研究吧，也没什么可以说的了···
【C++详解】——红黑树
weixin_69519040的博客
06-26 1282
本文介绍了红黑树的概念、性质，详细解释了红黑树插入节点的过程。
c++——红黑树
Britney_dark的博客
11-13 4221
愿你终将与重要的人重逢！
C++:红黑树
zhang_si_hang的博客
08-21 1483
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
基于C++红黑树与哈希表的实现
最新发布
05-08
哈希表 基于C++红黑树与哈希表的实现
C++ 红黑树 在本博客使用的图片
07-13
C++ 红黑树 在本博客使用的图片
红黑树的C++实现
05-13
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 它是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。...
红黑树的实现C++代码
07-27
用C++代码实现了一个红黑树，大家可以一起学习学习，有问题也可以直接给我留言
c/c++红黑树
04-11
关于红黑树的一些介绍 为啥一定要大于20个字 多一些废话也行嘛
C++数据结构 红黑树 实现全部功能
12-29
使用C++编写的红黑树源代码
红黑树C++实现
01-27
红黑树的C++完整实现代码
红黑树-基于C++实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于C++实现的红黑树数据结构
红黑树精短C++代码
04-13
红黑树实现前去后继排名的查询，代码经过精心简短，题目测试参考洛谷
C++数据结构 —— 红黑树
weixin_59913110的博客
03-03 4491
enum Corlor //枚举颜色RED,BLACKtemplate //为了方便，使用K模型K _key;{}
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2239
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
红黑树（C++实现）
热门推荐
2021dragon的博客
12-06 1万+
红黑树（C++实现）
c++ 红黑树demo
04-05
但是，我可以向您解释红黑树的基本原理和操作。红黑树是一种自平衡二叉搜索树，它的每个节点都有一个颜色属性，红色或黑色，具有以下特性： 1. 根节点为黑色。 2. 所有叶子节点（NIL节点）为黑色。 3. 如果一个节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值