• 【数据结构】红黑树（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.节点的定义 

    1. enum Colour
    2. {
    3. 	RED,
    4. 	BLACK
    5. };
    6.  
    7. template<class K, class V>
    8. struct RBTreeNode
    9. {
    10. 	RBTreeNode* _left;
    11. 	RBTreeNode* _right;
    12. 	RBTreeNode* _parent;
    13. 	pair _kv;
    14. 	Colour _col;
    15.  
    16. 	RBTreeNode(const pair& kv)
    17. 		: _left(nullptr)
    18. 		, _right(nullptr)
    19. 		, _parent(nullptr)
    20. 		, _kv(kv)
    21. 		, _col(RED)
    22. 	{}
    23. };

    思考：节点的默认颜色为什么是红色？ 

    因为如果插入黑色节点就一定会破坏规则（每条路径上的黑色节点数相同），并且会影响其他路径。

    所以我们需要设置节点的默认颜色为红色。

    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代码实现

    1. bool Insert(const pair& kv)
    2. {
    3. 	if (_root == nullptr)
    4. 	{
    5. 		_root = new Node(kv);
    6. 		_root->_col = BLACK;
    7. 		return true;
    8. 	}
    9.  
    10. 	Node* parent = nullptr;
    11. 	Node* cur = _root;
    12. 	while (cur)
    13. 	{
    14. 		if (cur->_kv.first < kv.first)
    15. 		{
    16. 			parent = cur;
    17. 			cur = cur->_right;
    18. 		}
    19. 		else if (cur->_kv.first > kv.first)
    20. 		{
    21. 			parent = cur;
    22. 			cur = cur->_left;
    23. 		}
    24. 		else
    25. 		{
    26. 			return false;
    27. 		}
    28. 	}
    29.  
    30. 	cur = new Node(kv); // 红色的
    31. 	if (parent->_kv.first < kv.first)
    32. 	{
    33. 		parent->_right = cur;
    34. 	}
    35. 	else
    36. 	{
    37. 		parent->_left = cur;
    38. 	}
    39. 	cur->_parent = parent;
    40.  
    41. 	while (parent && parent->_col == RED)
    42. 	{
    43. 		Node* grandfather = parent->_parent;
    44. 		if (parent == grandfather->_left)
    45. 		{
    46. 			Node* uncle = grandfather->_right;
    47. 			// 情况一：叔叔存在且为红
    48. 			if (uncle && uncle->_col == RED)
    49. 			{
    50. 				// 变色
    51. 				parent->_col = uncle->_col = BLACK;
    52. 				grandfather->_col = RED;
    53.  
    54. 				// 继续往上处理
    55. 				cur = grandfather;
    56. 				parent = cur->_parent;
    57. 			}
    58. 			else
    59. 			{
    60. 				// 情况二：叔叔不存在或者存在且为黑
    61. 				// 旋转+变色
    62. 				if (cur == parent->_left)
    63. 				{
    64. 					//       g
    65. 					//    p    u
    66. 					// c
    67. 					RotateR(grandfather);
    68. 					parent->_col = BLACK;
    69. 					grandfather->_col = RED;
    70. 				}
    71. 				else
    72. 				{
    73. 					//       g
    74. 					//    p     u
    75. 					//      c
    76. 					RotateL(parent);
    77. 					RotateR(grandfather);
    78. 					cur->_col = BLACK;
    79. 					grandfather->_col = RED;
    80. 				}
    81. 				break;
    82. 			}
    83. 		}
    84. 		else
    85. 		{
    86. 			Node* uncle = grandfather->_left;
    87. 			// 情况一：叔叔存在且为红
    88. 			if (uncle && uncle->_col == RED)
    89. 			{
    90. 				// 变色
    91. 				parent->_col = uncle->_col = BLACK;
    92. 				grandfather->_col = RED;
    93.  
    94. 				// 继续往上处理
    95. 				cur = grandfather;
    96. 				parent = cur->_parent;
    97. 			}
    98. 			else
    99. 			{
    100. 				// 情况二：叔叔不存在或者存在且为黑
    101. 				// 旋转+变色
    102. 				//      g
    103. 				//   u     p
    104. 				//            c
    105. 				if (cur == parent->_right)
    106. 				{
    107. 					RotateL(grandfather);
    108. 					parent->_col = BLACK;
    109. 					grandfather->_col = RED;
    110. 				}
    111. 				else
    112. 				{
    113. 					//		g
    114. 					//   u     p
    115. 					//      c
    116. 					RotateR(parent);
    117. 					RotateL(grandfather);
    118. 					cur->_col = BLACK;
    119. 					grandfather->_col = RED;
    120. 				}
    121. 				break;
    122. 			}
    123. 		}
    124. 	}
    125. 	_root->_col = BLACK;
    126.  
    127. 	return true;
    128. }
    129.  
    130. void RotateL(Node* parent)
    131. {
    132. 	Node* subR = parent->_right;
    133. 	Node* subRL = subR->_left;
    134.  
    135. 	parent->_right = subRL;
    136. 	if (subRL)
    137. 		subRL->_parent = parent;
    138.  
    139. 	subR->_left = parent;
    140. 	Node* ppnode = parent->_parent;
    141. 	parent->_parent = subR;
    142.  
    143. 	if (parent == _root)
    144. 	{
    145. 		_root = subR;
    146. 		subR->_parent = nullptr;
    147. 	}
    148. 	else
    149. 	{
    150. 		if (ppnode->_left == parent)
    151. 		{
    152. 			ppnode->_left = subR;
    153. 		}
    154. 		else
    155. 		{
    156. 			ppnode->_right = subR;
    157. 		}
    158. 		subR->_parent = ppnode;
    159. 	}
    160. }
    161.  
    162. void RotateR(Node* parent)
    163. {
    164. 	Node* subL = parent->_left;
    165. 	Node* subLR = subL->_right;
    166.  
    167. 	parent->_left = subLR;
    168. 	if (subLR)
    169. 		subLR->_parent = parent;
    170.  
    171. 	subL->_right = parent;
    172.  
    173. 	Node* ppnode = parent->_parent;
    174. 	parent->_parent = subL;
    175.  
    176. 	if (parent == _root)
    177. 	{
    178. 		_root = subL;
    179. 		subL->_parent = nullptr;
    180. 	}
    181. 	else
    182. 	{
    183. 		if (ppnode->_left == parent)
    184. 		{
    185. 			ppnode->_left = subL;
    186. 		}
    187. 		else
    188. 		{
    189. 			ppnode->_right = subL;
    190. 		}
    191. 		subL->_parent = ppnode;
    192. 	}
    193. }

    5.验证

    红黑树的验证分为两步：

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

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

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

    即：

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

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

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

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

    1. bool Check(Node* cur, int blackNum, int refBlackNum)
    2. {
    3. 	if (cur == nullptr)
    4. 	{
    5. 		if (refBlackNum != blackNum)
    6. 		{
    7. 			cout << "黑色节点的数量不相等" << endl;
    8. 			return false;
    9. 		}
    10. 		return true;
    11. 	}
    12.  
    13. 	if (cur->_col == RED && cur->_parent->_col == RED)
    14. 	{
    15. 		cout << cur->_kv.first << "存在连续的红色节点" << endl;
    16. 		return false;
    17. 	}
    18.  
    19. 	if (cur->_col == BLACK)
    20. 		++blackNum;
    21.  
    22. 	return Check(cur->_left, blackNum, refBlackNum)
    23. 		&& Check(cur->_right, blackNum, refBlackNum);
    24. }
    25.  
    26. bool IsBalance()
    27. {
    28. 	if (_root && _root->_col == RED)
    29. 		return false;
    30.  
    31. 	int refBlackNum = 0;
    32. 	Node* cur = _root;
    33. 	while (cur)
    34. 	{
    35. 		if (cur->_col == BLACK)
    36. 			refBlackNum++;
    37.  
    38. 		cur = cur->_left;
    39. 	}
    40. 	return Check(_root, 0, refBlackNum);
    41. }

    6.红黑树完整源码

    1. enum Colour
    2. {
    3. 	RED,
    4. 	BLACK
    5. };
    6.  
    7. template<class K, class V>
    8. struct RBTreeNode
    9. {
    10. 	RBTreeNode* _left;
    11. 	RBTreeNode* _right;
    12. 	RBTreeNode* _parent;
    13. 	pair _kv;
    14. 	Colour _col;
    15.  
    16. 	RBTreeNode(const pair& kv)
    17. 		:_left(nullptr)
    18. 		, _right(nullptr)
    19. 		, _parent(nullptr)
    20. 		, _kv(kv)
    21. 		, _col(RED)
    22. 	{}
    23. };
    24.  
    25. template<class K, class V>
    26. class RBTree
    27. {
    28. 	typedef RBTreeNode Node;
    29. public:
    30. 	bool Insert(const pair& kv)
    31. 	{
    32. 		if (_root == nullptr)
    33. 		{
    34. 			_root = new Node(kv);
    35. 			_root->_col = BLACK;
    36. 			return true;
    37. 		}
    38.  
    39. 		Node* parent = nullptr;
    40. 		Node* cur = _root;
    41. 		while (cur)
    42. 		{
    43. 			if (cur->_kv.first < kv.first)
    44. 			{
    45. 				parent = cur;
    46. 				cur = cur->_right;
    47. 			}
    48. 			else if (cur->_kv.first > kv.first)
    49. 			{
    50. 				parent = cur;
    51. 				cur = cur->_left;
    52. 			}
    53. 			else
    54. 			{
    55. 				return false;
    56. 			}
    57. 		}
    58.  
    59. 		cur = new Node(kv); // 红色的
    60. 		if (parent->_kv.first < kv.first)
    61. 		{
    62. 			parent->_right = cur;
    63. 		}
    64. 		else
    65. 		{
    66. 			parent->_left = cur;
    67. 		}
    68. 		cur->_parent = parent;
    69.  
    70. 		while (parent && parent->_col == RED)
    71. 		{
    72. 			Node* grandfather = parent->_parent;
    73. 			if (parent == grandfather->_left)
    74. 			{
    75. 				Node* uncle = grandfather->_right;
    76. 				// 情况一：叔叔存在且为红
    77. 				if (uncle && uncle->_col == RED)
    78. 				{
    79. 					// 变色
    80. 					parent->_col = uncle->_col = BLACK;
    81. 					grandfather->_col = RED;
    82.  
    83. 					// 继续往上处理
    84. 					cur = grandfather;
    85. 					parent = cur->_parent;
    86. 				}
    87. 				else
    88. 				{
    89. 					// 情况二：叔叔不存在或者存在且为黑
    90. 					// 旋转+变色
    91. 					if (cur == parent->_left)
    92. 					{
    93. 						//       g
    94. 						//    p    u
    95. 						// c
    96. 						RotateR(grandfather);
    97. 						parent->_col = BLACK;
    98. 						grandfather->_col = RED;
    99. 					}
    100. 					else
    101. 					{
    102. 						//       g
    103. 						//    p     u
    104. 						//      c
    105. 						RotateL(parent);
    106. 						RotateR(grandfather);
    107. 						cur->_col = BLACK;
    108. 						grandfather->_col = RED;
    109. 					}
    110.  
    111. 					break;
    112. 				}
    113. 			}
    114. 			else
    115. 			{
    116. 				Node* uncle = grandfather->_left;
    117. 				// 情况一：叔叔存在且为红
    118. 				if (uncle && uncle->_col == RED)
    119. 				{
    120. 					// 变色
    121. 					parent->_col = uncle->_col = BLACK;
    122. 					grandfather->_col = RED;
    123.  
    124. 					// 继续往上处理
    125. 					cur = grandfather;
    126. 					parent = cur->_parent;
    127. 				}
    128. 				else
    129. 				{
    130. 					// 情况二：叔叔不存在或者存在且为黑
    131. 					// 旋转+变色
    132. 					//      g
    133. 					//   u     p
    134. 					//            c
    135. 					if (cur == parent->_right)
    136. 					{
    137. 						RotateL(grandfather);
    138. 						parent->_col = BLACK;
    139. 						grandfather->_col = RED;
    140. 					}
    141. 					else
    142. 					{
    143. 						//		g
    144. 						//   u     p
    145. 						//      c
    146. 						RotateR(parent);
    147. 						RotateL(grandfather);
    148. 						cur->_col = BLACK;
    149. 						grandfather->_col = RED;
    150. 					}
    151.  
    152. 					break;
    153. 				}
    154. 			}
    155. 		}
    156.  
    157. 		_root->_col = BLACK;
    158.  
    159. 		return true;
    160. 	}
    161.  
    162. 	void RotateL(Node* parent)
    163. 	{
    164. 		++rotateSize;
    165.  
    166. 		Node* subR = parent->_right;
    167. 		Node* subRL = subR->_left;
    168.  
    169. 		parent->_right = subRL;
    170. 		if (subRL)
    171. 			subRL->_parent = parent;
    172.  
    173. 		subR->_left = parent;
    174. 		Node* ppnode = parent->_parent;
    175. 		parent->_parent = subR;
    176.  
    177. 		if (parent == _root)
    178. 		{
    179. 			_root = subR;
    180. 			subR->_parent = nullptr;
    181. 		}
    182. 		else
    183. 		{
    184. 			if (ppnode->_left == parent)
    185. 			{
    186. 				ppnode->_left = subR;
    187. 			}
    188. 			else
    189. 			{
    190. 				ppnode->_right = subR;
    191. 			}
    192. 			subR->_parent = ppnode;
    193. 		}
    194. 	}
    195.  
    196. 	void RotateR(Node* parent)
    197. 	{
    198. 		++rotateSize;
    199.  
    200. 		Node* subL = parent->_left;
    201. 		Node* subLR = subL->_right;
    202.  
    203. 		parent->_left = subLR;
    204. 		if (subLR)
    205. 			subLR->_parent = parent;
    206.  
    207. 		subL->_right = parent;
    208.  
    209. 		Node* ppnode = parent->_parent;
    210. 		parent->_parent = subL;
    211.  
    212. 		if (parent == _root)
    213. 		{
    214. 			_root = subL;
    215. 			subL->_parent = nullptr;
    216. 		}
    217. 		else
    218. 		{
    219. 			if (ppnode->_left == parent)
    220. 			{
    221. 				ppnode->_left = subL;
    222. 			}
    223. 			else
    224. 			{
    225. 				ppnode->_right = subL;
    226. 			}
    227. 			subL->_parent = ppnode;
    228. 		}
    229. 	}
    230.  
    231. 	void _InOrder(Node* root)
    232. 	{
    233. 		if (root == nullptr)
    234. 			return;
    235.  
    236. 		_InOrder(root->_left);
    237. 		cout << root->_kv.first << endl;
    238. 		_InOrder(root->_right);
    239. 	}
    240.  
    241. 	void InOrder()
    242. 	{
    243. 		_InOrder(_root);
    244. 	}
    245.  
    246. 	bool Check(Node* cur, int blackNum, int refBlackNum)
    247. 	{
    248. 		if (cur == nullptr)
    249. 		{
    250. 			if (refBlackNum != blackNum)
    251. 			{
    252. 				cout << "黑色节点的数量不相等" << endl;
    253. 				return false;
    254. 			}
    255.  
    256. 			//cout << blackNum << endl;
    257. 			return true;
    258. 		}
    259.  
    260. 		if (cur->_col == RED && cur->_parent->_col == RED)
    261. 		{
    262. 			cout << cur->_kv.first << "存在连续的红色节点" << endl;
    263. 			return false;
    264. 		}
    265.  
    266. 		if (cur->_col == BLACK)
    267. 			++blackNum;
    268.  
    269. 		return Check(cur->_left, blackNum, refBlackNum)
    270. 			&& Check(cur->_right, blackNum, refBlackNum);
    271. 	}
    272.  
    273. 	bool IsBalance()
    274. 	{
    275. 		if (_root && _root->_col == RED)
    276. 			return false;
    277.  
    278. 		int refBlackNum = 0;
    279. 		Node* cur = _root;
    280. 		while (cur)
    281. 		{
    282. 			if (cur->_col == BLACK)
    283. 				refBlackNum++;
    284.  
    285. 			cur = cur->_left;
    286. 		}
    287.  
    288. 		return Check(_root, 0, refBlackNum);
    289. 	}
    290.  
    291. 	size_t Size()
    292. 	{
    293. 		return _Size(_root);
    294. 	}
    295.  
    296. 	size_t _Size(Node* root)
    297. 	{
    298. 		if (root == NULL)
    299. 			return 0;
    300.  
    301. 		return _Size(root->_left)
    302. 			+ _Size(root->_right) + 1;
    303. 	}
    304.  
    305. 	Node* Find(const K& key)
    306. 	{
    307. 		Node* cur = _root;
    308. 		while (cur)
    309. 		{
    310. 			if (cur->_kv.first < key)
    311. 			{
    312. 				cur = cur->_right;
    313. 			}
    314. 			else if (cur->_kv.first > key)
    315. 			{
    316. 				cur = cur->_left;
    317. 			}
    318. 			else
    319. 			{
    320. 				return cur;
    321. 			}
    322. 		}
    323.  
    324. 		return NULL;
    325. 	}
    326.  
    327. 	int _Height(Node* root)
    328. 	{
    329. 		if (root == nullptr)
    330. 			return 0;
    331.  
    332. 		int leftHeight = _Height(root->_left);
    333. 		int rightHeight = _Height(root->_right);
    334.  
    335. 		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    336. 	}
    337.  
    338. 	int Height()
    339. 	{
    340. 		return _Height(_root);
    341. 	}
    342.  
    343. 	int GetRotateSize()
    344. 	{
    345. 		return rotateSize;
    346. 	}
    347.  
    348. private:
    349. 	Node* _root = nullptr;
    350. 	int rotateSize = 0;
    351. };

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

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

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

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

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

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

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

    🌟~ 点赞收藏＋关注 ~🌟

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

  • 相关阅读:
    一万小时真的能成为专家吗？
    据说是中国电信的java编程面试题
    ChatGPT生产力|实用指令（prompt）
    (附源码)ssm高校志愿者服务系统 毕业设计 011648
    【毕业设计】基于php+mysql+smarttemplate的图片共享系统设计与实现（毕业论文+程序源码）——图片共享系统
    SQL Server 全角半角设置梳理 Chinese_PRC_CI_AS_WS
    分享一个使用三目优先级遇到的优先级问题
    平板摄像头+算力搞定3D空间实时重建和理解，清华和禾多科技新成果入选CVPR 2022 Oral...
    【最优化方法】实验四 约束最优化方法的MATLAB实现
    直销系统开发是找开发公司还是外包团队？
  • 原文地址：https://blog.csdn.net/2301_77112634/article/details/136523992