【C++】从零开始构建红黑树

在这里插入图片描述
送给大家一句话：
日子没劲，就过得特别慢，但凡有那么一点劲，就哗哗的跟瀑布似的拦不住。 – 巫哲 《撒野》

🌋🌋🌋🌋🌋🌋🌋🌋
⛰️⛰️⛰️⛰️⛰️⛰️⛰️⛰️

从零开始构建红黑树

  • 1 🖤红黑树
  • 2 🖤红黑树的模拟实现
    • 2.1 ❤️红黑树的节点设计
    • 2.2 ❤️红黑树的插入函数
      • 🎄 整体框架
      • 🎄 旋转处理
      • 🎄 完成插入函数
    • 2.3 ❤️ 红黑树的测试
  • Thanks♪(･ω･)ﾉ谢谢阅读！！！
  • 下一篇文章见！！！

1 🖤红黑树

红黑树是一种特殊的二叉树，它遵循一套独特的规则：

  1. ⚠️每个节点要么是红色，要么是黑色。
  2. ⚠️根节点必须是黑色的。
  3. ⚠️如果一个节点是红色的，则它的两个子节点必须是黑色的。
  4. ⚠️对于任意一个节点，从该节点到其所有后代叶子节点的简单路径上，必须包含相同数目的黑色节点。
  5. ⚠️每个叶子节点都是黑色的。这里的叶子节点指的是为空的节点。

❗注意 ❗：红黑树的规则并不要求红黑节点严格交替出现。黑色节点可以连续，但红色节点不能连续。这是规则的设定。

通过这些规则，红黑树可以保持接近平衡的状态。虽然它不像AVL树那样可以维持严格的平衡状态，但是它可以保证搜索的效率。需要记住的是：红黑树每条路径（从根节点到空节点）上的黑色节点数量相同。

红黑树的应用场景十分广泛，其中之一是在很多高性能的C++ STL库中被广泛采用，比如map和set。这是因为红黑树具有平衡性能较好的特性，能够保持树的高度较低，从而保证了在插入、删除和查找操作上的较高效率。除此之外，它还常用于实现范围查询和有序遍历等功能。 之后我们将来实现map与set的封装！！！

红黑树的平衡性质使其在数据库系统中也得到了广泛的应用，特别是在实现索引结构时。在数据库系统中，红黑树可以用于实现基于范围的查询，如在B+树的实现中，通常使用红黑树来维护叶子节点的有序性。

2 🖤红黑树的模拟实现

✅了解了红黑树的定义与规则，接下来我们就来实现红黑树✅

2.1 ❤️红黑树的节点设计

红黑树的节点设计基于二叉搜索树的节点增加了一个表示颜色的变量，用来标识该节点的颜色;

//枚举变量来定义颜色
enum color
{
	Black,
	Red
};

// 节点结构体
template<class K , class V>
struct RBTreeNode
{	
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	pair<K, V> _kv;
	color _col;
	RBTreeNode(pair<K , V> kv)
		:_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_kv(kv),
		_col(Red)
	{}

};

我们按照三叉结构来构建节点，方便进行后续操作（寻找父节点，寻找爷爷节点）。键值对来储存key和key 值对应的value值，_col来储存颜色，默认创建的节点是红色。

2.2 ❤️红黑树的插入函数

🎄 整体框架

现在我们来进行红黑树核心函数的实现，在这个插入函数中，会深刻体会到红黑树的抽象程度，也会大大加强代码能力！！！

首先依旧是最常规的操作：寻找插入位置：

//插入函数	
void Insert( pair<K , V> kv)
{
	//如果根节点为空
	if (_root == nullptr)
	{
		Node* node = new Node(kv);
		node->_col = Black;
		_root = node;
		return;
	}
	//不是根节点 就找到合适位置进行插入
	else
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur != nullptr)
		{
			parent = cur;
			if (kv.first < cur->_kv.first)
			{
				cur = cur->_left;
			}
			else
			{
				cur = cur->_right;
			}
		}
		//找到位置进行插入


}

寻找到合适的位置可以进行插入了，这里要进行一个思考：新插入的节点是什么颜色？？？

红色还是黑色？？？我们来分类讨论一下：

  1. 新插入黑色节点：如果我们新插入一个黑色节点，那么毋庸置疑会违反规则4 ：对于任意一个节点，从该节点到其所有后代叶子节点的简单路径上，必须包含相同数目的黑色节点。 这个是红黑树最为关键的规则，插入一个黑色节点，红黑树立刻就不是红黑树了！！！
  2. 新插入红色节点：如果我们新插入一个红色节点，那么规则4肯定是不会违反的了，但是规则3如果一个节点是红色的，则它的两个子节点必须是黑色的。 是有可能违反的：
    • 如果父节点是黑色，插入一个红色节点刚刚好，没有破坏红黑树的规则！！！
    • 如果父节点是红色，插入一个红色节点就违反了规则3。

这么一看，还是插入红色节点比较好，因为插入黑色节点一定破坏原本的红黑树结构，插入红色节点不一定会破坏红黑树结构！！！

所以新节点的颜色我们设置为红色。

插入一个新的节点之后，我们就要进行调整了：

  • 如果父节点是黑色，插入一个红色节点刚刚好，没有破坏红黑树的规则！！！
  • 如果父节点是红色，插入一个红色节点就违反了规则3。

我们只需要对父节点是红色进行处理了，为了保证满足规则4:对于任意一个节点，从该节点到其所有后代叶子节点的简单路径上，必须包含相同数目的黑色节点。我们需要对叔叔节点进行分类讨论：

  1. 如果叔叔节点是红色，那么说明爷爷节点的两个子树中黑色节点个数一致，此时只需要进行变色处理。
    父节点和叔叔节点都变成黑色，爷爷节点变成红色，然后继续向上进行（爷爷节点变成红色，类似“插入了一个红色节点”）。直到根节点结束（最后根节点还要变回黑色，此时相当于全体增加了一个黑色节点）
  2. 如果叔叔节点是黑色，那么说明爷爷节点的两个子树中黑色节点个数不一致，单纯依靠变色是不能达到要求的，这时候就要进行旋转。
    此时旋转的本质是将树的高度变低，再通过变色使其两边的黑色节点个数一致。但是无论如何，黑色节点的增加只可以再根节点进行！

所以我们先把处理的逻辑写好，稍后再来写旋转：

	//插入函数	
	void Insert( pair<K , V> kv)
	{
		//如果根节点为空
		if (_root == nullptr)
		{
			Node* node = new Node(kv);
			node->_col = Black;
			_root = node;
			return;
		}
		//不是根节点 就找到合适位置进行插入
		else
		{
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur != nullptr)
			{
				parent = cur;
				if (kv.first < cur->_kv.first)
				{
					cur = cur->_left;
				}
				else
				{
					cur = cur->_right;
				}
			}
			//找到位置进行插入
			Node* node = new Node(kv);
			//新节点的颜色默认为红色
			//不要违反规则4 规则4很严厉
			node->_col = Red;
			if (kv.first < parent->_kv.first)
			{
				parent->_left = node;
				node->_parent = parent;
			}
			else
			{
				parent->_right= node;
				node->_parent = parent;
			}

			cur = node;

			//开始进行判断
			//调整红黑树的平衡 -- 父节点如果为黑色就不需要调整
			//注意父节点要存在才可以！！！
			while (parent && parent->_col == Red && parent->_parent)
			{
				//爷爷节点
				Node* grandfather = parent->_parent;
				//根据父节点与爷爷节点的关系进行分类
				if (parent == grandfather->_left)
				{
					//叔叔节点是关键
					Node* uncle = grandfather->_right;
					//如果叔叔也为红色，只需要一同变色处理即可
					if (uncle && uncle->_col == Red)
					{
						parent->_col = uncle->_col = Black;
						grandfather->_col = Red;
						//继续向上处理
						cur = grandfather;
						parent = cur->_parent;
					}
					//如果叔叔不存在 / 叔叔为黑色 ， 此时需要旋转
					else
					{
						//这里需要旋转
						//旋转之后不可能再出现连续两个红色节点
						//直接break
						break;
					}
				}
				//parent == grandfather->_right
				//一样的道理
				else
				{
					//叔叔节点是关键
					Node* uncle = grandfather->_left;
					//如果叔叔也为红色，只需要一同变色处理即可
					if (uncle && uncle->_col == Red)
					{
						parent->_col = uncle->_col = Black;
						grandfather->_col = Red;
						//继续向上处理
						cur = grandfather;
						parent = cur->_parent;
					}
					//如果叔叔不存在 / 叔叔为黑色 ， 此时需要旋转
					else
					{
						//这里需要旋转
						//旋转之后不可能再出现连续两个红色节点
						//直接break
						break;
					}
				}

			}
			//无论如何根节点都是黑色的！
			_root->_col = Black;
		}

	}

🎄 旋转处理

旋转的可以参考从零开始构建AVL树！
这里我们简单讲解一下右单旋：
在这里插入图片描述

右单旋的情况是：父节点是红色，叔叔节点是黑色 , 插入的位置是父节点的左边。这是就要对爷爷节点进行右单旋。

右单旋很简单：

  1. 先记录subL subLR parent 节点，方便后续操作
  2. 右单旋是将parent变为subL的右节点，subLR变为parent的左节点。
  3. 注意还要处理_parent指针哦!

旋转后还要进行颜色的处理，我们看图进行处理即可：grandfather变为红色，parent 变为黑色

//右单旋
void RotateR(Node* parent)
{
	//进行旋转
	Node* SubL = parent->_left;
	Node* SubLR = SubL->_right;
	Node* pparent = parent->_parent;

	SubL->_right = parent;
	parent->_parent = SubL;

	parent->_left = SubLR;
	if (SubLR != nullptr)
		SubLR->_parent = parent;

	//处理爷爷节点
	if (parent == _root)
	{
		_root = SubL;
		SubL->_parent = nullptr;
	}
	else
	{
		//保证指向正确
		SubL->_parent = pparent;
		if (parent == pparent->_left)
		{
			pparent->_left = SubL;
		}
		else
		{
			pparent->_right = SubL;
		}
	}
}

左单旋是一样的道理，看图：

在这里插入图片描述

接下来我们来看双旋的情况，左右双旋如图：

在这里插入图片描述
可以看到经过旋转变色处理，每个子树的黑色节点个数依然一致。

//左右双旋
void RotateLR(Node* parent)
{
	//直接化用右单旋 左单旋
	Node* SubL = parent->_left;
	//先对SubL 进行左单旋 使其方向一致
	RotateL(SubL);
	//在对parent进行右单旋
	RotateR(parent);
	//不需要调整平衡因子

}

右左双旋套路一样！

这样我们就写好了我们的插入函数

🎄 完成插入函数

//插入函数	
void Insert( pair<K , V> kv)
{
	//如果根节点为空
	if (_root == nullptr)
	{
		Node* node = new Node(kv);
		node->_col = Black;
		_root = node;
		return;
	}
	//不是根节点 就找到合适位置进行插入
	else
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur != nullptr)
		{
			parent = cur;
			if (kv.first < cur->_kv.first)
			{
				cur = cur->_left;
			}
			else
			{
				cur = cur->_right;
			}
		}

		//找到位置
		//进行插入
		Node* node = new Node(kv);
		//新节点的颜色默认为红色
		//不要违反规则4 规则4很严厉
		node->_col = Red;
		if (kv.first < parent->_kv.first)
		{
			parent->_left = node;
			node->_parent = parent;
		}
		else
		{
			parent->_right= node;
			node->_parent = parent;
		}

		cur = node;

		//开始进行判断
		//调整红黑树的平衡 -- 父节点如果为黑色就不需要调整
		while (parent && parent->_col == Red && parent->_parent)
		{
			//爷爷节点
			Node* grandfather = parent->_parent;
			//根据父节点与爷爷节点的关系进行分类
			if (parent == grandfather->_left)
			{
				//叔叔节点是关键
				Node* uncle = grandfather->_right;
				//如果叔叔也为红色，只需要一同变色处理即可
				if (uncle && uncle->_col == Red)
				{
					parent->_col = uncle->_col = Black;
					grandfather->_col = Red;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//如果叔叔不存在 / 叔叔为黑色 ， 此时需要旋转
				else
				{
					if (cur == parent->_left)
					{
						//此时进行右单旋
						RotateR(grandfather);
						//旋转完成需要进行变色
						parent->_col = Black;
						grandfather->_col = Red;
					}
					else
					{
						//此时进行左右双旋
						RotateLR(grandfather);
						grandfather->_col = Red;
						cur->_col = Black;
					}
					//旋转之后不可能再出现连续两个红色节点
					//直接break
					break;
				}
			}
			//parent == grandfather->_right
			//一样的道理
			else
			{
				//叔叔节点是关键
				Node* uncle = grandfather->_left;
				//如果叔叔也为红色，只需要一同变色处理即可
				if (uncle && uncle->_col == Red)
				{
					parent->_col = uncle->_col = Black;
					grandfather->_col = Red;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//如果叔叔不存在 / 叔叔为黑色 ， 此时需要旋转
				else
				{
					if (cur == parent->_right)
					{
						//此时进行左单旋
						RotateL(grandfather);
						parent->_col = Black;
						grandfather->_col = Red;
					}
					else
					{
						//此时进行右左双旋
						RotateRL(grandfather);
						grandfather->_col = Red;
						cur->_col = Black;
					}
					//旋转之后不可能再出现连续两个红色节点
					//直接break
					break;
				}
			}

		}
		//无论如何根节点都是黑色的！
		_root->_col = Black;
	}

}

2.3 ❤️ 红黑树的测试

我们什么大写特写一顿，是时候来检验一下我们写的红黑数是否满足条件了。
测验的方法就是检查每一条路径的黑色节点个数是否一致。对于这样二叉树的遍历处理，我们很自然的就可以想到DFS深度优先算法。直接暴力遍历一般就好了：
下面是测试一：

void IsBalance()
{
	//dfs检查每一条路径的黑色节点个数
	int num = 0;
	_IsBalance(_root, num);
}
void _IsBalance(Node* root , int num)
{
	if (root == nullptr)
	{
		cout << "黑色节点个数->" << num << endl;
	}
	else
	{
		_IsBalance(root->_left, root->_col == Red ? num : num + 1);
		_IsBalance(root->_right, root->_col == Red ? num : num + 1);
	}
	
}

我来来运行看看：
在这里插入图片描述
可以看到我们使用一个小数组进行的检查是没有问题的，那么接下来我们来一千万个数据来检查一下，我们的检查函数也要进行调整：
测试二

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);
}
bool Check(Node* root, int blackNum, const int refNum)
{
	if (root == nullptr)
	{
		//cout << blackNum << endl;
		if (refNum != blackNum)
		{
			cout << "存在黑色节点的数量不相等的路径" << endl;
			return false;
		}

		return true;
	}

	if (root->_col == Red && root->_parent->_col == Red)
	{
		cout << root->_kv.first << "存在连续的红色节点" << endl;
		return false;
	}

	if (root->_col == Black)
	{
		blackNum++;
	}

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

这样就可以来进行大数据的检查哩：
在这里插入图片描述
一千万的数据我们进行检查后依然是满足红黑树的规则！！！
nice!!!

这样我们就完成了红黑树的构建！！！
😎😎😎😎😎😎😎

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

指针(6)

指针(6)

1. sizeof和strlen的对比 1.1 sizeof 在学习操作符的时候&#xff0c;我们学习了 sizeof &#xff0c; sizeof 计算变量所占内存内存空间大小的&#xff0c;单位是字节&#xff0c;如果操作数是类型的话&#xff0c;计算的是使⽤类型创建的变量所占内存空间的大小。 sizeof 只…
阅读更多...
leetcode:计数质数

leetcode:计数质数

class Solution { public:// 如果 x 是质数&#xff0c;那么大于 x 的 x 的倍数 2x,3x… 一定不是质数int countPrimes(int n) {vector<int> isPrime(n, 1);int ans 0;for (int i 2; i < n; i) {if (isPrime[i]) {ans 1;if ((long long)i * i < n) {for (int j …
阅读更多...
Linux内核重置root密码

Linux内核重置root密码

Ubuntu 首先重新启动Ubuntu系统&#xff0c;然后快速按下shift键&#xff0c;以调出grub启动菜单在这里我们选择第二个&#xff08;Ubuntu高级选项&#xff09;&#xff0c;选中后按下Enter键 选择最高的Linux内核版本所对应的recovery mode模式&#xff0c;按e键编辑启动项 在…
阅读更多...
C语言 | Leetcode C语言题解之第113题路径总和II

C语言 | Leetcode C语言题解之第113题路径总和II

题目&#xff1a; 题解&#xff1a; int** ret; int retSize; int* retColSize;int* path; int pathSize;typedef struct {struct TreeNode* key;struct TreeNode* val;UT_hash_handle hh; } hashTable;hashTable* parent;void insertHashTable(struct TreeNode* x, struct Tr…
阅读更多...
数据结构——链表——模板类实现双向链表——先完成再完美——持续更

数据结构——链表——模板类实现双向链表——先完成再完美——持续更

链表&#xff1a;概念&#xff0c;实现&#xff0c;《数据结构》这里实现是基于模板的 C语言基础&#xff0c;指针&#xff0c;引用。模板。《CPrimer》有些进阶用法放在语言学习的目录 LeetCode应用&#xff0c;会更新在LeetCode150&#xff0c;目前这个系列先暂停&#xff0c…
阅读更多...
【PB案例学习笔记】-09滚动条使用

【PB案例学习笔记】-09滚动条使用

写在前面 这是PB案例学习笔记系列文章的第8篇&#xff0c;该系列文章适合具有一定PB基础的读者。 通过一个个由浅入深的编程实战案例学习&#xff0c;提高编程技巧&#xff0c;以保证小伙伴们能应付公司的各种开发需求。 文章中设计到的源码&#xff0c;小凡都上传到了gitee…
阅读更多...
云界洞见——基于移动云云数据库MySQL应用实践

云界洞见——基于移动云云数据库MySQL应用实践

目录 简介1 新手入门1.1 创建MySQL实例1.2 公网连接MySQL实例 2 操作指南2.1 创建数据库2.2 数据备份设置2.3 日志管理2.4 监控告警2.5 代码审计 3 应用场景4 总结 如今&#xff0c;大型企业如金融企业和银行等&#xff0c;在下一代的微服务架构转型要求下&#xff0c;需要基础…
阅读更多...
C++ prime 第五版 第14章 重载运算与类型转换

C++ prime 第五版 第14章 重载运算与类型转换

一、基本概念 重载的运算符是具有特殊名字的函数&#xff1a;它们的名字由关键字operator和其后要定义的运算符号共同组成。和其他函数一样&#xff0c;重载的运算符也包含返回类型、参数列表以及函数体。 我们不能为内置类型的运算对象重定义运算符。对于一个运算符函数来说&…
阅读更多...
【Week-R1】RNN实现心脏病预测，基于tensorflow框架

【Week-R1】RNN实现心脏病预测，基于tensorflow框架

文章目录 一、什么是RNN&#xff1f;二、准备环境和数据2.1 导入数据 三、构建模型四、训练和预测五、其他&#xff08;1&#xff09;sklearn模块导入报错&#xff1a;ModuleNotFoundError: No module named sklearn&#xff08;2&#xff09;优化器改为SGD&#xff0c;accurac…
阅读更多...
MySQL--备份恢复

MySQL--备份恢复

目录 一、备份恢复的工作职责 1.备份的时间周期 2.备份的方式 3.恢复方案 4.检查备份 5.定期恢复演练 6.故障恢复策略 7.迁移升级 二、逻辑备份工具--mysqldump 1.介绍 2.使用场景 3.mysqldump命令的参数介绍 1&#xff09;全备&#xff1a; 2&#xff09;单库或…
阅读更多...
四轮麦轮平衡车四个轮子安放位置要求，以及编码器测速注意事项（强调，否则无法正常平移）——基于STM32F103ZET6

四轮麦轮平衡车四个轮子安放位置要求，以及编码器测速注意事项（强调，否则无法正常平移）——基于STM32F103ZET6

轮子推荐ABBA&#xff0c;当然BAAB也可以 如图安放&#xff1a; 这两种安防位置可以实现平移效果 若要实现平移则需要先实现PID控制平衡&#xff0c;这里用到520编码电机&#xff0c;相较于370电机他的动力更足&#xff0c;在调节PID时能节约不少时间而且更加容易。 需要注意…
阅读更多...
基于离散小波变换(DWT)的心电信号伪影去除及心电信号PQRST波检测（MATLAB R2018）

基于离散小波变换(DWT)的心电信号伪影去除及心电信号PQRST波检测（MATLAB R2018）

心电信号是心脏神经&#xff0c;肌肉组织电化学活动的表现形式。这些电化学活动使心脏内部产生一系列非常协调的电刺激脉冲&#xff0c;分别使心房&#xff0c;心室的肌肉细胞兴奋&#xff0c;从而有节律的舒张和收缩。这些生物电活动在体表的不同部位形成不同的电位差变化&…
阅读更多...
622.设计循环队列

622.设计循环队列

typedef struct {int* a;int head;int tail;int k; } MyCircularQueue;bool myCircularQueueIsEmpty(MyCircularQueue* obj); bool myCircularQueueIsFull(MyCircularQueue* obj);//初始化 MyCircularQueue* myCircularQueueCreate(int k) {MyCircularQueue* obj(MyCircularQue…
阅读更多...
ARM+FPGA+NVIDIA AI摄像头软硬件定制

ARM+FPGA+NVIDIA AI摄像头软硬件定制

拥有资深ISP图像技术团队&#xff0c;是英伟达、地平线等合作伙伴&#xff0c;我们的团队掌握目前市面上大部分车载平台的ISP图像画质服务能力&#xff0c;能自主开发图像ISP和增强算法。我们具有多名经验丰富光学设计专家&#xff0c;掌握车载模组光学设计能力&#xff0c;资深…
阅读更多...
Mac上如何安装低版本chrome浏览器

Mac上如何安装低版本chrome浏览器

背景 为了排查项目上使用chrome低版本的兼容性问题&#xff0c;需要在本机【mac系统】上安装一个低版本的chrome浏览器。 不同版本的chrome下载地址 https://www.slimjet.com/chrome/google-chrome-old-version.php 下载后要记得你下载的旧版本的版本号&#xff0c;后面修改…
阅读更多...
Neural Filters：着色

Neural Filters：着色

Ps菜单&#xff1a;滤镜/Neural Filters/颜色/着色 Neural Filters/COLOR/Colorize 着色 Colorize滤镜可以对黑白照片自动着色&#xff0c;也为彩色照片简化色彩提供了有力的支持。 “着色”滤镜利用深度学习技术&#xff0c;对输入的黑白或彩色照片进行分析&#xff0c;识别图…
阅读更多...
【云原生】kubernetes声明式管理-----YAML文件

【云原生】kubernetes声明式管理-----YAML文件

目录 引言 一、声明式管理简介 &#xff08;一&#xff09;什么是声明式管理 &#xff08;二&#xff09;支持格式 二、YAML文件 &#xff08;一&#xff09;YAML文件基本格式 &#xff08;二&#xff09;YAML文件实践 三、YAML文件创建方式 &#xff08;一&#xff0…
阅读更多...
rk3568_spinlock

rk3568_spinlock

文章目录 前言1、spinlock是什么？2、自旋锁实验2.1源码2.2 结果图总结前言 本文记录在rk3568开发板做的自旋锁实验。通过自旋锁控制state变量来限制只有一个应用程序来打开驱动设备。 1、spinlock是什么？ spinlock称为自旋锁，如果获取不到资源，就只能一直傻傻地等待资源被…
阅读更多...
B树与B+树区别

B树与B+树区别

B树和B树是常见的数据库索引结构&#xff0c;都具有相较于二叉树层级较少&#xff0c;查找效率高的特点&#xff0c;它们之间有以下几个主要区别&#xff1a; 1.节点存储数据的方式不同 B树的叶子结点和非叶子节点都会存储数据&#xff0c;指针和数据共同保存在同一节点中B树…
阅读更多...
一文教你使用stream流轻松解决java项目数据枚举显示问题

一文教你使用stream流轻松解决java项目数据枚举显示问题

本篇文章主要讲解java枚举、vo实体类通过stream流形式输出枚举参数的方法。 日期&#xff1a;2024年5月26日 作者&#xff1a;任聪聪 本文代码实例附件&#xff1a;https://download.csdn.net/download/hj960511/89361611 实际效果 可以看到在枚举参数的基础上&#xff0c;我们…
阅读更多...
最新文章

Copyright @ 2022~2023