[数据结构]-红黑树

news2024/11/16 20:43:09

前言

作者：小蜗牛向前冲

名言：我可以接受失败，但我不能接受放弃

  如果觉的博主的文章还不错的话，还请点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正

目录

一、红黑树的基本知识

 1、红黑树的概念

2、性质 

二、红黑树的模拟实现 

1、节点的定义

2、红黑树的插入 

三、红黑树的测试

1、验证的准备工作

2、测试用例 

3、完整代码实现 

四、AVL树和红黑树的比较 

本期学习目标：什么是红黑树，红黑树是怎么实现的，红黑树的测试，红黑树和AVL树的对比 

一、红黑树的基本知识

 1、红黑树的概念

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

2、性质 

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

 推论：

  1. 最短路径：全部由黑节点组成
  2. 最长路径：一黑一红，红节点数量 == 黑节点数量

这里我们思考一下，红黑树是如何保证：最长路径不超过最短路径的2倍？

  • 由推论2可知，对于最长路经，就是一红一黑，而且红节点数量等于黑节点数量，
  • 在由推论1可知，最短路径节点数量全为黑。
  • 在由性质4可知，每条路径的黑节点数量都相同，这就保证了最长路径不超过2倍的最短路径。

二、红黑树的模拟实现 

1、节点的定义

enum Colour
{
	RED,
	BLACK,
};

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

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

2、红黑树的插入 

根据节点的定义，我们上面定义了一个枚举类型了存放显色的类型，RED和BLACK，但是我们在插入节点的时候是定义红色还是黑色呢？我们在上面定义的是红色为什么呢？

这里分类讨论一下：

定义新插入节点为黑色：

就会破坏性质4，导致每天路径的黑色节点数量不同

定义新插入节点为红色：

可能会破坏性质3，导致出现连续的红节点，但是这样也仅仅影响的是一条路径，影响有限。

综上所述：所以我们选择插入节点为红色。

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

1. 按照二叉搜索的树规则插入新节点

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

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

约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点(p：parent g：grandfather u：uncle)

当p为g的左孩子时，有3种情况需要讨论

情况1：

 

 情况2：

情况3：

 当p为g的右孩子时，也有3种情况需要讨论

这里的讨论和上面相似，处理方法也相似：

情况1：

情况2: 

情况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->_left;
		}
		else if (cur->_kv.first < kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}

	//找到了
	cur = new Node(kv);
	cur->_col = RED;//默认颜色为红色
	//链接节点
	if (parent->_kv.first > kv.first)
	{
		parent->_left = cur;
		cur->_parent = parent;
	}
	else
	{
		parent->_right = cur;
		cur->_parent = parent;
	}

	//插入后要调整红黑树
	//如果父亲存在且为红色
	while (parent && parent->_col == RED)
	{
		Node* grandparent = parent->_parent;
		//情况1：cur为红色，p和u都为红色，g为黑色,这里的u是存在的
		//解决方法:p和n都变黑,g变红,在把cur当做g继续调整
		if (parent == grandparent->_left)
		{
			Node* uncle = grandparent->_right;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandparent->_col = RED;
				cur = grandparent;
				//更新parent
				parent = cur->_parent;
			}
			else//情况2+3  uncle存在且为黑色或者uncle不存在
			{
				if (cur == parent->_left)
				{
					//情况2
					//解决方法:右单旋，将p变黑，g变红
					RotateR(grandparent);
					parent->_col = BLACK;
					grandparent->_col = RED;
				}
				else//情况3：双旋转
				{
					RotateL(parent);
					RotateR(grandparent);
					grandparent->_col = RED;
					cur->_col = BLACK;//双旋转后cur变为了根
				}
				//这里类比根节点为色，不需要在调整了
				break;
			}
		}
		else//grandparent->right == parent
		{
			//这里也是和上面一样分为三种情况
			Node* grandparent = parent->_parent;
			Node* uncle = grandparent->_left;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandparent->_col = RED;
				cur = grandparent;
				//更新parent
				parent = cur->_parent;
			}
			else
			{
				if (cur == parent->_right)
				{
					RotateL(grandparent);//左单旋转
					parent->_col = BLACK;
					grandparent->_col = RED;
				}
				else
				{
					RotateR(parent);
					RotateL(grandparent);
					grandparent->_col = RED;
					cur->_col = BLACK;//双旋转后cur变为了根
				}
				break;
			}
		}
	}
	//调整完成，把根节点变黑
	_root->_col = BLACK;
	return true;
}
//右单旋
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	Node* grandparent = parent->_parent;
	//让subLR变为parent的左,
	parent->_left = subLR;
	//这里要判断一下subLR不为空
	if (subLR)
	{
		subLR->_parent = parent;
	}
	//parent变为subL的右
	subL->_right = parent;
	parent->_parent = subL;
	//parent就是为根
	if (grandparent == nullptr)
	{
		_root = subL;
		subL->_parent = grandparent;
	}
	else
	{
		//parnet是上grandparent的左子树
		if (grandparent->_left == parent)
		{
			grandparent->_left = subL;
		}
		else
		{
			grandparent->_right = subL;
		}
		subL->_parent = grandparent;
	}
}

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

	parent->_right = subRL;
	if (subRL)
	{
		subRL->_parent = parent;
	}
	
	subR->_left = parent;
	parent->_parent = subR;
	//parnet为根,要更新根
	if (ppNode == nullptr)
	{
		_root = subR;
		subR->_parent = ppNode;
	}
	else
	{
		if (ppNode->_left == parent)
		{
			ppNode->_left = subR;
		}
		else
		{
			ppNode->_right = subR;
		}
		subR->_parent = ppNode;
	}
}

三、红黑树的测试

1、验证的准备工作

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)

  2. 检测其是否满足红黑树的性质
    检测方法：
    1、根节点是黑色，否则不是红黑树
    2、当前节点是红色，去检测父亲节点，父亲节点也是红色，则不是红黑树
    3、以最左侧路径的黑色节点为基准，其它路径上的黑色节点与基准不相等，不是红黑树

 检验代码：

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)
	{
		//已经递归到最深处进行,本路径的黑节点树和ref数量对比
		if (blackNum != ref)
		{
			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, ref)
		&& Check(root->_right, blackNum, ref);
}

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

	if (_root->_col != BLACK)
	{
		return false;
	}
	//求出最左路节点有多少个黑节点
	int ref = 0;
	Node* left = _root;
	while (left)
	{
		if (left->_col == BLACK)
		{
			++ref;
		}

		left = left->_left;
	}

	return Check(_root, 0, ref);
}

2、测试用例 

这里我们借用上面AVL树的测试用例即可

void TestRBTree1()
{
	//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTreeh<int, int> t;
	for (auto e : a)
	{
		/*if (e == 18)
		{
			int x = 0;
		}*/

		t.insert(make_pair(e, e));
		cout << "insert" << e << ":" << t.IsBalance() << endl;
	}

	t.Inorder();

	cout << t.IsBalance() << endl;
}

void TestRBTree2()
{
	srand(time(0));
	const size_t N = 100000;
	RBTreeh<int, int> t;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand();
		t.insert(make_pair(x, x));
		//cout << t.IsBalance() << endl;
	}

	//t.Inorder();
	cout << t.IsBalance() << endl;
}

3、完整代码实现 

#pragma once

enum Colour
{
	RED,
	BLACK,
};

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

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

template<class K,class V>
class RBTreeh
{
	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->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		//找到了
		cur = new Node(kv);
		cur->_col = RED;//默认颜色为红色
		//链接节点
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		//插入后要调整红黑树
		//如果父亲存在且为红色
		while (parent && parent->_col == RED)
		{
			Node* grandparent = parent->_parent;
			//情况1：cur为红色，p和u都为红色，g为黑色,这里的u是存在的
			//解决方法:p和n都变黑,g变红,在把cur当做g继续调整
			if (parent == grandparent->_left)
			{
				Node* uncle = grandparent->_right;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					cur = grandparent;
					//更新parent
					parent = cur->_parent;
				}
				else//情况2+3  uncle存在且为黑色或者uncle不存在
				{
					if (cur == parent->_left)
					{
						//情况2
						//解决方法:右单旋，将p变黑，g变红
						RotateR(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
					else//情况3：双旋转
					{
						RotateL(parent);
						RotateR(grandparent);
						grandparent->_col = RED;
						cur->_col = BLACK;//双旋转后cur变为了根
					}
					//这里类比根节点为色，不需要在调整了
					break;
				}
			}
			else//grandparent->right == parent
			{
				//这里也是和上面一样分为三种情况
				Node* grandparent = parent->_parent;
				Node* uncle = grandparent->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					cur = grandparent;
					//更新parent
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateL(grandparent);//左单旋转
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandparent);
						grandparent->_col = RED;
						cur->_col = BLACK;//双旋转后cur变为了根
					}
					break;
				}
			}
		}
		//调整完成，把根节点变黑
		_root->_col = BLACK;
		return true;
	}
	//右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* grandparent = parent->_parent;
		//让subLR变为parent的左,
		parent->_left = subLR;
		//这里要判断一下subLR不为空
		if (subLR)
		{
			subLR->_parent = parent;
		}
		//parent变为subL的右
		subL->_right = parent;
		parent->_parent = subL;
		//parent就是为根
		if (grandparent == nullptr)
		{
			_root = subL;
			subL->_parent = grandparent;
		}
		else
		{
			//parnet是上grandparent的左子树
			if (grandparent->_left == parent)
			{
				grandparent->_left = subL;
			}
			else
			{
				grandparent->_right = subL;
			}
			subL->_parent = grandparent;
		}
	}

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

		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		
		subR->_left = parent;
		parent->_parent = subR;
		//parnet为根,要更新根
		if (ppNode == nullptr)
		{
			_root = subR;
			subR->_parent = ppNode;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_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)
		{
			//已经递归到最深处进行,本路径的黑节点树和ref数量对比
			if (blackNum != ref)
			{
				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, ref)
			&& Check(root->_right, blackNum, ref);
	}

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

		if (_root->_col != BLACK)
		{
			return false;
		}
		//求出最左路节点有多少个黑节点
		int ref = 0;
		Node* left = _root;
		while (left)
		{
			if (left->_col == BLACK)
			{
				++ref;
			}

			left = left->_left;
		}

		return Check(_root, 0, ref);
	}
private:
	Node* _root = nullptr;

};

void TestRBTree1()
{
	//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTreeh<int, int> t;
	for (auto e : a)
	{
		/*if (e == 18)
		{
			int x = 0;
		}*/

		t.insert(make_pair(e, e));
		cout << "insert" << e << ":" << t.IsBalance() << endl;
	}

	t.Inorder();

	cout << t.IsBalance() << endl;
}

//void TestRBTree2()
//{
//	srand(time(0));
//	const size_t N = 100000;
//	RBTreeh<int, int> t;
//	for (size_t i = 0; i < N; ++i)
//	{
//		size_t x = rand();
//		t.insert(make_pair(x, x));
//		//cout << t.IsBalance() << endl;
//	}
//
//	//t.Inorder();
//	cout << t.IsBalance() << endl;
//}

四、AVL树和红黑树的比较 

AVL树（Adelson-Velsky and Landis tree）和红黑树都是自平衡的二叉搜索树，它们在维持树的平衡性上采用了不同的策略。以下是它们之间的一些比较：

  1. 平衡性维护策略：

    • AVL树： 通过保持任意节点的左右子树的高度差（平衡因子）不超过1来维护平衡。在每次插入或删除操作后，可能需要旋转来恢复平衡。
    • 红黑树： 通过引入额外的颜色信息和一些规则，确保树的高度保持在较小的范围内。具体来说，红黑树的平衡性维护是通过节点的颜色和一些颜色约束来实现的。

  2. 平衡因子和颜色信息：

    • AVL树： 使用平衡因子（Balance Factor）来表示每个节点左右子树的高度差。通常，平衡因子为 -1、0、1。
    • 红黑树： 使用颜色信息（红色或黑色）来表示树的平衡状态。通过遵循红黑树的性质，确保了树的平衡。

  3. 旋转操作：

    • AVL树： 插入或删除可能需要执行多次旋转操作，包括左旋、右旋、左右旋、右左旋等。
    • 红黑树： 插入或删除通常只需要执行一到两次旋转操作，因为红黑树引入了颜色信息，更灵活地维持平衡。

  4. 性能影响：

    • AVL树： 由于 AVL 树对平衡的要求更为严格，因此在插入和删除等操作时可能会导致更多的旋转，相对来说更耗费性能。
    • 红黑树： 由于其相对宽松的平衡条件，红黑树在插入和删除等操作时通常执行的旋转较少，因此性能可能相对更好。

  5. 应用场景：

    • AVL树： 适用于对搜索性能有较高要求的场景，例如在数据库中需要快速检索数据。
    • 红黑树： 通常在需要高效的插入和删除操作的情况下使用，例如在集合类的实现中。

总体而言，选择 AVL 树还是红黑树取决于应用的特定需求。如果搜索操作远远超过插入和删除，可能更倾向于使用 AVL 树。而在插入和删除操作频繁的情况下，红黑树可能更为适用。

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

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

相关文章

Oracle的安装及使用流程

Oracle的安装及使用流程

Oracle的安装及使用流程 1.Win10安装Oracle10g 1.1 安装与测试 安装版本&#xff1a; OracleXEUniv10.2.1015.exe 步骤参考&#xff1a;oracleXe下载与安装 安装完成后测试是否正常 # 输入命令连接oracle conn sys as sysdba; # 无密码&#xff0c;直接按回车 # 测试连接的s…
阅读更多...
kafka 集群 KRaft 模式搭建

kafka 集群 KRaft 模式搭建

Apache Kafka是一个开源分布式事件流平台&#xff0c;被数千家公司用于高性能数据管道、流分析、数据集成和关键任务应用程序 Kafka 官网&#xff1a;https://kafka.apache.org/ Kafka 在2.8版本之后&#xff0c;移除了对Zookeeper的依赖&#xff0c;将依赖于ZooKeeper的控制器…
阅读更多...
MySQL 库操作 | 表操作

MySQL 库操作 | 表操作

文章目录 一.MySQL库的操作1.创建数据库2.字符集和校验规则3.操纵数据库 二.MySQL表的操作1.创建表2.操作表3.删除表 一.MySQL库的操作 1.创建数据库 创建数据库 创建数据库的SQL如下&#xff1a; CREATE DATABASE [IF NOT EXISTS] db_name [[DEFAULT] CHARSETcharset_name…
阅读更多...
AT89S52单片机智能寻迹小车自动红外避障趋光检测发声发光设计

AT89S52单片机智能寻迹小车自动红外避障趋光检测发声发光设计

wx供重浩&#xff1a;创享日记 对话框发送&#xff1a;寻迹 获取完整说明报告源程序数据 小车具有以下几个功能&#xff1a;自动避障功能&#xff1b;寻迹功能&#xff08;按路面的黑色轨道行驶&#xff09;&#xff1b;趋光功能&#xff08;寻找前方的点光源并行驶到位&…
阅读更多...
数据查询，让表单之间“联动”起来！丨三叠云

数据查询，让表单之间“联动”起来！丨三叠云

数据查询 路径 表单设计 >> 字段属性 功能简介 「数据查询」增加触发「数据联动」功能。本次对「数据查询」字段的功能进行优化&#xff0c;这次升级包含「编辑关联数据」、「导入数据」「拷贝数据」&#xff0c;以提高数据操作时的便利。 适用场景&#xff1a; 销…
阅读更多...
.NET6 开发一个检查某些状态持续多长时间的类

.NET6 开发一个检查某些状态持续多长时间的类

📢欢迎点赞 ：👍 收藏 ⭐留言 📝 如有错误敬请指正，赐人玫瑰，手留余香！📢本文作者：由webmote 原创📢作者格言：新的征程，我们面对的不仅仅是技术还有人心，人心不可测，海水不可量，唯有技术，才是深沉黑夜中的一座闪烁的灯塔 ！序言 在代码的世界里，时常碰撞…
阅读更多...
操作系统：操作系统教程第六版（骆斌、葛季栋、费翔林）习题二处理器管理

操作系统：操作系统教程第六版（骆斌、葛季栋、费翔林）习题二处理器管理

目录 前言1. 简答题2. 应用题 前言 本系列文章是针对操作系统教程第六版&#xff08;骆斌、葛季栋、费翔林&#xff09;的习题解答&#xff0c;其中简答题部分为博主自己搜索整理的&#xff0c;错漏之处在所难免。应用题部分有答案为依据。 1. 简答题 &#xff08;1&#xf…
阅读更多...
1.前端--基本概念【2023.11.25】

1.前端--基本概念【2023.11.25】

1.网站与网页 网站是网页集合。 网页是网站中的一“页”&#xff0c;通常是 HTML 格式的文件&#xff0c;它要通过浏览器来阅读。 2.Web的构成 主要包括结构&#xff08;Structure&#xff09; 、表现&#xff08;Presentation&#xff09;和行为&#xff08;Behavior&#xff…
阅读更多...
如何学习VBA：3.2.8 OnTime方法与OnKey方法

如何学习VBA：3.2.8 OnTime方法与OnKey方法

我给VBA的定义&#xff1a;VBA是个人小型自动化处理的有效工具。利用好了&#xff0c;可以大大提高自己的劳动效率&#xff0c;而且可以提高数据处理的准确度。我推出的VBA系列教程共九套和一部VBA汉英手册&#xff0c;现在已经全部完成&#xff0c;希望大家利用、学习。 如果…
阅读更多...
[架构之路-250]：目标系统 - 设计方法 - 软件工程 - 需求工程 - 需求开发：如何用图形表达需求，面向对象需求分析OOA与UML视图

[架构之路-250]：目标系统 - 设计方法 - 软件工程 - 需求工程 - 需求开发：如何用图形表达需求，面向对象需求分析OOA与UML视图

目录 一、面向对象需求分析 1.1 面向对象的基本概念 1.2 什么是面向对象的需求分析 2.3 什么是UML图 2.4 UML视图 2.4 UML图与UML视图的关系 2.5 UML图与面向对象需求分析的关系 二、需求分析相关的UML图形与视图&#xff1a;14视图 2.1 用例模型与用例图&#xff1a;…
阅读更多...
2016年11月10日 Go生态洞察：七年的Go语言旅程

2016年11月10日 Go生态洞察：七年的Go语言旅程

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…
阅读更多...
解决No module named ‘ultralytics‘

解决No module named ‘ultralytics‘

win10Python3.7环境运行yolov5的程序时&#xff0c;程序语句from ultralytics.utils.plotting import Annotator, colors, save_one_box报错。 报错如下图&#xff1a; Exception has occurred: ModuleNotFoundError No module named ultralytics 解决方法&#xff1a; 在c…
阅读更多...
Guitar Pro软件8.0官方最新版本下载

Guitar Pro软件8.0官方最新版本下载

Guitar Pro 8是一款由法国Arobas Music公司开发的吉他学习与MIDI音序制作辅助软件&#xff0c;它具有丰富的功能&#xff0c;包括吉他谱、六线谱、四线谱绘制、打印、查看、试听等方面&#xff0c;能够帮助音乐爱好者更方便地进行音乐学习和创作。Guitar Pro 8拥有独特的gtp格式…
阅读更多...
JVM的小知识总结

JVM的小知识总结

加载时jvm做了这三件事&#xff1a; 1&#xff09;通过一个类的全限定名来获取该类的二进制字节流 什么是全限定类名&#xff1f; 就是类名全称&#xff0c;带包路径的用点隔开&#xff0c;例如: java.lang.String。 即全限定名 包名类型 非限定类名也叫短名&#xff0c;就…
阅读更多...
C语言你爱我么？（ZZULIOJ 1205:你爱我么？）

C语言你爱我么？（ZZULIOJ 1205:你爱我么？）

题目描述 LCY买个n束花准备送给她暗恋的女生&#xff0c;但是他不知道这个女生是否喜欢他。这时候一个算命先生告诉他让他查花瓣数&#xff0c;第一个花瓣表示"爱"&#xff0c;第二个花瓣表示"不爱"&#xff0c;第三个花瓣表示"爱"..... 为了使最…
阅读更多...
Unity UGUI的自动布局-LayoutGroup（水平布局）组件

Unity UGUI的自动布局-LayoutGroup（水平布局）组件

Horizontal Layout Group | Unity UI | 1.0.0 1. 什么是HorizontalLayoutGroup组件&#xff1f; HorizontalLayoutGroup是Unity UGUI中的一种布局组件&#xff0c;用于在水平方向上对子物体进行排列和布局。它可以根据一定的规则自动调整子物体的位置和大小&#xff0c;使它们…
阅读更多...
间接法加窗分析信号的功率谱

间接法加窗分析信号的功率谱

本篇文章是博主在通信等领域学习时&#xff0c;用于个人学习、研究或者欣赏使用&#xff0c;并基于博主对通信等领域的一些理解而记录的学习摘录和笔记&#xff0c;若有不当和侵权之处&#xff0c;指出后将会立即改正&#xff0c;还望谅解。文章分类在 通信领域笔记&#xff…
阅读更多...
【图解系列】一张图带你了解 DevOps 生态工具

【图解系列】一张图带你了解 DevOps 生态工具

一张图带你了解 DevOps 生态工具 ✅ 协作&#xff08;Collaborate&#xff09;&#xff1a;JIRA、Confluence 大家肯定不陌生了&#xff0c;我之前也写过利用 Jekyll 搭建个人博客的帖子。✅ 构建&#xff08;Build&#xff09;&#xff1a;常用的 SCM&#xff08;Software Con…
阅读更多...
每日一题--删除链表的倒数第 N 个结点

每日一题--删除链表的倒数第 N 个结点

破阵子-晏殊 燕子欲归时节&#xff0c;高楼昨夜西风。 求得人间成小会&#xff0c;试把金尊傍菊丛。歌长粉面红。 斜日更穿帘幕&#xff0c;微凉渐入梧桐。 多少襟情言不尽&#xff0c;写向蛮笺曲调中。此情千万重。 目录 题目描述&#xff1a; 思路分析&#xff1a; 方法及…
阅读更多...
01 _ 高并发系统：它的通用设计方法是什么？

01 _ 高并发系统：它的通用设计方法是什么？

我们知道&#xff0c;高并发代表着大流量&#xff0c;高并发系统设计的魅力就在于我们能够凭借自己的聪明才智设计巧妙的方案&#xff0c;从而抵抗巨大流量的冲击&#xff0c;带给用户更好的使用体验。这些方案好似能操纵流量&#xff0c;让流量更加平稳地被系统中的服务和组件…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023