【数据结构】红黑树实现详解

news2024/11/26 17:49:37

在本篇博客中，作者将会带领你使用C++来实现一棵红黑树，此红黑树的实现是基于二叉搜索树和AVLTree一块来讲的，所以在看本篇博客之前，你可以先看看下面这两篇博客

【C++】二叉搜索树-CSDN博客

【数据结构】AVLTree实现详解-CSDN博客

在这棵红黑树中，我们用到了二叉搜索树的插入规则和AVLTree的旋转，所以在本篇博客中，在旋转部分可以直接看AVLTree的博客。

一.什么是红黑树 

红黑树是一棵二叉搜索树，它的结点不是黑的就是红的，其中它有一个非常重要的特点：

通过对任何一条从根到叶子的路径上各个结点的着色控制，保证了红黑树没有一条路径会比最短路径长出两倍，达到接近平衡的特点。 

看到这句话，可能你还云里雾里的，但是不要怕，简单的来说，红黑树的特点就是：找出树中最短的路径和最长的路径，其中这条最长路径的长度不会大于最短路径长度的两倍。

如下图所示：

在这棵红黑树中，最短的路径是最左边的那条，长度为3，最长的路径是最右边的那条，长度为4，即4 < 2*3，最长的路径不会大于最短路径的两倍。

 1.红黑树的性质

那么红黑树是怎么做到上面的这个特点的呢？

那是因为红黑树需要遵循下面这5条性质：

1.每个结点不是红的就是黑的

2.根节点是黑色的

3.如果一个结点是红色的，那么它的两个孩子一定是黑色的

4.对于每个结点，从该结点到其所有后代叶结点的路径上，均包含相同数量的黑色结点

5.每个叶子结点都是黑色的（此处的我叶子结点指的是空结点）

对于这5条性质来说，可能有一些很难理解，但是不用怕，我们来解释一下。

对于1、2这两条性质来说，很好理解就字面意思，这里就不做过多的解释，其中最重要的是3、4这两条性质，在下面的红黑树插入讲解中，我们都将会围绕着3、4这两条性质来进行。

3.如果一个结点是红色的，那么它的两个孩子一定是黑色的。

        其实这个也很好理解，但是这个很重要。其规则如下图所示。

4.对于每个结点，从该结点到其所有后代叶结点的路径上，均包含相同数量的黑色结点。

         这条规则说的是，从任意一个结点开始，一直往下走，走遍所有可能，这其中会有很多条可能的路径，但是这些路径都有一个特点，就是每条路径上的黑色结点的个数相同。如下图所示。

5.每个叶子结点都是黑色的（这里的叶子结点指的是空结点），如下图所示。 但是其实这个并不是那么重要，理解就行了。

那么为什么只要遵循上面这五条性质，就能做到红黑树的特点的呢？红黑树的特点是，最长路径的长度不会大于最短路径的长度的两倍。

既然红黑树的特点与最短路径和最长路径有关，那么我们来把这两条路径分析一下。

最短路径：通过这五条性质，我们可以知道在一棵红黑树中，最短路径上，一定全是黑结点。不会再有情况比这种情况要短了。

最长路径： 对于最长路径来说，由于有性质4，所以在最长路径上，它的黑色结点的个数一定和最短路径的黑色结点个数相同。又由于有性质3，对于最长的路径来说，它一定是黑结点，红结点交替的。所以最长的路径的长度不会大于最短路径的两倍。

如下图所示

二.红黑树的实现 

知道了红黑树的性质和特点，接下来我们可以来实现一棵红黑树了。 

1.红黑树结点的定义

在定义红黑树的结点时，与普通的树结点不同的是，这里多了一个_parent指针和一个记录结点颜色的变量。 

	enum Color
	{
		BLACK,
		RED
	};

	template<class T>
	struct TreeNode
	{
		//成员变量
		T _data;//数据
		TreeNode<T>* _left;
		TreeNode<T>* _right;
		TreeNode<T>* _parent;
		Color _col;//保存结点的颜色

		//构造函数
		TreeNode(const T& data)
			:_data(data)
			,_left(nullptr)
			,_right(nullptr)
			,_parent(nullptr)
			,_col(RED)//每生成一个新结点，都将结点的颜色默认给红色，至于为什么，后面会解释
		{}
	};

2.红黑树类的定义

对于红黑树类的定义，我们先简单的给出一个构造函数，并将_root根结点赋值为nullptr即可。 

	template<class T>
	class RBTree
	{
		typedef TreeNode<T> Node;
	public:
		//构造函数
		RBTree()
			:_root(nullptr)//给根结点一个nullptr
		{}

	private:
		Node* _root;
	};

3.红黑树的插入 

接下来就是最重要的部分了，红黑树的插入，对于红黑树的插入，我们可以分为两个过程： 

1.先按二叉搜索树的插入规则把新结点插入进去先。

2.插入新结点后，判断红黑树的性质有没有被破坏，如果没有被破坏，则插入直接结束，如果有被破坏，则进行调整处理。

由于插入结点的函数有点长，所以这里把插入函数分开来实现 。下面是函数的名称以及参数

bool insert(const T& data)

①按二叉搜索树的规则进行插入 

二叉搜索树的插入规则就是，先不管三七二十一，先把新结点插入进去再说。 

对于二叉搜索树的插入规则，这里不在多讲，不是很理解的，可以看下面这篇博客，这里面讲到了二叉搜索树的插入实现。我们在这里直接给出代码。

【C++】二叉搜索树-CSDN博客

			//如果树为NULL，则直接将新结点给到_root
			if (_root == nullptr)
			{
				_root = new Node(data);
				_root->_col = BLACK;//把新结点给_root后，要记得把颜色给位BLACK
				return true;
			}

			Node* cur = _root;
			Node* cur_parent = nullptr;
			while (cur != nullptr)
			{
				if (data > cur->_data)
				{
					cur_parent = cur;
					cur = cur->_right;
				}
				else if (data < cur->_data)
				{
					cur_parent = cur;
					cur = cur->_left;
				}
				else//说明该值已经存在，不进行插入
				{
					return false;	
				}
			}

			//将新结点插入
			Node* newnode = new Node(data);
			if (cur_parent->_data > data)
			{
				cur_parent->_left = cur;
				cur->_parent = cur_parent;
			}
			else
			{
				cur_parent->_right = cur;
				cur->_parent = cur_parent;
			}

②判断红黑树的性质是否被破坏

当插入完结点后，就要判断红黑树的性质是否被破坏，如没有，则插入结束，如果有，则进行调整处理。 

对于前者没有什么好讨论的，我们在着重于讨论后者。

红黑树的性质：

1.每个结点不是红的就是黑的

2.根节点是黑色的

3.如果一个结点是红色的，那么它的两个孩子一定是黑色的

4.对于每个结点，从该结点到其所有后代叶结点的路径上，均包含相同数量的黑色结点

5.每个叶子结点都是黑色的（此处的我叶子结点指的是空结点）

首先我们来思考一个问题，如果新增了一个结点，你希望这个新增的结点是红色的还是黑色的呢？

其实我们希望这个新增的结点是红色的，为什么，我们来从红黑树的性质来分析。

当我们新插入一个结点的时候，性质1、2、5是绝对不会被破坏的，这应该很好理解。

被破坏的只有3或者4，当我们插入一个红结点，有可能会破坏性质3，当我们插入一个黑结点，会破坏性质4，如下图所示。

既然不管插入的是红结点还是黑结点，都会破坏红黑树的性质，那么为什么我们要选择插入红结点呢？

其实大家凭感觉来判断，应该都会感觉性质3的破坏更好的调整，而性质4的破坏不好调整，因为对于性质4的破坏，我们去给其他路径新增黑结点显然不合理，所以只有给当前路径减少一个黑结点来解决，那么我们把这个新增的结点给成红色即可。

既然这里已经确定了新增的结点一定为红色，所以对于红黑树的调整，我们都围绕着这个来讲解。 

③如果被破坏，则进行调整 

对于性质3的破坏，我们可以分为下面着三种情况。 

cur为红，cur_parent为红，grandparent为黑，uncle为红

上图是其中的一种插入的情况，其中cur刚好是叶子，但是cur也有可能不是叶子，所以我们可以给出这种情况的抽象图。

对于这种情况，我们的调整过程是这样的：

把cur_parent和uncle的颜色变为黑色，grandparent的颜色变为红色。如下图所示。

但是这样的处理后，还会有可能会发生性质破坏，例如grandparent的父结点还是红色，对于这样的情况，我们只需要把grandparent给cur，继续向上处理即可。如下图所示。  

cur为红，cur_parent为红，grandparent为黑，uncle为黑\uncle不存在

在这种情况中，又可以分为两种小情况，一种是uncle存在且为黑，一种是uncle不存在。

uncle不存在 

先来说说第一种情况，uncle不存在的情况，我们先来看图。 

对于这种情况来说，cur一定是新插入的结点，因为如果cur不是新插入的结点，那么说明是由情况一调整而来的，那么既然是从情况一调整而来的，那么cur的孩子肯定是黑色，但是这样就不符合性质4：从任意结点开始，每条路径的黑色结点的数量相同。 

uncle存在且为黑

接着第二种情况，uncle存在且为黑色，我们先来看图。 

对于这种情况来说，cur一定不是新插入的结点，因为如果cur是新插入的结点，那么在插入cur之前，这棵红黑树违反了性质4：从任意结点开始，每条路径的黑色结点的个数相同。 

基于这两种情况，我们可以给出这它们的抽象图，同时它们的调整方法是一样的。 

对于情况二，我们的处理是对grandparent进行一个右单旋，后调整cur_parent和grandparent的颜色即可。如下图所示。

 

cur为红，cur_parent为红，grandparent为红，uncle为黑\uncle不存在 

情况三看上去与情况二类似，其实可以说是，也可以说不是，首先同样的，情况三也可以分为两种情况，一种是uncle不存在，一种是uncle存在且为黑色。 

uncle不存在

我们直接来看图。

也情况二不同的是，它是一个折线。同样的如果uncle不存在，那么cur一定是新插入的结点。 

uncle存在且为黑 

同样的，我们直接来看图。 

对于这种情况来说，cur一定不是新插入的结点，它是由情况一调整过来的 

基于这两种情况，我们可以给出它的抽象图处理，如下图所示。  

对于情况三，我们的处理是，先对cur_parent进行一个左单旋，左单旋后，要交换cur和cur_parent，后再对grandparent进行一个右单旋，最后再调整颜色，如下图所示。

 

 

走到这里，我们所有的情况都已经讲完了，接下来可以编写我们的调整代码了。 

④ 调整代码

注意，我们上面讲到的三种情况没有覆盖到全部情况，因为还有另外三种情况是上面这三种情况的反方向，如情况一的反方向，如下图所示。 

同样的情况二和情况三也有它们的反方向，这里就不在多讲了，逻辑都是一样的。接下来我们可以来编写我们的调整代码了，我们的调整代码可以分为如上图所示的正反向和反方向来编写。   

			//调整结点代码
			while (cur_parent != nullptr && cur_parent->_col == RED)
			{
				Node* grandparent = cur_parent->_parent;
				if (grandparent->_left == cur_parent)//正方向
				{
					Node* uncle = grandparent->_right;
					if (uncle != nullptr && uncle->_col == RED)//情况一,uncle存在且为红
					{
						cur_parent->_col = uncle->_col = BLACK;
						grandparent->_col = RED;
						//继续向上处理
						cur = grandparent;
						cur_parent = cur->_parent;
					}
					else//情况二和情况三
					{
						//这里情况三经过第一次旋转后可以变成情况二，所以可以先判断是否是情况三
						if (cur_parent->_right == cur)//这种情况就是情况三
						{
							//先进行一个左单旋
							RotateL(cur_parent);
							swap(cur, cur_parent);//这里一定要进行交换，不然如果是情况二的，会出现逻辑错误
						}
						//代码走到这里就一定是情况二了
						RotateR(grandparent);
						cur_parent->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
				else if (grandparent->_right == cur_parent)//反方向
				{
					Node* uncle = grandparent->_left;
					if (uncle != nullptr && uncle->_col == RED)//反方向的情况一
					{
						cur_parent->_col = uncle->_col = BLACK;
						grandparent->_col = RED;

						cur = grandparent;
						cur_parent = cur->_parent;
					}
					else//反方向的情况二和情况三
					{
						if (cur_parent->_left == cur)
						{
							RotateR(cur_parent);
							swap(cur, cur_parent);
						}
						RotateL(grandparent);
						cur_parent->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
			}
			_root->_col = BLACK;

⑤最终插入代码 

		//插入结点
		bool insert(const T& data)
		{
			//如果树为NULL，则直接将新结点给到_root
			if (_root == nullptr)
			{
				_root = new Node(data);
				_root->_col = BLACK;//把新结点给_root后，要记得把颜色给位BLACK
				return true;
			}

			Node* cur = _root;
			Node* cur_parent = nullptr;
			while (cur != nullptr)
			{
				if (data > cur->_data)
				{
					cur_parent = cur;
					cur = cur->_right;
				}
				else if (data < cur->_data)
				{
					cur_parent = cur;
					cur = cur->_left;
				}
				else//说明该值已经存在，不进行插入
				{
					return false;	
				}
			}

			//将新结点插入
			cur = new Node(data);
			if (cur_parent->_data > data)
			{
				cur_parent->_left = cur;
				cur->_parent = cur_parent;
			}
			else
			{
				cur_parent->_right = cur;
				cur->_parent = cur_parent;
			}

			//调整结点代码
			while (cur_parent != nullptr && cur_parent->_col == RED)
			{
				Node* grandparent = cur_parent->_parent;
				if (grandparent->_left == cur_parent)//正方向
				{
					Node* uncle = grandparent->_right;
					if (uncle != nullptr && uncle->_col == RED)//情况一,uncle存在且为红
					{
						cur_parent->_col = uncle->_col = BLACK;
						grandparent->_col = RED;
						//继续向上处理
						cur = grandparent;
						cur_parent = cur->_parent;
					}
					else//情况二和情况三
					{
						//这里情况三经过第一次旋转后可以变成情况二，所以可以先判断是否是情况三
						if (cur_parent->_right == cur)//这种情况就是情况三
						{
							//先进行一个左单旋
							RotateL(cur_parent);
							swap(cur, cur_parent);
						}
						//代码走到这里就一定是情况二了
						RotateR(grandparent);
						cur_parent->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
				else if (grandparent->_right == cur_parent)//反方向
				{
					Node* uncle = grandparent->_left;
					if (uncle != nullptr && uncle->_col == RED)//反方向的情况一
					{
						cur_parent->_col = uncle->_col = BLACK;
						grandparent->_col = RED;

						cur = grandparent;
						cur_parent = cur->_parent;
					}
					else//反方向的情况二和情况三
					{
						if (cur_parent->_left == cur)
						{
							RotateR(cur_parent);
							swap(cur, cur_parent);
						}
						RotateL(grandparent);
						cur_parent->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
			}
			_root->_col = BLACK;
		}

⑥代码分析

在我们的插入函数的调整部分中，有下面这段逻辑

			//调整结点代码
			while (cur_parent != nullptr && cur_parent->_col == RED)
			{
				Node* grandparent = cur_parent->_parent;
				if (grandparent->_left == cur_parent)//正方向
                {
                    
                  
                }

有的人可能会有个疑问，就是在这里的grandparent指针中，没有进行做判空处理，不会出现grandparent是个空指针的错误吗？

答案是不会的，原因如下： 

首先我们可以确定的是，cur和cur_parent指针不会是空指针，不然这个while循环也不会进入，且进去这个循环后，cur和cur_parent结点的颜色一定为红色。那么既然cur_parent为红色，那么cur_parent就一定不是根结点，因为在红黑树的性质中，根结点一定是黑色的，但是这个时候cur_parent是红色的，说明cur_parent一定有父结点，所以不会出现grandparent为空指针的情况。

4.红黑树的查找

红黑树的查找就比较简单了，就是普通的二叉搜索树的查找方式，这里就不在多解释，不了解的可以去看前面的二叉搜索树的博客。 


		//查找结点
		Node* find(const T& data)
		{
			Node* cur = _root;
			if (data > cur->_data)
			{
				cur = cur->_right;
			}
			else if (data < cur->_data)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
			return nullptr;
		}

5.红黑树的修改 

不是所有红黑树的结点都是可以修改的，只有<key,value>模型的红黑树才能修改，例如STL中的map，而key模型的红黑树是不能修改的，例如STL中的set，我们这里默认实现的是key模型的红黑树，所以在这里是不能修改的，但是如果想要做到修改，可以把这棵红黑树改成<key,value>模型即可，即在TreeNode结构体中，多加一个参数即可。 

三.测试

看到这里，我们的这棵红黑树除了删除都已经搞定了，那么我们如果判断我们写的代码是对的呢？即我们写的这棵红黑树到底是不是红黑树，判断这棵树是不是红黑树的方法就是用红黑树的性质去检查它即可。 

首先，我们再来看一下红黑树的五条性质： 

1.每个结点不是红的就是黑的

2.根节点是黑色的

3.如果一个结点是红色的，那么它的两个孩子一定是黑色的

4.对于每个结点，从该结点到其所有后代叶结点的路径上，均包含相同数量的黑色结点

5.每个叶子结点都是黑色的（此处的我叶子结点指的是空结点） 

通过下面这个代码，可以测试一个红黑树是否正确。 

		//判断是否符合红黑树的性质
		bool JudgeTree()
		{
			//空树也是红黑树
			if (_root == nullptr)
			{
				return true;
			}
			//性质1：树结点不是红的就是黑的
			//这条性质就没必要检查的了

			//性质2：根结点一定是黑色的
			if (_root->_col != BLACK)
			{
				cout << "违反性质2：根结点一定是黑色的" << endl;
				return false;
			}

			//性质5:所有叶子结点都是黑色的
			//这个性质也没必要检查

			size_t blackcount = 0;
			Node* cur = _root;
			while (cur != nullptr)//先求出一条路径中的黑色结点的个数
			{
				if (cur->_col == BLACK)
				{
					blackcount++;
				}
				cur = cur->_left;
			}
			size_t k = 0;//用来存储黑色结点的个数
			return _JudgeTree(_root, k, blackcount);//判断性质3和性质4

			//性质3：如果一个结点是红色的，那么它的孩子一定是黑色的
			//性质4：每条路径上的黑色结点的个数都相同
		}

		//判断是否红黑树的子函数
		bool _JudgeTree(Node* root, size_t k, size_t blackcount)
		{
			//当root走到NULL的时候，判断这条路径的黑色结点个数是否==blackcount
			if (root == nullptr)
			{
				if (k == blackcount)
				{
					return true;
				}
				else
				{
					cout << "违反性质4：每条路径上的黑结点个数相同" << endl;
					return false;
				}			
			}

			//如果结点是红色的，判断它的父结点是否也为红色
			Node* root_parent = root->_parent;
			if (root_parent != nullptr && root->_col == RED)
			{
				if (root_parent->_col == RED)
				{
					cout << "违反性质3：如果一个结点是红色的，那么它的孩子一定是黑色的" << endl;
					return false;
				}
			}

			//如果结点是黑色的，则k++
			if (root->_col == BLACK)
			{
				k++;
			}

			return _JudgeTree(root->_left, k, blackcount) && _JudgeTree(root->_right, k, blackcount);
		}

四.所有源代码

blog_RBTree.h

#pragma once
#include<iostream>
#include<time.h>
using namespace std;
namespace blog_RBTree
{
	enum Color
	{
		BLACK,
		RED
	};

	template<class T>
	struct TreeNode
	{
		//成员变量
		T _data;//数据
		TreeNode<T>* _left;
		TreeNode<T>* _right;
		TreeNode<T>* _parent;
		Color _col;//保存结点的颜色

		//构造函数
		TreeNode(const T& data)
			:_data(data)
			,_left(nullptr)
			,_right(nullptr)
			,_parent(nullptr)
			,_col(RED)//每生成一个新结点，都将结点的颜色默认给红色，至于为什么，后面会解释
		{}
	};

	template<class T>
	class RBTree
	{
		typedef TreeNode<T> Node;
	public:
		//构造函数
		RBTree()
			:_root(nullptr)//给根结点一个nullptr
		{}

		//插入结点
		bool insert(const T& data)
		{
			//如果树为NULL，则直接将新结点给到_root
			if (_root == nullptr)
			{
				_root = new Node(data);
				_root->_col = BLACK;//把新结点给_root后，要记得把颜色给位BLACK
				return true;
			}

			Node* cur = _root;
			Node* cur_parent = nullptr;
			while (cur != nullptr)
			{
				if (data > cur->_data)
				{
					cur_parent = cur;
					cur = cur->_right;
				}
				else if (data < cur->_data)
				{
					cur_parent = cur;
					cur = cur->_left;
				}
				else//说明该值已经存在，不进行插入
				{
					return false;	
				}
			}

			//将新结点插入
			cur = new Node(data);
			if (cur_parent->_data > data)
			{
				cur_parent->_left = cur;
				cur->_parent = cur_parent;
			}
			else
			{
				cur_parent->_right = cur;
				cur->_parent = cur_parent;
			}

			//调整结点代码
			while (cur_parent != nullptr && cur_parent->_col == RED)
			{
				Node* grandparent = cur_parent->_parent;
				if (grandparent->_left == cur_parent)//正方向
				{
					Node* uncle = grandparent->_right;
					if (uncle != nullptr && uncle->_col == RED)//情况一,uncle存在且为红
					{
						cur_parent->_col = uncle->_col = BLACK;
						grandparent->_col = RED;
						//继续向上处理
						cur = grandparent;
						cur_parent = cur->_parent;
					}
					else//情况二和情况三
					{
						//这里情况三经过第一次旋转后可以变成情况二，所以可以先判断是否是情况三
						if (cur_parent->_right == cur)//这种情况就是情况三
						{
							//先进行一个左单旋
							RotateL(cur_parent);
							swap(cur, cur_parent);
						}
						//代码走到这里就一定是情况二了
						RotateR(grandparent);
						cur_parent->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
				else if (grandparent->_right == cur_parent)//反方向
				{
					Node* uncle = grandparent->_left;
					if (uncle != nullptr && uncle->_col == RED)//反方向的情况一
					{
						cur_parent->_col = uncle->_col = BLACK;
						grandparent->_col = RED;

						cur = grandparent;
						cur_parent = cur->_parent;
					}
					else//反方向的情况二和情况三
					{
						if (cur_parent->_left == cur)
						{
							RotateR(cur_parent);
							swap(cur, cur_parent);
						}
						RotateL(grandparent);
						cur_parent->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
			}
			_root->_col = BLACK;
		}

		//查找结点
		Node* find(const T& data)
		{
			Node* cur = _root;
			if (data > cur->_data)
			{
				cur = cur->_right;
			}
			else if (data < cur->_data)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
			return nullptr;
		}

		//判断是否符合红黑树的性质
		bool JudgeTree()
		{
			//空树也是红黑树
			if (_root == nullptr)
			{
				return true;
			}
			//性质1：树结点不是红的就是黑的
			//这条性质就没必要检查的了

			//性质2：根结点一定是黑色的
			if (_root->_col != BLACK)
			{
				cout << "违反性质2：根结点一定是黑色的" << endl;
				return false;
			}

			//性质5:所有叶子结点都是黑色的
			//这个性质也没必要检查

			size_t blackcount = 0;
			Node* cur = _root;
			while (cur != nullptr)//先求出一条路径中的黑色结点的个数
			{
				if (cur->_col == BLACK)
				{
					blackcount++;
				}
				cur = cur->_left;
			}
			size_t k = 0;//用来存储黑色结点的个数
			return _JudgeTree(_root, k, blackcount);//判断性质3和性质4

			//性质3：如果一个结点是红色的，那么它的孩子一定是黑色的
			//性质4：每条路径上的黑色结点的个数都相同
		}

	private:
		//左单旋	
		void RotateL(Node* cur_parent)
		{
			Node* cur = cur_parent->_right;
			Node* cur_left = cur->_left;

			//改变指针的链接关系
			cur_parent->_right = cur_left;
			if (cur_left != nullptr)
			{
				cur_left->_parent = cur_parent;
			}

			cur->_left = cur_parent;
			Node* cur_parent_parent = cur_parent->_parent;
			cur_parent->_parent = cur;

			//旋转完成后要判断cur_parent是否为根
			if (cur_parent_parent != nullptr)//说明cur_parent不是根
			{
				if (cur_parent_parent->_data < cur_parent->_data)
				{
					cur_parent_parent->_right = cur;
					cur->_parent = cur_parent_parent;
				}
				else
				{
					cur_parent_parent->_left = cur;
					cur->_parent = cur_parent_parent;
				}
			}
			else//说明cur_parent是根
			{
				_root = cur;
				cur->_parent = nullptr;
			}

		}

		//右单旋
		void RotateR(Node* cur_parent)
		{
			Node* cur = cur_parent->_left;
			Node* cur_right = cur->_right;

			cur_parent->_left = cur_right;
			if (cur_right != nullptr)
			{
				cur_right->_parent = cur_parent;
			}

			cur->_right = cur_parent;
			Node* cur_parent_parent = cur_parent->_parent;
			cur_parent->_parent = cur;

			if (cur_parent_parent != nullptr)
			{
				if (cur_parent_parent->_data > cur_parent->_data)
				{
					cur_parent_parent->_left = cur;
					cur->_parent = cur_parent_parent;
				}
				else
				{
					cur_parent_parent->_right = cur;
					cur->_parent = cur_parent_parent;
				}
			}
			else
			{
				_root = cur;
				cur->_parent = nullptr;
			}

		}

		//获取根节点
		Node* GetRoot()
		{
			return _root;
		}

		//判断是否红黑树的子函数
		bool _JudgeTree(Node* root, size_t k, size_t blackcount)
		{
			//当root走到NULL的时候，判断这条路径的黑色结点个数是否==blackcount
			if (root == nullptr)
			{
				if (k == blackcount)
				{
					return true;
				}
				else
				{
					cout << "违反性质4：每条路径上的黑结点个数相同" << endl;
					return false;
				}
					

			}

			//如果结点是红色的，判断它的父结点是否也为红色
			Node* root_parent = root->_parent;
			if (root_parent != nullptr && root->_col == RED)
			{
				if (root_parent->_col == RED)
				{
					cout << "违反性质3：如果一个结点是红色的，那么它的孩子一定是黑色的" << endl;
					return false;
				}
			}

			//如果结点是黑色的，则k++
			if (root->_col == BLACK)
			{
				k++;
			}

			return _JudgeTree(root->_left, k, blackcount) && _JudgeTree(root->_right, k, blackcount);
		}

	private:
		Node* _root;
	};

	void Test1()
	{
		srand(time(0));
		RBTree<int> root;
		const int n = 10000;
		for (int i = 0; i < n; i++)
		{
			int input = rand();
			root.insert(input);
		}
		cout << root.JudgeTree() << endl;
	}
}

test.cpp  

#include"blog_RBTree.h"

int main()
{
	blog_RBTree::Test1();

	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1832502.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

21.FuturePromise

21.FuturePromise

在异步处理时，经常用到两个接口Future 和 Promise。 说明：Netty中的Future与jdk中的Future同名，但是是两个接口，netty的Future继承了jdk的Future,而Promise又对Netty的Future进行了扩展。 JDK的Future只能同步等待任务结束（成功、失败）才能得到结果。FutureTask.get()方…
阅读更多...
项目(一)--高并发内存池项目简介

项目(一)--高并发内存池项目简介

什么是高并发内存池 它是一个全球性大厂google(谷歌)的 开源项目,项目名字叫tcmalloc,全称是Thread-Caching Malloc,即线程缓存的malloc 作用&#xff1a; 我们知道C语言在堆上开辟空间和 释放使用的是malloc和free函数 并且C的动态内存管理new和delete 的底层实际上也调用了…
阅读更多...
高考志愿填报：选择好专业还是好学校？

高考志愿填报：选择好专业还是好学校？

人不走空 &#x1f308;个人主页&#xff1a;人不走空 &#x1f496;系列专栏&#xff1a;算法专题 ⏰诗词歌赋&#xff1a;斯是陋室&#xff0c;惟吾德馨 高考志愿填报&#xff1a;选择好专业还是好学校&#xff1f; 每年高考结束后&#xff0c;考生和家长面临的一个…
阅读更多...
数据结构之线性表（3）

数据结构之线性表（3）

数据结构之线性表&#xff08;3&#xff09; 上文我们了解了线性表的静动态存储的相关操作&#xff0c;此篇我们对线性表中链表的相关操作探讨。 在进行链表的相关操作时&#xff0c;我们先来理解单链表是什么&#xff1f; 1.链表的概念及结构 链表是一种物理存储结构上非连…
阅读更多...
密钥管理简介

密钥管理简介

首先我们要知道什么是密钥管理&#xff1f; 密钥管理是一种涉及生成、存储、使用和更新密钥的过程。 密钥的种类 我们知道&#xff0c;对称密码主要包括分组密码和序列密码。但有时也可以将杂凑函数和消息认证码划分为这一类&#xff0c;将它们的密钥称为对称密钥&#xff1b;…
阅读更多...
RAG与Langchain简介

RAG与Langchain简介

RAG与Langchain简介 什么是RAGRAG解决的问题RAG工作流程RAG调优策略LangChain简介 什么是RAG 检索增强生成&#xff08;Retrieval-Augmented Generation&#xff09;&#xff0c;主要是通过从外部给大模型补充一些知识&#xff0c;相当于给模型外挂了一个知识库&#xff0c;让…
阅读更多...
Navicat 安装及初步配置指南

Navicat 安装及初步配置指南

Navicat 是一款广泛使用的数据库管理工具&#xff0c;支持多种数据库&#xff0c;如 MySQL、PostgreSQL、SQLite 等。以下是 Navicat 安装步骤的详细说明&#xff1a; 在 Windows 上安装 Navicat 下载 Navicat 安装包&#xff1a; 访问 Navicat 官方网站&#xff1a;Navicat 官…
阅读更多...
iCopy for Mac 剪切板 粘贴工具 历史记录 安装（保姆级教程，新手小白轻松上手）

iCopy for Mac 剪切板 粘贴工具 历史记录 安装（保姆级教程，新手小白轻松上手）

Mac分享吧 文章目录 效果可留存文本、图片、文件等复制历史记录也可根据关键字进行历史记录检索点击一下&#xff0c;可复制双击两下&#xff0c;复制内容&#xff0c;并将信息粘贴至鼠标指针处 一、准备工作二、开始安装1、双击运行软件&#xff0c;将其从左侧拖入右侧文件夹…
阅读更多...
【Vue】Pinia管理用户数据

【Vue】Pinia管理用户数据

Pinia管理用户数据 基本思想&#xff1a;Pinia负责用户数据相关的state和action&#xff0c;组件中只负责触发action函数并传递参数 步骤1&#xff1a;创建userStore 1-创建store/userStore.js import { loginAPI } from /apis/user export const useUserStore defineStore(…
阅读更多...
Havoc工具

Havoc工具

Team端 客户端 打开后需要生成监听器和agent 监听 生成payload 最后上线 HTTPS流量 HTTP流量 心跳
阅读更多...
基于微信小程序的在线答题小程序设计与实现

基于微信小程序的在线答题小程序设计与实现

个人介绍 hello hello~ &#xff0c;这里是 code袁~&#x1f496;&#x1f496; &#xff0c;欢迎大家点赞&#x1f973;&#x1f973;关注&#x1f4a5;&#x1f4a5;收藏&#x1f339;&#x1f339;&#x1f339; &#x1f981;作者简介&#xff1a;一名喜欢分享和记录学习的…
阅读更多...
安装 Nuxt.js 的步骤和注意事项

安装 Nuxt.js 的步骤和注意事项

title: 安装 Nuxt.js 的步骤和注意事项 date: 2024/6/17 updated: 2024/6/17 author: cmdragon excerpt: Nuxt.js在Vue.js基础上提供的服务器端渲染框架优势&#xff0c;包括提高开发效率、代码维护性和应用性能。指南详细说明了从环境准备、Nuxt.js安装配置到进阶部署技巧&…
阅读更多...
大模型KV Cache节省神器MLA学习笔记（包含推理时的矩阵吸收分析）

大模型KV Cache节省神器MLA学习笔记（包含推理时的矩阵吸收分析）

首先&#xff0c;本文回顾了MHA的计算方式以及KV Cache的原理&#xff0c;然后深入到了DeepSeek V2的MLA的原理介绍&#xff0c;同时对MLA节省的KV Cache比例做了详细的计算解读。接着&#xff0c;带着对原理的理解理清了HuggingFace MLA的全部实现&#xff0c;每行代码都去对应…
阅读更多...
dentacare - hackmyvm

dentacare - hackmyvm

简介 靶机名称&#xff1a;dentacare 难度&#xff1a;中等 靶场地址&#xff1a;https://hackmyvm.eu/machines/machine.php?vmdentacare 本地环境 虚拟机&#xff1a;vitual box 靶场IP&#xff08;dentacare&#xff09;&#xff1a;192.168.56.120 跳板机IP(window…
阅读更多...
使用Multipass编译OpenHarmony工程

使用Multipass编译OpenHarmony工程

Multipass 是一个轻量级虚拟机管理器&#xff0c;支持 Linux、Windows 与 macOS&#xff0c;这是为希望使用单个命令提供全新 Ubuntu 环境的开发人员而设计的。使用 Linux 上的 KVM、Windows 上的 Hyper-V 和 macOS 上的 HyperKit 来以最小的开销运行 VM&#xff0c;同时它还可…
阅读更多...
驱动开发（二）：创建字符设备驱动

驱动开发（二）：创建字符设备驱动

往期文章&#xff1a; 驱动开发&#xff08;一&#xff09;&#xff1a;驱动代码的基本框架 驱动开发&#xff08;二&#xff09;&#xff1a;创建字符设备驱动 ←本文 驱动开发&#xff08;三&#xff09;&#xff1a;内核层控制硬件层 目录 字符驱动设备的作用 函数 …
阅读更多...
找不到vcomp100.dll无法继续执行代码的原因及解决方法

找不到vcomp100.dll无法继续执行代码的原因及解决方法

在日常使用电脑的过程中&#xff0c;我们可能会遇到一些错误提示&#xff0c;其中之一就是“vcomp100.dll丢失”。那么&#xff0c;vcomp100.dll是什么&#xff1f;它为什么会丢失&#xff1f;对电脑有什么具体影响&#xff1f;如何解决这个问题&#xff1f;本文将为您详细解答…
阅读更多...
SpringBoot整合SpringDataRedis

SpringBoot整合SpringDataRedis

目录 1.导入Maven坐标 2.配置相关的数据源 3.编写配置类 4.通过RedisTemplate对象操作Redis SpringBoot整合Redis有很多种&#xff0c;这里使用的是Spring Data Redis。接下来就springboot整合springDataRedis步骤做一个详细介绍。 1.导入Maven坐标 首先&#xff0c;需要导…
阅读更多...
dp练习2

dp练习2

如何分析这个题目呢&#xff0c;要想着当前的最优解只和前面的最优解有关 class Solution { public:int numSquares(int n) {vector<int> f(n 1);for (int i 1; i < n; i) {int minn INT_MAX;for (int j 1; j * j < i; j) {minn min(minn, f[i - j * j]);}f[…
阅读更多...
基于Java+Swing贪吃蛇小游戏（含课程报告）

基于Java+Swing贪吃蛇小游戏（含课程报告）

博主介绍&#xff1a; 大家好&#xff0c;本人精通Java、Python、C#、C、C编程语言&#xff0c;同时也熟练掌握微信小程序、Php和Android等技术&#xff0c;能够为大家提供全方位的技术支持和交流。 我有丰富的成品Java、Python、C#毕设项目经验&#xff0c;能够为学生提供各类…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023