【数据结构】红黑树（C++实现）

👀樊梓慕：个人主页

 🎥个人专栏：《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》《Linux》《算法》

🌝每一个不曾起舞的日子，都是对生命的辜负

目录

前言

1.概念

2.性质

3.节点的定义 

4.插入

4.1情况1：叔叔u存在且为红

4.2情况2：叔叔u不存在或者叔叔u存在且为黑

4.3代码实现

5.验证

6.红黑树完整源码

7.AVL树与红黑树的性能比较

前言

如果没有现在的红黑树的话，那么可能set与map底层的数据结构就是AVL树了，那么红黑树的设计为什么能够取代AVL树的地位呢，红黑树的设计又有哪些奥秘，今天让我们一同来探索一下吧！

欢迎大家📂收藏📂以便未来做题时可以快速找到思路，巧妙的方法可以事半功倍。 

=========================================================================

GITEE相关代码：🌟樊飞 (fanfei_c) - Gitee.com🌟

=========================================================================

1.概念

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

红黑树不像AVL树那样绝对的平衡，而是接近平衡，

但是这个影响是常数级别的，接着往下看。

2.性质

了解了红黑树的性质，你就明白了为什么红黑树是如何控制平衡的。

  • 每个结点不是红色就是黑色
  • 根节点是黑色的
  • 如果一个节点是红色的，则它的两个孩子结点必须是黑色的（没有连续的红色节点）。
  • 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。
  • 每个叶子结点都是黑色的(此处的叶子结点指的是空结点-NIL节点，因为路径指的是从根节点走到空，而不是从根节点走到叶子节点，所以设计者专门将空节点定义为NIL节点默认为黑色，就是为了防止人们数错路径)。

接下来我们构建极端场景来分析下为什么最长路径中节点的个数不会超过最短路径节点个数的两倍？

  • 最短路径情况：节点为全黑。
  • 最长路径情况：一黑一红排列。
  • 大前提：每条路径都包含相同数量的黑色节点。

举例：

而且红黑树不是每次搜索都是2*logN。 

 AVL树与红黑树搜索效率基本平齐，但是AVL树实现更小的高度的方法是频繁地旋转，而旋转的开销还是比较大的，所以AVL树有点『 得不偿失』。

红黑树虽然也需要旋转来控制高度，但是引入了颜色控制，可以减少旋转的次数。

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.插入

因为新节点的默认颜色是红色，因此

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

所以以下都是当新插入节点的父节点为红色时的情况： 

4.1情况1：叔叔u存在且为红

 g的颜色是确定为黑的，因为如果g不为黑，那么就证明上一层就已经不满足红黑树的规则了。

此时c一定是新插入的节点，并且已经破坏了没有连续的红色节点的规则，所以我们需要进行调整。

调整的办法：p/u变黑，g变红。

 g变红的目的是为了保持当前分支黑色节点的数目不变。

但这里注意：

  • 如果g为根节点，那么需要再将g变黑（规则：根节点必须是黑色），即将所有路径的黑色节点数都+1，仍然符合规则。
  • 如果g不为根节点，那么g为红色，此时将g视为cur，继续向上调整。

4.2情况2：叔叔u不存在或者叔叔u存在且为黑

 同样的g的颜色是确定为黑的，因为如果g不为黑，那么就证明上一层就已经不满足红黑树的规则了。

  • 如果叔叔u不存在，那么c一定是新插入的节点，因为叔叔u不存在说明在parent的下面不可能再挂黑色结点了。
  • 如果叔叔u存在且为黑，那么c一定不是新插入的节点，因为之前已经不满足规则了，所以c一定是刚刚变红的，也就是说有可能是情况1调整过后，将c变红的。 

此时单纯地变色已经无法处理了，所以此时我们需要进行旋转。

很明显根据之前学习的AVL树，面对如上图情况时我们需要对g进行右旋。 

即当p为g的左，cur为p的左时对g进行右旋：

注意：之前分析由于cur是因为之前的调整才变红的，所以cur向下的路径中一定有一个黑色节点与叔叔抵消，此时达到平衡。

如果叔叔不存在也是一样的对g进行右旋即可：

那么假如cur在p的右子树上呢？此时则需要先左旋再右旋。

即当p为g左，cur为p的右时进行左右双旋，然后变色。

  同样的如果叔叔不存在也是一样的进行左右双旋，然后变色。

总结下来就以上这些种情况，相信你掌握了左面的这些种情况，右面也非常简单。

4.3代码实现

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); // 红色的
	if (parent->_kv.first < 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)
		{
			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)
				{
					//       g
					//    p    u
					// c
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//       g
					//    p     u
					//      c
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else
		{
			Node* uncle = grandfather->_left;
			// 情况一：叔叔存在且为红
			if (uncle && uncle->_col == RED)
			{
				// 变色
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				// 继续往上处理
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				// 情况二：叔叔不存在或者存在且为黑
				// 旋转+变色
				//      g
				//   u     p
				//            c
				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;
}

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

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

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

	if (parent == _root)
	{
		_root = subR;
		subR->_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;

	subL->_right = parent;

	Node* ppnode = parent->_parent;
	parent->_parent = subL;

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

5.验证

红黑树的验证分为两步：

首先要对树是否满足搜索特性进行检测，这一部分我们只需要对树进行中序遍历，观察得到的序列是否为有序序列即可。

其次就是如何判断该树满足红黑树的特性呢？

其实就是看是否满足红黑树的规则即可。

即：

  • 根节点是黑色的；
  • 没有连续的红色节点；
  • 每条路径均包含相同数目的黑色结点。

首先根节点是否为黑很好检测。

其次是否有连续的红色节点，由于我们采用的是三叉链式结构，我们维护了父亲节点，所以只需要判断当前节点和父亲节点是否同时为红即可。

最后就是如何判断每条路径的黑色节点数目是否相同，其实最简单的做法就是先统计一下最左路径的黑色节点数目，然后将该值作为参考，检验其他路径是否与该值相同即可。

bool Check(Node* cur, int blackNum, int refBlackNum)
{
	if (cur == nullptr)
	{
		if (refBlackNum != blackNum)
		{
			cout << "黑色节点的数量不相等" << endl;
			return false;
		}
		return true;
	}

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

	if (cur->_col == BLACK)
		++blackNum;

	return Check(cur->_left, blackNum, refBlackNum)
		&& Check(cur->_right, blackNum, refBlackNum);
}

bool IsBalance()
{
	if (_root && _root->_col == RED)
		return false;

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

		cur = cur->_left;
	}
	return Check(_root, 0, refBlackNum);
}

6.红黑树完整源码

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)
	{}
};

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); // 红色的
		if (parent->_kv.first < 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)
			{
				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)
					{
						//       g
						//    p    u
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//       g
						//    p     u
						//      c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					//      g
					//   u     p
					//            c
					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;
	}

	void RotateL(Node* parent)
	{
		++rotateSize;

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

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

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

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

	void RotateR(Node* parent)
	{
		++rotateSize;

		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = subL;

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

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << endl;
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
	}

	bool Check(Node* cur, int blackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			if (refBlackNum != blackNum)
			{
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}

			//cout << blackNum << endl;
			return true;
		}

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

		if (cur->_col == BLACK)
			++blackNum;

		return Check(cur->_left, blackNum, refBlackNum)
			&& Check(cur->_right, blackNum, refBlackNum);
	}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

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

			cur = cur->_left;
		}

		return Check(_root, 0, refBlackNum);
	}

	size_t Size()
	{
		return _Size(_root);
	}

	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

		return _Size(root->_left)
			+ _Size(root->_right) + 1;
	}

	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 NULL;
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	int Height()
	{
		return _Height(_root);
	}

	int GetRotateSize()
	{
		return rotateSize;
	}

private:
	Node* _root = nullptr;
	int rotateSize = 0;
};

注：rotateSize成员是用来记录旋转次数的，若不记录可以删除。 

7.AVL树与红黑树的性能比较

 如上图，这是在一千万数据下得到的测试结果。

结论：红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是logN，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，红黑树降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多（比如STL库中的set和map容器，linux内核等等）。而AVL树虽然在高度和搜索上优于红黑树，但基本可以忽略。

=========================================================================

如果你对该系列文章有兴趣的话，欢迎持续关注博主动态，博主会持续输出优质内容

🍎博主很需要大家的支持，你的支持是我创作的不竭动力🍎

🌟~ 点赞收藏＋关注 ~🌟

=========================================================================

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

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

相关文章

企业微信HOOK协议，新设备二次验证处理

企业微信HOOK协议，新设备二次验证处理

提示设备强制二次验证问题已处理 HOOK&#xff1a;https://www.showdoc.com.cn/1663062930779972/7859611259700402密码&#xff1a;999999999
阅读更多...
蓝桥杯练习系统（算法训练）ALGO-979 移动

蓝桥杯练习系统（算法训练）ALGO-979 移动

资源限制 内存限制&#xff1a;256.0MB C/C时间限制&#xff1a;1.0s Java时间限制&#xff1a;3.0s Python时间限制&#xff1a;5.0s 问题描述 给定一个n长的数列&#xff0c;有m次操作&#xff0c;第i次操作表示将整个数列循环移动mi位&#xff0c;询问每次操作结束后…
阅读更多...
前端解决跨域问题（ 6种方法 ）

前端解决跨域问题（ 6种方法 ）

本专栏是汇集了一些HTML常常被遗忘的知识&#xff0c;这里算是温故而知新&#xff0c;往往这些零碎的知识点&#xff0c;在你开发中能起到炸惊效果。我们每个人都没有过目不忘&#xff0c;过久不忘的本事&#xff0c;就让这一点点知识慢慢渗透你的脑海。 本专栏的风格是力求简洁…
阅读更多...
【MATLAB源码-第160期】基于matlab的胡桃夹子优化算法（NOA）无人机三维路径规划，输出做短路径图和适应度曲线

【MATLAB源码-第160期】基于matlab的胡桃夹子优化算法（NOA）无人机三维路径规划，输出做短路径图和适应度曲线

操作环境&#xff1a; MATLAB 2022a 1、算法描述 胡桃夹子优化算法&#xff08;Nutcracker Optimization Algorithm, NOA&#xff09;是一个灵感来源于胡桃夹子的故事的元启发式优化算法。这个故事中&#xff0c;胡桃夹子是一个能够将坚果壳轻易地破开以获取内部果仁的工具。…
阅读更多...
linux系统adb调试工具

linux系统adb调试工具

adb的全称为Android Debug Bridge&#xff0c;就是起到调试桥的作用。通过adb可以在Eclipse中通过DDMS来调试Android程序&#xff0c;说白了就是调试工具。 adb的工作方式比较特殊&#xff0c;采用监听Socket TCP 5554等端口的方式让IDE和Qemu通讯&#xff0c;默认情况下adb会…
阅读更多...
Rust接收命令行参数和新建文件读写和追加操作与IO

Rust接收命令行参数和新建文件读写和追加操作与IO

接收命令行参数 命令行程序是计算机程序最基础的存在形式&#xff0c;几乎所有的操作系统都支持命令行程序并将可视化程序的运行基于命令行机制。 命令行程序必须能够接收来自命令行环境的参数&#xff0c;这些参数往往在一条命令行的命令之后以空格符分隔。 在很多语言中&a…
阅读更多...
145.乐理基础-增三和弦、减三和弦

145.乐理基础-增三和弦、减三和弦

内容参考于&#xff1a;三分钟音乐社 上一个内容&#xff1a;144.根三五音、大三和弦、小三和弦 上一个内容里练习的答案&#xff1a; 增三和弦与减三和弦的结构 增三和弦例子&#xff1a; 下图红框里的乐谱是c、e、升g&#xff0c;这个和弦&#xff0c;c-e是大三度&#xff…
阅读更多...
_note_06

_note_06

1.说一说函数的按地址传递和按值传递&#xff0c;他们的区别是什么&#xff1f; 函数的参数传递方式可以分为按地址传递&#xff08;也称为按引用传递&#xff09;和按值传递两种方式。按值传递是指将实际参数的值复制给形式参数&#xff0c;即在函数调用时&#xff0c;实际参数…
阅读更多...
Ps：画笔工具

Ps：画笔工具

画笔工具 Brush Tool是 Photoshop 中最常用的工具&#xff0c;可广泛地用于绘画与修饰工作之中。 快捷键&#xff1a;B ◆ ◆ ◆ 常用操作方法与技巧 1、熟练掌握画笔工具的操作对于使用其他工具也非常有益&#xff0c;因为 Photoshop 中许多与笔刷相关的工具有类似的选项和操…
阅读更多...
Nestjs与Vue实现多人聊天[简易版]

Nestjs与Vue实现多人聊天[简易版]

本项目是一个小demo,帮助各位理清一点开发思路&#xff0c;作为一个小参考&#xff0c;虽然技术栈是nodejs。但是其他语言也是相通的。 准备环境&#xff1a; Nodejs version >18.13.0Vue3Nestjssoket.io 一、初始化 打开一个路径启动cmd窗口&#xff0c;初始化前后端项…
阅读更多...
智慧城市的前景：数字孪生技术在智慧城市中的应用前景

智慧城市的前景：数字孪生技术在智慧城市中的应用前景

目录 一、引言 二、数字孪生技术及其在智慧城市中的应用概述 三、数字孪生技术在智慧城市中的应用前景 1、城市规划与仿真模拟 2、智能交通与出行服务 3、智慧环保与可持续发展 4、智慧公共服务与社会治理 5、智慧能源与绿色建筑 四、数字孪生技术在智慧城市中的挑战与…
阅读更多...
CSS 入门指南（二）CSS 常用样式及注册页面案例

CSS 入门指南（二）CSS 常用样式及注册页面案例

CSS 常用样式 颜色属性 常见样式的颜色属性&#xff1a; color&#xff1a;定义文本的颜色border-color&#xff1a;定义边框的颜色background-color&#xff1a;设置背景色 颜色属性值设置方式&#xff1a; 十六进制值 - 如&#xff1a;&#xff03;FF0000一个RGB值 - 如…
阅读更多...
冬去春来天气阴晴不定 美食拿捏味蕾安稳换季

冬去春来天气阴晴不定 美食拿捏味蕾安稳换季

俗话说“春打六九头”&#xff0c;3月虽然已经入春&#xff0c;但是天气依然是凉飕飕的 &#xff0c;冬天春天的换季期&#xff0c;因为天气的变化&#xff0c;尤为痛苦。但是来到了换季期&#xff0c;天气也不总是那么稳定&#xff0c;随着气温的起伏&#xff0c;我们的食欲也…
阅读更多...
Orange3数据预处理(预处理器组件)

Orange3数据预处理(预处理器组件)

1.组件介绍 Orange3 提供了一系列的数据预处理工具&#xff0c;这些工具可以帮助用户在数据分析之前准备好数据。以下是您请求的预处理组件的详细解释&#xff1a; Discretize Continuous Variables&#xff08;离散化连续变量&#xff09;&#xff1a; 这个组件将连续变量转…
阅读更多...
Python调用edge-tts实现在线文字转语音

Python调用edge-tts实现在线文字转语音

edge-tts是一个 Python 模块&#xff0c;允许通过Python代码或命令的方式使用 Microsoft Edge 的在线文本转语音服务。 项目源码 GitHub - rany2/edge-tts: Use Microsoft Edges online text-to-speech service from Python WITHOUT needing Microsoft Edge or Windows or an…
阅读更多...
力扣hot---岛屿数量

力扣hot---岛屿数量

dfs思路&#xff1a; 首先通过两层for循环遍历每一个点&#xff0c;如果这个点为0或者2&#xff08;这个2是什么呢&#xff1f;是在遍历该点以及该点连成的这一片区域中&#xff0c;因为通过深度优先搜索&#xff0c;遍历该点就等于遍历这一片区域&#xff0c;遍历这篇区域中的…
阅读更多...
打字通小游戏制作教程：用HTML5和JavaScript提升打字速度

打字通小游戏制作教程：用HTML5和JavaScript提升打字速度

&#x1f31f; 前言 欢迎来到我的技术小宇宙&#xff01;&#x1f30c; 这里不仅是我记录技术点滴的后花园&#xff0c;也是我分享学习心得和项目经验的乐园。&#x1f4da; 无论你是技术小白还是资深大牛&#xff0c;这里总有一些内容能触动你的好奇心。&#x1f50d; &#x…
阅读更多...
strlen和sizeof的应用与区别

strlen和sizeof的应用与区别

sizeof和strlen作为都能求大小的工具两者之间有何不同, strlen: 1. strlrn计算的是什么的大小 strlen计算的是字符串长度的大小&#xff0c;所以strlen在计算字符串长度时会一直顺着字符串的元素一个一个的查找&#xff0c;一直到查询到了/0才会停止 2.strlen属于库函数&am…
阅读更多...
C# 用 System.Xml 读 Freeplane.mm文件，生成测试用例.csv文件

C# 用 System.Xml 读 Freeplane.mm文件，生成测试用例.csv文件

Freeplane 是一款基于 Java 的开源软件&#xff0c;继承 Freemind 的思维导图工具软件&#xff0c;它扩展了知识管理功能&#xff0c;在 Freemind 上增加了一些额外的功能&#xff0c;比如数学公式、节点属性面板等。 先写一个测试程序 test_read_Xml.cs 如下 using System;…
阅读更多...
基于springboot+vue实现开放实验室管理系统项目【项目源码+论文说明】

基于springboot+vue实现开放实验室管理系统项目【项目源码+论文说明】

基于springbootvue实现企业任务管理追踪系统演示 摘要 信息技术永远是改变生活的第一种创新方式&#xff0c;各种行业的发展更是脱离不了科技化的支持。原本传统的行业正在被科技行业的切入悄悄的发生变化。就拿我们生活当中常见的事情举例而言&#xff0c;在外卖行业还没有发…
阅读更多...
最新文章

Copyright @ 2022~2023