数据结构---红黑树

最新推荐文章于 2024-08-18 00:23:09 发布
最新推荐文章于 2024-08-18 00:23:09 发布
阅读量268 收藏
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MEANSWER/article/details/117698298
版权

红黑树

1. 红黑树的概念

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

在这里插入图片描述

2. 红黑树的性质

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

3. 红黑树节点的定义

在节点的定义中，为什么要将节点的默认颜色给成红色的？

非要选择破坏性质3和4里面的一个的时候，选择破坏性质3（一个红结点他的两个孩子结点是黑色的），这个条件相对来说更加好控制一些，确保每条路径上的黑色结点数都是相同的这个条件并不好控制。

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;


	enum Color _col;

	//非要选择破坏性质3和4里面的一个的时候，选择3比较好---  一个红结点他的两个孩子结点是黑色的
	RBTreeNode(const pair<K,V>& kv)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
		, _kv(kv)
	{}
};

4. 红黑树的插入操作

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

  1. 按照二叉搜索的树规则插入新节点
  2. 检测新节点插入后，红黑树的性质是否造到破坏

插入新节点按照大框架其实就分为了2种情况：

  1. 叔叔结点存在且为红色
  2. 叔叔结点不存在或者存在且为黑色

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

约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

情况一：cur为红，p为红，g为黑，u存在且为红
在这里插入图片描述

  • p和u变黑，g变红这样的话，就没有连续的红结点了，这棵子树每条路径黑结点的数量不改变。
  • 如果g是根结点，调整完成后，需要将g改为黑色。
  • 如果g是子树，g一定有双亲，且g的双亲如果是红色，需要继续向上调整

情况二：cur为红，p为红，g为黑，u不存在/u存在且为黑
在这里插入图片描述

u的情况分为两种：

  1. 如果u结点不存在，则cur一定是新插入结点，因为如果cur不是新插入结点，则cur和p一定有一个结点的颜色是黑色，就不满足性质四：每条路径黑色节点个数相同。

①右单旋
在这里插入图片描述

②左单旋
在这里插入图片描述

  1. 如果u结点存在，则其一定是黑色，那么cur结点原来的颜色一定是黑色。
    在这里插入图片描述

总结：

  • p为g的左孩子，cur为p的左孩子，则进行右单旋转；
  • p为g的右孩子，cur为p的右孩子，则进行左单旋转
  • p、g变色–p变黑，g变红

u的情况分为两种：

  1. 如果u结点不存在，则cur一定是新插入结点，因为如果cur不是新插入结点，则cur和p一定有一个结点的颜色是黑色，就不满足性质四：每条路径黑色节点个数相同。

在这里插入图片描述

  1. 如果u结点存在，则其一定是黑色，那么cur结点原来的颜色一定是黑色

③先左单旋再右单旋
在这里插入图片描述

④先右单旋再左单旋
在这里插入图片描述

总结：

  • p为g的左孩子，cur为p的右孩子，则针对p做左单旋转，然后在以cur做右单旋；
  • p为g的右孩子，cur为p的左孩子，则针对p做右单旋转，然后在以cur做左单旋；
  • g变为红色，cur变为黑色
	pair<Node*,bool> Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return make_pair(_root, 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 make_pair(cur, false);
			}
		}

		cur = new Node(kv);//RED
		//此时说明已经找到了位置，还需要进行插入
		if (parent->_kv.first < kv.first)
		{
			//说明此时应该链接在父节点的右边
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		Node* newnode = cur;
		//因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整
		while (parent && parent->_col == RED) //cur是新增的肯定存在parent，但是如果他是往上跳了一层的，就不会有parent了
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				//情况一：叔叔存在且为红色，第一种情况是不旋转的，只是单纯的变一个色
				if (uncle && uncle->_col == RED)
				{
					//变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else //情况2+3 u不存在或者存在且为黑 
				{
					//			g
					//       p
					//    c
					if (cur == parent->_left)//右单旋
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//此时就是一个双旋了
						//		g
						//    p
						//      c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else //grandfather->_right == parent
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;//这里再不要忘记，也有可能迭代的要往上继续处理
				}
				else
				{
					//叔叔不存在或者叔叔的颜色为黑
					//       g
					//			p
					//			   c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED; //
						parent->_col = BLACK;
					}
					//			g
					//			  p
					//			c
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;//始终把根变为黑色
		return make_pair(newnode, true);
	}


	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		//但是subLR有可能是空的，那么下面这个代码就会崩
		if (subLR)
			subLR->_parent = parent;

		Node* parentParent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;


		//此时还需要最后一步，把根结点换掉
		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			//此时你需要把30这个结点连接住，但是应该连接在哪一边还需要进行判断
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
	}

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

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

		Node* parentParent = parent->_parent;//先保存下来，因为后面会改变这个，就找不到最开始的父节点了

		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			//作为子树的一部分
			if (parentParent->_left == parent)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}
			subR->_parent = parentParent;
		}
	}

5. 红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质（当然也可以去查看是否满足最长路径不会超过最短路径的2倍，但是这个条件检查起来其实是相对困难的，所以这里选择去查看是否这棵树有满足性质）
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_kv.first << " ";
		_Inorder(root->_right);
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}

	bool _CheckRedCol(Node* root)
	{
		if (root == nullptr)
			return true;
		if (root->_col == RED)
		{
			Node* parent = root->_parent;
			if (parent->_col == RED)
			{
				cout << "违反规则3：存在连续的红结点" << endl;
				return false;
			}
		}
		return _CheckRedCol(root->_left) && _CheckRedCol(root->_right);
	}

	//检查每条路径上的黑色节点数是否相同
	bool _CheckBlackNum(Node* root,int blackNum,int trueNum)
	{
		if (root == nullptr)
		{
			return trueNum == blackNum;
		}

		if (root->_col == BLACK)
		{
			blackNum++;
		}

		return _CheckBlackNum(root->_left, blackNum,trueNum) && _CheckBlackNum(root->_right, blackNum,trueNum);
	}
	//不要考虑去检查最长路径是否不超过最短路径的两倍，这个方法麻烦
	//而是从反向进行思考，检查他的性质是否都满足
	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "违反规则1：根结点是红色的" << endl;
			return false;
		}

		int trueNum = 0; //拿到真实路径上面的结点值，然后和算出来的进行比较
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++trueNum;
			}
			cur = cur->_left;
		}
		int blackNum = 0;
		return _CheckRedCol(_root) && _CheckBlackNum(_root, blackNum,trueNum); //这样就知道是否满足了红黑树的所有性质
	}

6. 红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN)（以2为底），红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，（AVL树是一个严格平衡的二叉搜索树，而红黑树只是一个近似平衡的二叉搜索树，但是在效率方面，从计算机方面来看两者几乎是相同）而且红黑树实现比较简单，所以实际运用中红黑树更多。

7. 完整红黑树模拟实现代码

#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;


	enum Color _col;

	//非要选择破坏性质3和4里面的一个的时候，选择3比较好---  一个红结点他的两个孩子结点是黑色的
	RBTreeNode(const pair<K,V>& kv)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
		, _kv(kv)
	{}
};

template<class K,class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	pair<Node*,bool> Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return make_pair(_root, 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 make_pair(cur, false);
			}
		}

		cur = new Node(kv);//RED
		//此时说明已经找到了位置，还需要进行插入
		if (parent->_kv.first < kv.first)
		{
			//说明此时应该链接在父节点的右边
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		Node* newnode = cur;
		//因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整
		while (parent && parent->_col == RED) //cur是新增的肯定存在parent，但是如果他是往上跳了一层的，就不会有parent了
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				//情况一：叔叔存在且为红色，第一种情况是不旋转的，只是单纯的变一个色
				if (uncle && uncle->_col == RED)
				{
					//变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else //情况2+3 u不存在或者存在且为黑 
				{
					//			g
					//       p
					//    c
					if (cur == parent->_left)//右单旋
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//此时就是一个双旋了
						//		g
						//    p
						//      c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else //grandfather->_right == parent
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;//这里再不要忘记，也有可能迭代的要往上继续处理
				}
				else
				{
					//叔叔不存在或者叔叔的颜色为黑
					//       g
					//			p
					//			   c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED; //
						parent->_col = BLACK;
					}
					//			g
					//			  p
					//			c
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;//始终把根变为黑色
		return make_pair(newnode, true);
	}


	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		//但是subLR有可能是空的，那么下面这个代码就会崩
		if (subLR)
			subLR->_parent = parent;

		Node* parentParent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;


		//此时还需要最后一步，把根结点换掉
		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			//此时你需要把30这个结点连接住，但是应该连接在哪一边还需要进行判断
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
	}

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

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

		Node* parentParent = parent->_parent;//先保存下来，因为后面会改变这个，就找不到最开始的父节点了

		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			//作为子树的一部分
			if (parentParent->_left == parent)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}
			subR->_parent = parentParent;
		}
	}

	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_kv.first << " ";
		_Inorder(root->_right);
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}

	bool _CheckRedCol(Node* root)
	{
		if (root == nullptr)
			return true;
		if (root->_col == RED)
		{
			Node* parent = root->_parent;
			if (parent->_col == RED)
			{
				cout << "违反规则3：存在连续的红结点" << endl;
				return false;
			}
		}
		return _CheckRedCol(root->_left) && _CheckRedCol(root->_right);//其实拆分为了根，左子树，右子树的问题
	}

	bool _CheckBlackNum(Node* root,int blackNum,int trueNum)
	{
		if (root == nullptr)
		{
			return trueNum == blackNum;//算出来的和真实的进行比较
		}

		if (root->_col == BLACK)
		{
			blackNum++;
		}

		return _CheckBlackNum(root->_left, blackNum,trueNum) && _CheckBlackNum(root->_right, blackNum,trueNum);
	}
	//不要考虑去检查最长路径是否不超过最短路径的两倍，这个方法麻烦
	//而是从反向进行思考，检查他的性质是否都满足
	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "违反规则1：根结点是红色的" << endl;
			return false;
		}

		int trueNum = 0; //拿到真实路径上面的结点值，然后和算出来的进行比较
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++trueNum;
			}
			cur = cur->_left;
		}
		int blackNum = 0;
		return _CheckRedCol(_root) && _CheckBlackNum(_root, blackNum,trueNum); //这样就知道是否满足了红黑树的所有性质
	}

private:
	Node* _root = nullptr;
};

main.c

#include"RBTree.hpp"

void TestRBTree()
{
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	RBTree<int, int> t;

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

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

int main()
{
	TestRBTree();
}

在这里插入图片描述

没什么..
关注
专栏目录
数据结构之红黑树
hty46565的博客
11-21 266
红黑树的由来 红黑树的引入是用来解决二叉查找树在频繁的插入、删除操作的情况下，可能会出现的性能快速退化的问题。二叉查找树最坏的情况下可能退化为链表，成为O(n)O(n)O(n)的时间复杂度。 用来解决这种问题的二叉查找树叫做平衡二叉查找树，平衡二叉查找树可以保持二叉查找树的高度尽可能的小，以此来使二叉查找树的操作时间复杂度稳定在O(logn)O(logn)O(logn)。 接下来看一下平衡二叉查找...
数据结构-红黑树.zip
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
红黑树
深耕技术
03-03 307
面试：你懂什么是分布式系统吗？Redis分布式锁都不会？>>> 1. 简介 红黑树是一种自平衡二叉查找树。它的统计性能要好于平衡二叉树（AVL树），因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操...
数据结构——红黑树
2401_86777036的博客
08-18 766
红黑树：一种相对平衡的二叉搜索树，通过限制路径节点着色方式保证最长路径不会超过最短路径的两倍，从而提高效率
数据结构：红黑树（Red Black Tree）
Gabriel.Tian的博客
07-29 530
概念 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。它可以在O(log n)时间内（它的查找最坏时间复杂度为O(2lgn)）做查找，插入和删除，这里的n 是树中元素的数目。 性质 节点是红色或黑色。 根节点是黑色...
数据结构--红黑树
sayhello_world的博客
05-10 719
数据结构之红黑树   一．什么是红黑树？ 红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是red或者black，通过对任何一条从根节点到叶子结点上的简单路径来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似平衡。   二．红黑树满足的条件？ 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个根节点是红色的，则它的两个叶子结点是黑
数据结构-红黑树（全篇）
10-17
红黑树代码资源
红黑树-基于Java实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由计算机科学家...总的来说，红黑树是数据结构中的重要组成部分，尤其在需要高效存储和检索大量有序数据的场合。通过理解和掌握红黑树的原理和实现，能提升编程能力，优化程序性能。
数据结构-Java实现一个简单的红黑树RedBlackTree
最新发布
09-25
数据结构-Java实现一个简单的红黑树RedBlackTree，代码通过内部类和枚举来实现了一个简单的红黑树，包括了红黑树的插入、查找以及部分辅助函数。
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
- 转换操作：在插入和删除过程中，可能需要将红黑树转换成其他数据结构，如AVL树，以满足特定需求。 在实际应用中，红黑树广泛用于各种场景，如C++标准库中的STL map和set，它们底层就是基于红黑树实现的。红黑树的...
红黑树数据结构剖析
weixin_34327223的博客
07-13 100
红黑树数据结构剖析   红黑树是计算机科学内比较常用的一种数据结构，它使得对数据的搜索，插入和删除操作都能保持在O(lgn)的时间复杂度。然而，相比于一般的数据结构，红黑树的实现的难度有所增加。网络上关于红黑树的实现资料汗牛充栋，但是乏于系统介绍红黑树实现的资料。本文通过一个自己实现的红黑树数据结构以及必要的搜索，插入和删除操作算法，为大家更系统地剖析红黑树数据结构的实现。 对于大部分数...
数据结构_红黑树
xc13212777631的博客
06-25 922
红黑树 红黑树也是属于一种BBST。在之前介绍的伸展树中，虽然实现简单，分摊复杂度低，但是最坏情况下的操作需要O(n)时间，无法适用于对单次效率敏感的场合。相反的，之前介绍的AVL树尽管可以保证最坏情况下的单次操作，但是要在节点中嵌入平衡因子等标识；更重要的是，删除操作之后可能需要多达O(logn)次旋转。红黑树是针对后一不足的改进。通过为节点指定颜色，合理动态调整。它可以保证：在每一次插入或删...
『数据结构』红黑树(red-black tree)
mbinary
07-14 481
1. 定义与性质 红黑树是一种平衡的二叉查找树 1.1. 数据域 每个结点有 5 个数据域 * color: red or black * key: keyword * left: pointer to left child * right:pointer to right child * p: pointer to nil leaf 1.2. 红黑性质 满足下面的 ...
算法导论：数据结构篇--红黑树详解
总结来说，《算法导论》中的红黑树章节是理解数据结构中的高级主题，特别是动态数据结构实现的重要部分，它为高效的搜索和排序算法提供了基础，是所有希望深入学习计算机科学和算法设计的学生和专业人士的必备参考...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值