RBTree(红黑树)的介绍和实现

news2024/10/26 23:28:21

   欢迎来到杀马特的主页：羑悻的小杀马特.-CSDN博客

目录

​编辑

一·红黑树介绍：

1.1红黑树概念：

1.2红黑树遵循的原则：

 1.3红黑树效率分析：

二.红黑树的实现：

2.1红黑树结构：

2.2红黑树节点的插入：

2.2.1 顺序性插入：

2.2.2.1变色(叔叔节点为红色)：

 2.2.2.2变色（叔叔节点为红色）(简单总结版)：

2.2.3.1 左单旋+变色（叔叔节点为黑色或者不存在）：

 2.2.3.2左单旋+变色（叔叔节点为黑色或者不存在）（简单总结版）：

2.2.4.1 右单旋+变色（叔叔节点为黑色或者不存在）：

2.2.4.2 右单旋+变色(叔叔节点为黑色或者不存在)（简单总结版）：

2.2.5.1 左右双旋+变色（叔叔节点为黑色或者不存在）：

2.2.5.2 左右双旋+变色（叔叔节点为黑色或者不存在）（简单总结版）：

2.2.6.1右左双旋+变色（叔叔节点为黑色或者不存在）：

 2.2.6.2右左双旋+变色（叔叔节点为黑色或者不存在）（简单总结版）：

 2.3红黑树的查找：​编辑

2.4红黑树的验证： 

2.5红黑树的删除：

三·代码总结： 

四·红黑树创建总结（仅个人理解）： 

一·红黑树介绍：

1.1红黑树概念：

首先可以把它理解成一颗二叉搜索树，但是它的节点会有颜色不是红就是黑，可以这么理解：就是avl树把平衡因子去掉并改成颜色再加以修改，但是平衡还是有点差别，高度可能会差别大于2，因此只能勉勉强强这麽说。这样可以保证如果存在最短路径必然都是黑节点，如果存在最长路径必然一般黑一般红，其他路径就位于它们之间了，它根据特性也可以默认成平衡的了，这里也要注意空节点默认为黑色（这里也可有头结点也可无，如果有的话就是头结点为黑色，然后它的parent指针指向根节点，左指针指向树最左边孩子，右指针指向树最右边的孩子）。

1.2红黑树遵循的原则：

简称红黑树四大原则：

①它的结点不是红⾊就是⿊⾊ 。

②根结点是⿊⾊的。

③如果⼀个结点是红⾊的，则它的两个孩⼦结点必须是⿊⾊的，也就是说任意⼀条路径不会有连续的 红⾊结点，故红红节点不能连续出现。

 ④对于任意⼀个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的⿊⾊结点。

 1.3红黑树效率分析：

这里如果我们假设树的最短高度是h，而最长高度就是2h（假设存在的话）：为什么？：这里若果是最短（由于黑色节点相同）故只需要它无红色几点即全黑设高度为h，那么最长的只能是红黑交错出现（红色不能相连）故就是2h了。 那么我们证明一下它的效率范围：

这里最短路路径就是18 10 而最长就是 18 30 40 50，我们以最坏情况考虑(因为在最短和最长之间的点是怎样分布不清楚故这样)那么最好就是2^h-1,最长是2^2h-1,也就是节点是这些，设节点为n解答时间复杂度=logn与2*logn之间，故都可以近似成o(logn)。

二.红黑树的实现：

2.1红黑树结构：

这里和avl树大致相同就是把平衡因子等换成了颜色的枚举类型了。

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

template<class K, class V>
class RBTree {
	using Node = RBTreeNode<K, V>;
public:
 private：
Node* _root=nullptr;

};

2.2红黑树节点的插入：

这里剧透一下：那么插入过程大概是怎么样的呢？首先我们先找到了大小关系合适的节点；然后如果我们插入的是黑色就破坏了黑色相等的规则，故插入的节点一定是红色，那么就可以推出它的父亲是红或者黑，如果是黑色那么可以直接成功插入了，但是如果是红色的话，爷爷节点一定是黑色，此时关键就要看叔叔节点了：这时候分为三种情况为黑，为红，不存在（为黑），故这里还可以归总成两种：1·叔叔节点为红色，2·叔叔节点为黑色。----->"调整的环节又叫"关键看叔叔"

下面说一下这个插入的思路：就是当我们插入后父亲是黑色就退出，如果是红色：那么就继续向上调整（这里可以直到如果父亲为红肯定存在爷爷即为黑，但是爷爷的父亲不一定存在，那么如果下一次向上调整爷爷变成了孩子，那么可能爷爷就是根节点，但是会被变红，故需要最后变黑）,此时就要看叔叔了。根据那两种情况进行旋转或者不旋转。 

代码思路：首先分为两大方向分别是父亲是爷爷的左孩子与右孩子，此时叔叔就相反了，然后再分叔叔为黑或者红（直接变色），为黑：则要分孩子插入的是父亲的左还是右进行对应的左 右单旋和左右 右左双旋 。

2.2.1 顺序性插入：

就是按照比原节点值小就向左走，大就向右走，然后走到空，判断插入的是左还是右进行插入即可。

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

cur->_parent = parent;

2.2.2.1变色(叔叔节点为红色)：

叔叔节点为红色的情况（这里首先要确定叔叔是爷爷的左还是右（父亲，叔叔的连接如何））：

假设插入的是c这个节点，故此时父亲是红色，故要变色（由于要保证每条路黑色节点个数不变，故我们可以先把父亲和叔叔节点变成黑色，爷爷变成红色就行了-->这样可以保证黑色节点相当于没变化。），接着就是向上调整（让爷爷节点变成孩子）看看父亲节点颜色，红色：就看叔叔颜色，进行相关变化黑色：退出。

代码实现：

if (uncle && uncle->_col == RED) {
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				// 继续往上处理:
				cur = grandfather;
				parent = cur->_parent;
}

 2.2.2.2变色（叔叔节点为红色）(简单总结版)：

判断父亲叔叔方位，叔叔为红，父亲叔叔变黑，爷爷变红继续向上走。

2.2.3.1 左单旋+变色（叔叔节点为黑色或者不存在）：

注：这里是由于要进行不同方向的那四种旋转我们才分孩子连接的是父亲的左还是右。

我们首先要想什么时候会左单旋然后变色呢？(首先保持好它的平衡性，故还要旋转变平衡，最后保证节点颜色规则。)  因此左单旋肯定是右边高了，而根据标题就可以知道此时叔叔节点是黑色，但是它是不是第一次插入就黑色了呢？肯定不可能，下面看一张图解释一下：

但是当叔叔不存在时候（虽然也是黑色）但是它只能是新插入的节点而不是向上调整才会出现：

这样我们就明白了把。因此接下来如果要进行左旋故父亲肯定是爷爷的右，孩子也是父亲的右（无论叔叔存在还是存在为黑都一样当黑色处理进行左旋。） 

故我们要先保持它的平衡（右边高了）（利用左旋（对g））：

①首先是叔叔为空（黑）：

这样才能保持平衡后，还符合颜色规则。 

②其次是叔叔为存在，黑（就是由最底下插入向上调整时候出现的）：

这样我们左单旋的所有情况就完了。

代码实现：

//又分两种情况：孩子插入的是左还是右：
if (cur == parent->_right) {
				RotateL(grandfather);
				parent->_col = BLACK;
				grandfather->_col = RED;
}

 2.2.3.2左单旋+变色（叔叔节点为黑色或者不存在）（简单总结版）：

父亲连接爷爷右，孩子连接父亲右，叔叔存在且黑色（不存在），进行左旋，爷爷变红，父亲变黑。

2.2.4.1 右单旋+变色（叔叔节点为黑色或者不存在）：

注：这里是由于要进行不同方向的那四种旋转我们才分孩子连接的是父亲的左还是右。

这里其实就和单旋一样（叔叔存在黑色或者不存在），但是此时就是父亲连接爷爷的左，孩子连接父亲左了。

下面就分情况画图简单看一下吧：

①首先是叔叔为空（黑）：

②其次是叔叔为存在，黑（就是由最底下插入向上调整时候出现的）：

代码实现：

//又分两种情况：孩子插入的是左还是右：
if (cur == parent->_left) {
				RotateR(grandfather);
				parent->_col = BLACK;
				grandfather->_col = RED;
}

2.2.4.2 右单旋+变色(叔叔节点为黑色或者不存在)（简单总结版）：

父亲连接爷爷左，孩子连接父亲左，叔叔存在且黑色（不存在），进行旋右，爷爷变红，父亲变黑。

2.2.5.1 左右双旋+变色（叔叔节点为黑色或者不存在）：

注：这里是由于要进行不同方向的那四种旋转我们才分孩子连接的是父亲的左还是右。

首先我们要知道为什么会出现左右双旋？个人理解：它是右旋样子下孩子插入在父亲右边才会形成的，故此时我们还要分叔叔节点为存在为黑色以及不存在情况进行画图分析。

先说一下它的情况吧：父亲连节爷爷的左边，孩子连接父亲的右边。

①首先是叔叔为空（黑）：

对于叔叔是空只能是一开始第一次插入就这样出现的（上面也分析了），下面展示一下它插入并完成旋转和变色的图：

此时我们可以看出进行双旋后把孩子变黑，爷爷变红了。 

②其次是叔叔为存在，黑（就是由最底下插入向上调整时候出现的）：

还是老样子叔叔为黑，则孩子节点一定是向上调整由黑变红来的，展示一下：

同理也是孩子变黑，爷爷变红，才能符合既平衡又符合黑色相同规则。 

代码实现：

RotateLR(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;

2.2.5.2 左右双旋+变色（叔叔节点为黑色或者不存在）（简单总结版）：

父亲连接爷爷的左，孩子连接父亲的右，叔叔为黑或者不存在，此时爷爷变红，孩子变黑。

2.2.6.1右左双旋+变色（叔叔节点为黑色或者不存在）：

其实此时的右左双旋和上面的左右双旋相似，只不过是父亲连接了爷爷的右，而孩子连接了父亲的左而已，下面就不过多重复了，画图看一下：

①首先是叔叔为空（黑）：

②其次是叔叔为存在，黑（就是由最底下插入向上调整时候出现的）：

代码实现：

else {
				RotateRL(grandfather);
				cur->_col = BLACK;
				grandfather->_col = RED;
}

 2.2.6.2右左双旋+变色（叔叔节点为黑色或者不存在）（简单总结版）：

父亲连接爷爷的右，孩子连接父亲的左，叔叔为黑或者不存在，此时爷爷变红，孩子变黑。

 2.3红黑树的查找：

这里遵循avl的查找只查找pair的first（根据）而不管颜色故直接用它的查找就行。

代码实现：

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

2.4红黑树的验证： 

这时候我们就要根据红黑树的四大原则了，但是这里我们只用到了三个：

①根节点为空就是不为空必须是黑色。

②每个节点（这里认为的是根节点起，到空的每条支路的黑色节点数相同）。

③红色节点的孩子一定是黑色节点，但是这里如果这么找，还要判断孩子存不存在然后看颜色，因此我们可以倒着来即找到一个节点是红色，则它的父亲不能是红色（即红色节点不相连）。

黑色节点相同的话，我们可以先往最左或者最右遍历至空，找到一条路径的黑色节点个数作为标准，然后利用递归到空记录blackcount与它比较发现不等就false，红色不相连：遍历途中，发现红色就看父亲颜色，如果为红色就false。

代码展示：

 bool is_rbtree() {
  int count = 0;
  if (_root == nullptr) return true;
  if (_root->_col == RED) return false;//根节点存在就为黑
  Node* cur = _root;
  while (cur) {
	  if (cur->_col == BLACK) count++;
	  cur = cur->_left;
  }
  return check(_root, count, 0);
  }


 bool check(Node* root, int reference, int blackcount) {//查找树中要满足黑色相同以及红的节点只能连两个黑的（转化成红的节点父亲不能是红的）：这里只有都满足才返回true，故可以判断错就返false

	if (root == nullptr) {//检查每条支路黑色节点数量相同
		if (blackcount != reference) {
			cout << "发现黑色节点不等的支路" << endl;
			return false;
		}
		else return true;
		
	}
	if (root->_col == RED && root->_parent->_col == RED) {
		cout << "发现连续的红色节点" << endl;//不能有连续的红色节点
		return false;
	}

	if (root->_col == BLACK) blackcount++;
	return check(root->_left, reference, blackcount) && check(root->_right, reference, blackcount);
}

2.5红黑树的删除：

这里和上次的avl树一样采取的是替换制删除，可以根据上篇avl树的删除来仿写，但是就是把平衡因子换成了红黑色的颜色而已。 

三·代码总结： 

#pragma once
#include<iostream>
using namespace std;
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)
	{}
};
template<class K, class V>
class RBTree {
	using Node = RBTreeNode<K, V>;
public:
	bool insert(const pair<K, V>& kv) {//先按照avl树插入节点，然后最后判断是否旋转来修改颜色
		//第一次插入要保证根节点为黑色：
		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);
		cur->_col = RED;
		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;//爷爷节点一定存在（当父亲节点为红）一定为黑：要么继续调整要么为根节点最后改黑
			//下面分两种大情况分别是父亲为爷爷的left和right：
			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);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
			 }
			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);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
			}
		}
		_root->_col = BLACK;//如果到头爷爷原来是黑的被改成了红且是根节点故改回黑
		return true;

	  }

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

	  bool is_rbtree() {
		  int count = 0;
		  if (_root == nullptr) return true;
		  if (_root->_col == RED) return false;//根节点存在就为黑
		  Node* cur = _root;
		  while (cur) {
			  if (cur->_col == BLACK) count++;
			  cur = cur->_left;
		  }
		  return check(_root, count, 0);
	   }

	  int treeheight() {
		  return _treeheight(_root);
	   }
	  int size() {
		  return _size(_root);
	  }
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:


	void RotateL(Node* parent) {//左旋
		Node* subr = parent->_right;
		Node* subrl = subr->_left;
		//处理sublr：
		parent->_right = subrl;
		if (subrl) subrl->_parent = parent;//sublr为空不能访问

		Node* pp = parent->_parent;//保存parent的父节点指针
		//调节新旧“parent”位置：
		subr->_left = parent;
		parent->_parent = subr;

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

	}


	void RotateR(Node* parent) {//右旋
		Node* subl = parent->_left;
		Node* sublr = subl->_right;

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

		Node* pp = parent->_parent;
		subl->_right = parent;
		parent->_parent = subl;
		if (pp == nullptr) {
			_root = subl;
			subl->_parent = nullptr;
		}
		else {
			if (parent == pp->_left) pp->_left = subl;
			else pp->_right = subl;
			subl->_parent = pp;
		}
		
	}

	void	RotateLR(Node* parent) {//左右双旋
		Node* subl = parent->_left;
		Node* sublr = subl->_right;
		RotateL(subl);
		RotateR(parent);

	}

	void RotateRL(Node* parent) {//右左双旋
		Node* subr = parent->_right;
		Node* subrl = subr->_left;
		RotateR(subr);
		RotateL(parent);

	}
	bool check(Node* root, int reference, int blackcount) {//查找树中要满足黑色相同以及红的节点只能连两个黑的（转化成红的节点父亲不能是红的）：这里只有都满足才返回true，故可以判断错就返false

		if (root == nullptr) {//检查每条支路黑色节点数量相同
			if (blackcount != reference) {
				cout << "发现黑色节点不等的支路" << endl;
				return false;
			}
			else return true;
			
		}
		if (root->_col == RED && root->_parent->_col == RED) {
			cout << "发现连续的红色节点" << endl;//不能有连续的红色节点
			return false;
		}

		if (root->_col == BLACK) blackcount++;
		return check(root->_left, reference, blackcount) && check(root->_right, reference, blackcount);
	}
	  

	int _treeheight(Node* root) {
		if (root == nullptr)  return 0;
		int leftheight = _treeheight(root->_left);
		int rightheight = _treeheight(root->_right);
		return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
	}
	int _size(Node* root) {
		if (root == nullptr) return 0;
		return _size(root->_left) + _size(root->_right) + 1;
	 }
	             

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

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

	Node* _root=nullptr;
	
 };

测试用例：

#define _CRT_SECURE_NO_WARNINGS
#include"rbtree.h"

int main() {
	RBTree<int, int> t;
	// 常规的测试用例
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	// 特殊的带有双旋场景的测试用例
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };

	for (auto e : a)
	{
		t.insert({ e, e });
	}

	t.InOrder();
	cout << t.is_rbtree() << endl;
	cout <<"树的节点大小："<< t.size() << endl;
	cout <<" 树的高度："<< t.treeheight() << endl;


}

四·红黑树创建总结（仅个人理解）： 

首先的话，我们来谈一谈插入吧：这里可以这么理解：插入就按照二插搜索树插入，然后就是接下来要保证平衡和颜色了，我们插入的红色如果发现父亲是黑色就结束，如果红色，我们三步走：

第一步：判断父亲为爷爷的左还是右。

第二步：看叔叔存在为黑（或者不存在）还是为红。

第三步：看孩子连接父亲的左还是右。

下面画图帮助理解一下：

这里我们可能会说为什么只有叔叔是红色，才会孩子变爷爷向上调整，叔叔是其他就不用？因为当叔叔是其他的时候就会旋转，此时最顶上就是黑色，而旋转带来的改变犹如上调，故可以类似于做到了上调操作。 

本篇结束：希望对每一位读者通过此篇文章对有关红黑树的认识能有所增加，哪怕一丢丢，也更能体现这篇文章存在的价值，感谢各位的用心阅读以及支持！

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

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

相关文章

TMGM：下周全球市场分析

TMGM：下周全球市场分析

本周&#xff0c;美国股市表现强劲&#xff0c;标普500指数和道琼斯工业平均指数均刷新了历史最高记录。这一涨势得到了美联储公开市场委员会&#xff08;FOMC&#xff09;会议纪要的支撑&#xff0c;纪要显示大部分官员都支持9月份实施重大的50个基点降息。 在澳大利亚&#…
阅读更多...
宝安网站建设中的响应式设计

宝安网站建设中的响应式设计

宝安网站建设中的响应式设计 在数字化时代&#xff0c;网站已成为企业展示形象、吸引客户的重要平台。而在宝安地区&#xff0c;随着互联网的发展&#xff0c;越来越多的企业意识到响应式设计的重要性。响应式设计不仅能够提升用户体验&#xff0c;还能为企业带来更大的市场竞争…
阅读更多...
.NET 一款通过DCOM实现系统提权的工具

.NET 一款通过DCOM实现系统提权的工具

01阅读须知 此文所提供的信息只为网络安全人员对自己所负责的网站、服务器等&#xff08;包括但不限于&#xff09;进行检测或维护参考&#xff0c;未经授权请勿利用文章中的技术资料对任何计算机系统进行入侵操作。利用此文所提供的信息而造成的直接或间接后果和损失&#xf…
阅读更多...
2024年恩施职称评前公示

2024年恩施职称评前公示

此次公示共有422人&#xff0c;初级职称、中级职称、馆员、畜牧师、助理馆员、三级演员、农艺师等均在一起进行评审前的公示。 根据恩施州职称改革工作领导小组办公室《关于报送2024年度恩施州中初级专业技术职务评审材料的通知》&#xff08;恩施州职改办〔2024〕14号&#xf…
阅读更多...
04 什么是线性表

04 什么是线性表

什么是线性表 一、为什么需要线性表 例如&#xff1a; ​ 在程序中保存指定班级的所有的学生信息&#xff08;暂时只需要处理姓名、年龄&#xff09;&#xff0c;该班级最多可容纳30人&#xff0c;且可进行数量上的增减。 业务功能&#xff1a; ​ 1&#xff09;这个项目中…
阅读更多...
【分布式架构】分布式锁Redission

【分布式架构】分布式锁Redission

一、流程图 二、lua脚本实现原理 由setnxexpire实现 setnx&#xff1a;判断key是否存在&#xff0c;如果不存在&#xff0c;则获取锁 setnx的数据结构&#xff1a;<key,<key1,value>> key&#xff1a;业务声明的key key1&#xff1a;线程id value&#xff1a;次数…
阅读更多...
css 翻页效果

css 翻页效果

有一个项目&#xff0c;页面切换的时候要翻页效果。 所以有一个简单的demo&#xff0c;提供给大家学习 <!DOCTYPE html> <html lang"en"> <head> <meta charset"UTF-8"> <meta name"viewport" content"widthdev…
阅读更多...
Golang | Leetcode Golang题解之第476题数字的补数

Golang | Leetcode Golang题解之第476题数字的补数

题目&#xff1a; 题解&#xff1a; func findComplement(num int) int {highBit : 0for i : 1; i < 30; i {if num < 1<<i {break}highBit i}mask : 1<<(highBit1) - 1return num ^ mask }
阅读更多...
空间计算：现实与数字世界的无缝融合

空间计算：现实与数字世界的无缝融合

随着增强现实&#xff08;AR&#xff09;、虚拟现实&#xff08;VR&#xff09;、物联网&#xff08;IoT&#xff09;和人工智能&#xff08;AI&#xff09;的不断进步&#xff0c;空间计算&#xff08;Spatial Computing&#xff09;作为一种新兴技术&#xff0c;正在成为人们…
阅读更多...
IDEA Sping Boot 多配置文件application Maven动态切换

IDEA Sping Boot 多配置文件application Maven动态切换

新建application-dev.yml与application-prod.yml pom.xml文件下添加profiles等 让idea识别出配置文件 <profiles><profile><id>dev</id><properties><!-- 环境标识&#xff0c;需要与配置文件的名称相对应 --><profiles.active>dev&…
阅读更多...
安装和配置k8s可视化UI界面dashboard-1.20.6

安装和配置k8s可视化UI界面dashboard-1.20.6

安装和配置k8s可视化UI界面dashboard-1.20.6 1.环境规划2.初始化服务器1&#xff09;配置主机名2&#xff09;设置IP为静态IP3&#xff09;关闭selinux4&#xff09;配置主机hosts文件5&#xff09;配置服务器之间免密登录6&#xff09;关闭交换分区swap&#xff0c;提升性能7&…
阅读更多...
2013年国赛高教杯数学建模A题车道被占用对城市道路通行能力的影响解题全过程文档及程序

2013年国赛高教杯数学建模A题车道被占用对城市道路通行能力的影响解题全过程文档及程序

2013年国赛高教杯数学建模 A题 车道被占用对城市道路通行能力的影响 车道被占用是指因交通事故、路边停车、占道施工等因素&#xff0c;导致车道或道路横断面通行能力在单位时间内降低的现象。由于城市道路具有交通流密度大、连续性强等特点&#xff0c;一条车道被占用&#x…
阅读更多...
ubuntu22.04 ROS2 - 安装

ubuntu22.04 ROS2 - 安装

参考链接：Ubuntu 22.04 LTS安装ROS2 (ros-humble-desktop)-CSDN博客 1、安装测试 ros2 run demo_nodes_cpp listener再开一个终端ros2 run demo_nodes_cpp listener2、小海龟模拟器 ros2 run turtlesim turtlesim_noderos2 run turtlesim turtle_teleop_key两个终端分别执行…
阅读更多...
树莓派应用--AI项目实战篇来啦-5.OpenCV绘画函数的使用

树莓派应用--AI项目实战篇来啦-5.OpenCV绘画函数的使用

1. 介绍 OpenCV作为一款功能强大的计算机视觉库&#xff0c;被广泛地应用于图像处理和计算机视觉领域。 除了在机器视觉和人工智能领域有者广泛的应用&#xff0c;OpenCV 还能够媲美艺术家的创造力&#xff0c;通过其强大的绘图函数&#xff0c;绘制出令人叹为观止的艺术画作。…
阅读更多...
【ICESat-2（Ice, Cloud and land Elevation Satellite-2）简介】

【ICESat-2（Ice, Cloud and land Elevation Satellite-2）简介】

ICESat-2&#xff08;Ice, Cloud and land Elevation Satellite-2&#xff09;&#xff0c;即冰、云和陆地高程卫星2号&#xff0c;是美国国家航空航天局&#xff08;NASA&#xff09;的一项重要卫星任务&#xff0c;旨在测量地球冰盖、云层以及陆地的高度变化。以下是对ICESat…
阅读更多...
phpstorm+phpstudy 配置xdebug(无需开启浏览器扩展)

phpstorm+phpstudy 配置xdebug(无需开启浏览器扩展)

今天又被xdebug折磨了&#xff0c;忘记了以前咋配置了现在百度发现好多都是各种浏览器扩展而且也没有真正的用到项目上的都是测试的地址怎么样的 我就简单写一下自己实战吧 不支持workerman swoole hyperf等这种服务框架 如果你会请教教我 工具版本phpstudy8.1.xphpstorm2021.x…
阅读更多...
用SpringBoot给Servlet容器Tomcat打war包步骤

用SpringBoot给Servlet容器Tomcat打war包步骤

首先写一个类来代替启动类 先在SpringBoot项目里打开pom.xml导入依赖,原本SpringBoot里面spring-boot-starter-web依赖里面有Tomcat,所以我们要先在spring-boot-starter-web里面导入依赖,把Tomcat给排除掉,并且加上你要打的war类型依赖 然后先刷新,再清除,最后再打包 成功之后,…
阅读更多...
华为云Flexus云服务：性能倍增、体验跃级

华为云Flexus云服务：性能倍增、体验跃级

在数字化转型的浪潮中&#xff0c;企业对云计算的需求日益增长&#xff0c;尤其是在性能和体验方面。华为云Flexus云服务应运而生&#xff0c;为企业提供了一个性能倍增、体验跃级的云计算解决方案。下面九河云就来给大家介绍一下华为云Flexus云服务吧。 1. 性能倍增 华为云…
阅读更多...
【AI绘画】Midjourney进阶：三分线构图详解

【AI绘画】Midjourney进阶：三分线构图详解

博客主页&#xff1a; [小ᶻZ࿆] 本文专栏: AI绘画 | Midjourney 文章目录 &#x1f4af;前言&#x1f4af;什么是构图为什么Midjourney要使用构图 &#x1f4af;三分线构图特点使用场景提示词书写技巧测试 &#x1f4af;小结 &#x1f4af;前言 【AI绘画】Midjourney进阶&a…
阅读更多...
cmake 报错及解决

cmake 报错及解决

1.背景&#xff1a;自己编写CMakeLists.txt并构建项目 2.问题&#xff1a;build目录下执行“cmake ..”命的时候如下报错&#xff1a; CMake Error at CMakeLists.txt:27 (ADD_EXECUTABLE): The target name "client," is reserved or not valid for certain CMak…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023