红黑树C++实现

news2025/8/13 14:36:41

目录

一、红黑树的概念

二、红黑树的性质

三、红黑树节点的定义

四、红黑树的插入

4.1 插入节点

4.2 插入节点的颜色

4.3 调整情况1

4.4 调整情况2

4.5 调整情况3

4.6 调整情况总结

五、调整的实现

5.1 调整的步骤分析

5.2 代码实现

六、树的平衡判断

七、源代码+测试代码

一、红黑树的概念

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

二、红黑树的性质

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

解读：

性质三：保证树中没有连续的红色节点

性质四：每条路径上黑色节点的数目相同

满足以上性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍

其中，其极限最短：全黑。极限最长：一黑一红……

三、红黑树节点的定义

 因为性质一，节点的颜色不是红就是黑，所以我们可以使用枚举来清晰的区分。

四、红黑树的插入

4.1 插入节点

红黑树本质也是二叉搜索树，所以插入的方式是相同的。只是调整平衡的方式不同。插入的代码如下：

bool Insert(const pair<K, V>& kv)
	{
		if (!_root)
		{
			_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);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right= cur;
		}
		cur->_parent = parent;
	}

4.2 插入节点的颜色

接下来我们就要分析，插入的节点默认应该是红色还是黑色。

首先分析插入黑节点。如下：

 插入黑节点后，直接就破坏了红黑树的规则四，因为每条路径上的黑色节点数不再相同了，所以说插入黑节点是一定会出错的。

接下来我们看看插入红节点。

 此中情况下，破坏了规则三，其红节点下必须是黑节点。

在这种情况下，插入红节点，既没有破坏规则三，也没有破坏规则四。所以说，插入红节点有几率会破坏规则，而插入黑节点一定会破坏规则，且破坏了整棵树，所以我们默认插入红节点。

那如果出现以上插入红节点破坏规则我们要怎么处理呢？

我们采取 变色+旋转 的策略，以上这种情况我们只需要变色即可解决。如图所示：

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；

但当新插入节点的双亲结点颜色为红色时，就违反了性质三不能有连续在一起的红色节点，此时就需要对红色数分情况来解决。

即双亲黑色不调整，双亲红色则调整。

4.3 调整情况1

情况一：cur 为红，parent为红，grandfather为黑，uncle存在且为红.

解决方式：将p，u 改为黑，g改为红，然后把 g 当作 cur，继续向上调整。

4.4 调整情况2

情况二：cur 为红，p 为红，g 为黑，u 不存在/ u 存在且为黑。

  1. 如果 u 节点不存在，则 cur 一定是新插入节点，因为如果 cur 不是新插入节点，则 cur 和 p 一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点的个数相同。
  2. 如果 u 节点存在，则其一定是黑色的，那么 cur 节点原来的颜色一定是黑色的，现在看到其是红色的原因是因为 cur 的子树在调整的过程中将 cur 节点的颜色由黑色改成红色。

 此时这种情况，单纯的变色是无法解决的，我们就要采取旋转+变色的方式。

此时我们的解决策略是将 p 变黑，g 变红，然后让其对 g 进行右单旋。

4.5 调整情况3

情况三：cur 为红，p 为红，g 为黑，u 不存在 / u 存在且为黑

 调整策略：

p 为 g 的左孩子，cur 为 p 的右孩子，则针对 p 进行左单旋，则转变为情况 2，然后再进行情况 2 的右单旋+变色即可。

4.6 调整情况总结

在学习了AVL 树 之后，这三种情况其实也都能理解，接下来我们对其做一个总结。

红黑树的关键在于叔叔。因为知道叔叔节点的情况，可以了解到另一棵子树的高度情况。

三种情况：

  1. u 存在且为红，变色并继续向上处理
  2. u 不存在或为黑，进行 单旋+变色
  3. u 不存在或为黑，插入方式为折线，进行 双旋+变色。

五、调整的实现

5.1 调整的步骤分析

  1. 只有当cur 为红，p 为红，g 为黑，则进行调整。(p为黑不用调整，p 为红，则grandfather必然为黑，要不然此时不为红黑树)
  2. 查看 uncle 的位置，同时也是判断插入节点在 g 的左子树还是右子树。
  3. 情况1，uncle存在且为红，进行情况一的调整(变色+继续往上更新)。
  4. 如果uncle不存在或为黑，则为情况二或三
  5. 如果插入在边侧，则进行单旋+变色
  6. 如果插入在内侧，则进行双旋+变色。

5.2 代码实现

以下只有调整的代码，没有截取插入的代码。

//1.因为插入的节点为红色， 如果parent也为红色，进行处理
while (parent && parent->_col == RED)
{
	Node* grandfater = parent->_parent;
	//2.判断爷节点的合法性
	assert(grandfater);
	assert(grandfater->_col == BLACK);
	//3.查看叔叔
	//4.首先判断叔叔位于grandfater的left 还是 right
	if (grandfater->_left == parent)
	{
		Node* uncle = grandfater->_right;
		//5.情况1，叔叔存在 && 叔叔为红色
		if (uncle && uncle->_col == RED)
		{
			//6.将父、树变黑，祖父变红
			parent->_col = uncle->_col = BLACK;
			grandfater->_col = RED;
			//7.并继续往上处理
			cur = grandfater;
			parent = cur->parent;
		}
		//8.情况2+情况3  uncle不存在或为黑
		else
		{
			//9.判断单旋还是双旋
			//      g          
			//    p   u
			//  c            右单旋+变色
			if (cur == parent->_left)
			{
				RotateR(grandfater);
				parent->_col = BLACK;
				grandfater->_col = RED;
			}
			//    g          左右双旋+变色
			//   p  u        
			//    c
			else
			{
				RotateL(parent);
				RotateR(grandfater);
				cur->_col = BLACK;
				grandfater->_col = RED;
			}
			break;
		}
	}
	else
	{
		Node* uncle = grandfater->_left;
		if (uncle && uncle->_col == RED)
		{
			parent->_col = uncle->_col = BLACK;
			grandfater->_col = RED;
			//继续往上处理
			cur = grandfater;
			parent = cur->parent;
		}
		else
		{
			//9.判断单旋还是双旋
			//      g          
			//    u   p
			//          c    左单旋+变色
			if (cur == parent->_right)
			{
				RotateL(grandfater);
				parent->_col = BLACK;
				grandfater->_col = RED;
			}
			//    g          右左双旋+变色
			//   u  p        
			//     c
			else
			{
				RotateR(parent);
				RotateL(grandfater);
				cur->_col = BLACK;
				grandfater->_col = RED;
			}
			break;
		}
	}
}

//因为以上会将祖父变红，直接将_root变黑
_root->_color = BLACK;
return true;

好的，实现了插入之后，我们来使用一段测试代码测试一下 Insert

六、树的平衡判断

实现 Insert 之后，只能证明当前的结构是一棵搜索树，而不能证明其是否为红黑树，接下来我们还要编写一个Balanceu验证平衡。

所以这个判定平衡的函数应该按照红黑树的规则，来进行判定该树是否符合红黑树的性质。即，算每条路径上的黑节点数量，如果路径上的黑节点数量相同，则说明是红黑树。

实现步骤：

  1. 计算最左/右边路径上的黑节点个数，将该值设为基准值。
  2. 走前序遍历，遇到黑节点则将将计数器++
  3. 如果当前节点的为红，并且父节点也为红则直接返回false。
  4. 如果该路径上的黑节点总数等于基准值，则返回true，反之返回false。

代码如下：


bool IsBalance()
{
	if (_root == nullptr)
	{
		return true;
	}
	if (_root->_col == RED)
	{
		cout << "根节点不是黑色" << endl;
		return false;
	}

	//设置基准值,以来校验路径上的黑节点
	int benchmark = 0;
	Node* cur = _root;
    //计算左侧路径上的黑色节点数量
	while (cur)
	{
		if (cur->_col == BLACK)
		{
			++benchmark;
		}
		cur = cur->_left;
	}
	return PrevCheck(_root, 0, benchmark);
}
bool PrevCheck(Node* root, int blackNum, int Benchmark)
{
	if (root == nullptr)
	{
		if (blackNum != Benchmark)
			return false;
		else
			return true;
	}
	if (root->_col == BLACK)
		++blackNum;
	if (root->_col == RED && root->_parent->_col == RED)
	{
		cout << "存在连续的红色节点" << endl;
		return false;
	}

	return PrevCheck(root->_left, blackNum, Benchmark)
		&& PrevCheck(root->_right, blackNum, Benchmark);
}

以上检查方式就按照红黑树的三条重要性质进行了检查，

1.根节点为黑色；2.不存在连续的红节点；3.每条路径上的黑节点个数相同。

满足以上三点才能证明该结构为红黑树。

接下来我们进入测试。

 测试一：

测试二：

注意一件事情，我们使用的是键值对的形式进行插入的，如果 k 存在了，则不会进行插入，并且红黑树中的排序是按照 k 的大小进行排序的，所以使用 find 函数时，要按 pair.first 查找，因为 pair.second并按搜索树的规则存储的。 

七、源代码+测试代码

红黑树代码(实现了插入、查找、中序遍历、高度、平衡检测)

#include <iostream>
using namespace std;

enum Color { 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;			    
	Color _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)
		{
			_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);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		while (parent && parent->_col == RED)
		{
			Node* grandfater = parent->_parent;
			assert(grandfater);
			assert(grandfater->_col == BLACK);
			if (grandfater->_left == parent)
			{
				Node* uncle = grandfater->_right;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					cur = grandfater;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						RotateR(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}					else
					{
						RotateL(parent);
						RotateR(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* uncle = grandfater->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					cur = grandfater;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateL(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;

	}
	void Inorder()
	{
		_Inorder(_root);
	}
	int Height()
	{
		return _Height(_root);
	}
	pair<K, V> Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur->_kv;
			}
		}
		return pair<int, int>(0, 0);
	}
	bool IsBalance()
	{
		if (_root == nullptr)
		{
			return true;
		}
		if (_root->_col == RED)
		{
			cout << "根节点不是黑色" << endl;
			return false;
		}

		//设置基准值,以来校验路径上的黑节点
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++benchmark;
			}
			cur = cur->_left;
		}
		return PrevCheck(_root,0, benchmark);
	}
	
private:

	bool PrevCheck(Node* root, int blackNum,int Benchmark)
	{
		if (root==nullptr)
		{
			//cout << blackNum << endl;
			if (blackNum == 2)                 //     3 
			{                                  //   7   16
				int n = 0;                     //      11
			}                                  //
			if (blackNum != Benchmark)
				return false;
			else 
			return true;
		}
		if (root->_col == BLACK)
			++blackNum;
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "存在连续的红色节点" << endl;
			return false;
		}

		return PrevCheck(root->_left, blackNum, Benchmark)
		&& PrevCheck(root->_right, blackNum, Benchmark);
	}

	void _Inorder(Node* root)
	{
		if (root)
		{
			_Inorder(root->_left);
			cout << root->_kv.first << ":" << root->_kv.second << endl;
			_Inorder(root->_right);
		}
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		return max(_Height(root->_left), _Height(root->_right)) + 1;
	}

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

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

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

		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (ppNode)
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		else
		{
			_root = subL;
			subL->_parent = nullptr;
		}
	}
    //成员变量 _root 
	Node* _root=nullptr; 
};

测试代码

void TestRBTree1()
{
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	RBTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert(e);
	}
	t1.Inorder();

	//检测是否为红黑树
	if (t1.IsBalance())
		cout << "Is RedBlackTree" << endl;
	else
		cout << "Not RedBlackTree" << endl;

	//查找 18 
	cout << "Find（18）：";
	int result = t1.Find(18);
	cout << result<< endl;

}

void TestRBTree2()
{
	size_t N = 10000000;
	RBTree<int, int> t1;
	for (size_t i = 0; i < N; ++i)
	{
		t1.Insert(i);
	}
	cout <<"Height:" << t1.Height() << endl;

	//检测是否为红黑树
	if (t1.IsBalance())
		cout << "Is RedBlackTree" << endl;
	else
		cout << "Not RedBlackTree" << endl;

	int  result = t1.Find(23451);
	cout << result<< endl;

}

int main()
{
	TestRBTree1();
	TestRBTree2();
	return 0;
}

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

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

相关文章

微信小程序制作要多少钱？【制作小程序】

微信小程序制作要多少钱？【制作小程序】

关于微信小程序制作要多少钱的问题&#xff0c;是很多企业商家在制作小程序之前需要了解的事项&#xff0c;因为总是听说制作小程序的费用有高有低&#xff0c;而他们又对这方面不太了解&#xff0c;所以也还是需要了解微信小程序制作要多少钱的。那么微信小程序制作要多少钱呢…
阅读更多...
RocketMQ中生产者发消息前为啥一定要调用start()方法？

RocketMQ中生产者发消息前为啥一定要调用start()方法？

前言 我们在使用RocketMQ发送消息时&#xff0c;一般都会使用DefaultMQProducer&#xff0c;类型的代码如下&#xff1a; DefaultMQProducer producer new DefaultMQProducer("producer_group"); producer.setNamesrvAddr("42.192.50.8:9876"); try {pr…
阅读更多...
Chrome 103支持使用本地字体，纯前端导出PDF优化

Chrome 103支持使用本地字体，纯前端导出PDF优化

在前端导出PDF&#xff0c;解决中文乱码一直是一个头疼的问题。要解决这个问题&#xff0c;需要将ttf等字体文件内容注册到页面PDF生成器中。但是之前网页是没有权限直接获取客户机器字体文件&#xff0c;这时就需要从服务器下载字体文件或者提示用户选择字体文件上传到页面。对…
阅读更多...
链接杂谈 CASPP

链接杂谈 CASPP

构建大型程序 构建大型程序&#xff0c;不可避免的一个问题是链接问题&#xff1a; - 链接器提示&#xff1a;缺少某个模块 缺少某个库 不兼容的库版本 理解全局变量的链接 你的代码可能有多个全局变量&#xff0c;有些是强变量&#xff0c;有些是弱定义&#xff0c;执行…
阅读更多...
清除浮动的常用方法

清除浮动的常用方法

关于浮动 我们为什么需要浮动&#xff1f; 我们想把多个块级元素放到同一行上。 打破标准流的限制。 浮动原来做图文混排效果&#xff0c;现在主要用来做网页布局的。 浮动语法 只有左浮动和右浮动。 float: left; float: right;浮动特点 1.浮动元素会脱离标准流&#x…
阅读更多...
Win10禁止应用独占麦克风

Win10禁止应用独占麦克风

痛点需求&#xff1a; qq和微信同时发起语音通话&#xff0c;发现只有一个qq说话对方能听到&#xff0c;但是微信却不能&#xff0c;这是典型的应用程序独占了麦克风&#xff0c;导致其他应用无法使用。 有没有办法让qq和微信同时使用麦克风呢&#xff1f; 答案是&#xff1a;有…
阅读更多...
图的拓扑序列

图的拓扑序列

拓扑序列&#xff1a; 拓扑序是按照点的先后顺序排列的。拓扑序列满足以下两点&#xff1a; 1.每个顶点在序列中出现且只出现一次。 2.若存在一条从顶点 A 到顶点 B 的路径&#xff0c;那么在序列中顶点 A 出现在顶点 B 的前面。 拓扑序列只存在于有向无环图中。可以理解成…
阅读更多...
MCE | 肝炎病毒是如何诱发肝癌的

MCE | 肝炎病毒是如何诱发肝癌的

肝炎病毒分类 肝炎病毒是世界上最常见的肝炎病因&#xff0c;其它原因包括酗酒、某些药物、毒素、其他感染、自身免疫性疾病和非酒精性脂肪性肝炎 (NASH)。肝炎病毒共有五种主要的肝炎病毒株&#xff0c;分别为 A、B、C、D 和 E 型。目前&#xff0c;全世界大约有 3.25 亿人患…
阅读更多...
2023中国绿色铝业国际峰会

2023中国绿色铝业国际峰会

会议背景 铝行业属于能源高度密集型行业&#xff0c;主要包括铝矿石开采、氧化铝生产、电解铝生产和铝材加工等环节。我国原铝产量自2001年以来一直占据世界首位&#xff0c;连续7年产量占比超过全球50%。然而与国际先进铝生产企业相比&#xff0c;我国铝生产企业单位原铝碳…
阅读更多...
C# 自定义事件

C# 自定义事件

一 自定义事件 例如&#xff0c;利用自定义绘制的技术&#xff0c;画出一个圆角按钮。 现在来看&#xff0c;怎么样给它添加自定义的事件。 二 要点与细节 1 Control 类本身就有继承的鼠标和键盘事件&#xff0c;这里只是一个引子&#xff0c;用于引出更复杂的自定义事件。 …
阅读更多...
web测试——业务测试2

web测试——业务测试2

1.历史数据 前端&#xff1a; 组件相关  组件内部是否动过&#xff1b;  展示的数据是否受影响&#xff1b;  失焦后的校验(爆红) 页面样式相关  坐标位置、  按钮位置是否动过&#xff0c;  新版本上线对历史配置的影响 交互提示相关  新手引导的展示位置、关闭后的展…
阅读更多...
pycharm2022.2 远程连接服务器调试代码

pycharm2022.2 远程连接服务器调试代码

目的&#xff1a; 同步本地和服务器的全部或者部分文件本地debug&#xff0c;服务器跑实验 需要条件&#xff1a; 服务器上已经创建好虚拟环境你本地已经安装好pycharm 1.1 File → Settings → Project:XXX →Python Interpreter 打开之后再右边这添加解释器。选On SSH 1.2把…
阅读更多...
简单的网页制作期末作业——电影泰坦尼克号(4页)

简单的网页制作期末作业——电影泰坦尼克号(4页)

HTML实例网页代码, 本实例适合于初学HTML的同学。该实例里面有设置了css的样式设置&#xff0c;有div的样式格局&#xff0c;这个实例比较全面&#xff0c;有助于同学的学习,本文将介绍如何通过从头开始设计个人网站并将其转换为代码的过程来实践设计。 文章目录一、网页介绍一…
阅读更多...
小学生python游戏编程arcade----excel调用

小学生python游戏编程arcade----excel调用

小学生python游戏编程arcade----excel调用前言小学生python游戏编程arcade----excel调用1、excel文件1.1 excel表头1.2 excel文件1.3 文件读取函数1.4 打开excel文件读取数据,每行一个字典&#xff0c;再总存为序列1.5 打开excel文件读取数据&#xff0c;取两列存为字典1.6 游戏…
阅读更多...
[漏洞复现] jenkins 远程代码执行 （CVE-2019-100300）

[漏洞复现] jenkins 远程代码执行 （CVE-2019-100300）

文章目录一、简介二、影响版本三、复现四、修复一、简介 拥有Overall/Read 权限的用户可以绕过沙盒保护&#xff0c;在jenkins可以执行任意代码。此漏洞需要一个账号密码和一个存在的job。 Jenkins的pipeline主要是通过一个配置文件或者job里面的pipeline脚本配置来设定每个j…
阅读更多...
锐捷MPLS跨域方案C2实验配置

锐捷MPLS跨域方案C2实验配置

目录 配置ASBR之间的EBGP邻居 配置PE之间的Vpnv4邻居 此时配置PE与CE设备对接命令 手工配置为PE地址分配标签 MPLS隧道——跨域解决方案C1、C2讲解_静下心来敲木鱼的博客-CSDN博客https://blog.csdn.net/m0_49864110/article/details/127634890?ops_request_misc%257B%252…
阅读更多...
数字孪生|交通运输可视化系统

数字孪生|交通运输可视化系统

交通是城市经济发展的动脉&#xff0c;与我们的日常生活息息相关。 传统交通信息管理中&#xff0c;只是做了粗略的信息发布以及简单的交通流量监测&#xff0c;早已经不能满足现代智慧交通的需求。现代的智慧交通则提供基于实时交通数据的交通信息服务&#xff0c;融入了物联网…
阅读更多...
python离线安装module以及常见问题及解决方案

python离线安装module以及常见问题及解决方案

文章目录一&#xff0c;离线安装module1.1 下载module1.2 离线安装二&#xff0c;常见的问题2.1 模块缺少合适的适配&#xff1a;error: Could not find suitable distribution for Requirement.parse()2.2 install成功但发现控制台打印的最后一行显示下载module版本为0.0.0工作…
阅读更多...
如何区分小角X射线散射和小角X射线衍射？

如何区分小角X射线散射和小角X射线衍射？

小角X射线散射&#xff08;SAXS&#xff09;大多数被用来测定超细粉体、纳米离子分布的有关性质&#xff0c;小角X射线衍射&#xff08;SAXD&#xff09;则主要用来测定超大晶面间距或者薄膜结构等等问题&#xff0c;在用途上两种实验并不一致&#xff0c;本篇文章将介绍小角X射…
阅读更多...
Promise错误处理比较：使用then的第二个参数还是catch

Promise错误处理比较：使用then的第二个参数还是catch

catch是一个语法糖而己 还是通过then来处理的 如果在then的第一个函数里抛出了异常&#xff0c;后面的catch能捕获到&#xff0c;而then的第二个函数捕获不到。 catch是一个语法糖而己 还是通过then 来处理的&#xff1a; Promise.prototype.catch function(fn){return this…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023