认识红黑树

最新推荐文章于 2024-07-19 13:59:11 发布
最新推荐文章于 2024-07-19 13:59:11 发布
阅读量295 收藏 1
点赞数 3
分类专栏： c++ 数据结构 文章标签： 算法 数据结构 b树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xbhinsterest11/article/details/126815978
版权
红黑树

往期文章介绍了AVL树，它是一个颗平衡的搜索二叉树，当插入数据后如果导致任意结点的左右两边的高度差超过1，就会进行旋转调整，其平衡规则比较严格，所以当插入大量数据的时候就会导致多次旋转，本文介绍的红黑树也是一颗平衡搜索二叉树，它的平衡是通过控制结点的颜色来间接控制的，但是其平衡规则没有AVL树那样严格，是相对平衡的（最长的路径不超过最短路径的两倍都算平衡），所以其相对AVL树来说可以在大量插入数据的时候只需要旋转较少的次数就可以实现树的平衡。

在这里插入图片描述

什么是红黑树

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

红黑树遵守的规则

既然是平衡树就需要遵守一些规则来保持树的平衡，下面是红黑树必须遵守的五个规则，只有遵守这五个规则，才可以使得红黑树是平衡树！！！

  • 1.每个结点的颜色不是黑色就是红色
  • 2.根结点必须是黑色的
  • 3.如果一个节点是红色的，那么他的子节点就必须是黑色的（不能有连续的红色结点）
  • 4.对于每个结点，从该结点到其所有后代叶子结点的简单路径上，都包含相同颜色的黑色结点
  • 5.每个叶子结点都是黑色的（即空结点是黑色的，简单路径以空结尾）

思考一：为什么遵循了上面的规则就可以保证树中的最长路径不超过最短路径的两倍呢？

因为在不破坏规则的情况下，最短路径就是该路径都是全黑结点，最长路径就是一黑一红交替。极端情况下满足最长路径恰好是最短路径的两倍，不会超过两倍。

在这里插入图片描述

思考二：新增的结点是设为黑色还是红色呢？

考虑到规则限制，我们可以知道如果在原本平衡的树中插入新的结点的颜色为黑色，就会违反规则4（从一个结点到其所有后代叶子结点的简单路径上的黑色结点个数相同），如果在原本平衡的树中插入新的结点的颜色为红色，那么就不会违反规则4，但是有可能会违反规则3（不能存在连续的红色结点）。

  • 综合以上两种情况，我们可以分析当一个树的结点非常多的时候那么一个结点到其所有后代的叶子结点的路径就会非常多，如果新增结点是黑色就必然违反这个规则，就需要更改每一条路径，非常难处理！！！

  • 但是如果新增是红色就是当新增结点的父亲是红色的时候（连续红结点）才会违反规则，但是这种连续红结点的情况我们可以通过往上迭代改变结点的颜色来维护规则，总而言之就是违反规则3相对违反规则4比较好处理。所以新增的结点颜色默认设为红色的。

举例：
在这里插入图片描述

  • 如果上面的额2是黑色结点就会导致4到其所有叶子结点的简单路径上黑色结点不相同，8也会受到影响，处理起来很麻烦。

红黑树的实现

基本结构

//结点的颜色 用枚举表示
enum color
{
	RED,
	BLACK,
};
template<class K,class V>
//树的结点
struct RBTreeNode
{
    //三叉链
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;//每个结点可以找到父亲  

	color _col;//颜色
	pair<K, V> _kv;//数据
	RBTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_col(RED)
		,_kv(kv)
	{

	}
	
};

template<class K,class V>
class RBTree
{
public:
	typedef RBTreeNode<K,V> Node;
    typedef __RBTree_Iterator<T, T&, T*> iterator;
	typedef __RBTree_Iterator<T,const T&,const T*> const_iterator;//迭代器
    
	RBTree()
		:_root(nullptr)
	{}
    RBTree(const RBTree<K, V>& t)//拷贝构造
	{
		_root = copyNode(t._root);
	}
	
    iterator begin();
    const_iterator begin()const {}
	iterator end();
    const_iterator endn()const{} 
	
    //左右旋转
	void RotateL(Node* parent);
    void RotateR(Node* parent);
    //主要是掌握插入数据构建红黑树
    bool insert(const pair<K,V>& kv);
    size_t getMaxHight();
    size_t getMinHight();
    bool checkIsRBTree();
private:
    Node* _root;
}

学习红黑树主要是学插入数据的过程中的各种导致不平衡的情况该如何调整，使得插入数据前后都是平衡的树，不违法红黑树遵循的规则。

插入的多种情况分析

这里称插入结点（c表示）的父亲结点的兄弟结点为叔叔结点（u表示)，插入结点的父亲的父亲为祖父结点(g表示）。

第一种：叔叔存在且为红

在这里插入图片描述

处理：将p变黑，u变黑，g变红（如果g是根结点就将其颜色改成黑）再往上迭代器处理（即第一次变色后可能会影响上层的结点，就需要往上迭代处理，如果有违反的情况就处理）

为什么需要迭代往上修改呢？

如下图，出现连续的红色结点后进行了改色，这可能会影响上层的结点，这里使g变成了红色g的父节点也是红色，就又出现了连续的红结点，就还需要处理，所以要往上迭代处理如果不符合规则就对其进行处理，处理到符合所有规则为止！！！

第二种：叔叔不存在

叔叔不存在的情况也有四种

满足c为红 p为红 g为黑

  • 1、p为g的左，c为p的左（g p c 形成斜线 / ）
    在这里插入图片描述

处理方式：对g进行右单旋，再把p变成黑色，g变红色

  • 2、p为g的左 ，c为p的右（g p c形成折线 < )

在这里插入图片描述

处理方式：对p进行左单旋，然后变成第一种情况（/斜线型），进行处理。

  • 3、p为g的右，c为p的右（g p c 形成斜线 \ ）

在这里插入图片描述

处理方式：对g进行左单旋，再把p变成黑色，g变红色

  • 4、p为g的右， c为p的左（g p c 形成折线 > )

在这里插入图片描述

处理方式：对p进行右单旋，然后变成第一种情况（\斜线型），进行处理。

第三种：叔叔存在且为黑

叔叔存在且为黑的情况是由叔叔存在且为红的情况转化而来的，下面的图都是包含叔叔存在且为红的情况，处理完叔叔存在且为红后就有可能会形成叔叔存在且为黑的情况，以下就是所有的情况，其中的△是代表空或者各种子树（也就是说△可以拓展开来，只要拓展开后不违反规则就可以！）

这里涉及树的旋转 可以参考前几期的AVL树的博客 里面有旋转的详细解析

满足c为红 p为红 g为黑

  • 1、p为g的左，c为p的左（g p c 形成斜线 / ）

在这里插入图片描述

处理方式：1、处理完叔叔存在且为红的情况后转化为叔叔存在且为黑的情况。

​ 2、对g进行右单旋，再把p变成黑色，g变红色

  • 2、p为g的左 ，c为p的右（g p c形成折线 < )

在这里插入图片描述

处理方式：1、处理完叔叔存在且为红的情况后转化为叔叔存在且为黑的情况。

​ 2、对p进行左单旋，将折线型（<）转化为斜线型(/），转化为上面的情况1处理

  • 3、p为g的右，c为p的右（g p c 形成斜线 \ ）

在这里插入图片描述

处理方式：1、处理完叔叔存在且为红的情况后转化为叔叔存在且为黑的情况。

​ 2、对g进行左单旋，再把p变成黑色，g变红色

  • 4、p为g的右， c为p的左（g p c 形成折线 > )

在这里插入图片描述

处理方式：1、处理完叔叔存在且为红的情况后转化为叔叔存在且为黑的情况。

​ 2、对p进行右单旋，将折线型（>）转化为斜线型(\），转化为上面的情况3处理

插入函数的代码：

bool insert(const pair<K,V>& kv)
	{
    	//第一次插入的情况 新插入结点（红色）做根结点 然后得把其颜色改成黑
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		else
		{
			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已经为空了 直接将新结点赋值给cur
			cur = new Node(kv);
			cur->_col = RED;
			//链接新增结点和其父节点
			if (cur->_kv.first < parent->_kv.first)
			{
				parent->_left = cur;
			}
			else
			{
				parent->_right = cur;
			}
			cur->_parent = parent;

			//调整红黑树 维持规则
			while (parent&&parent->_col==RED)
			{
				Node* grandfather = parent->_parent;
				Node* uncle = nullptr;
			
				if (grandfather->_left == parent)
				{
					uncle = grandfather->_right;
				}
				else
				{
					uncle = grandfather->_left;
				}

			
				 if (parent&&parent->_col== RED && uncle && uncle->_col == RED)//叔叔存在且为红
				{
					
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						cur = grandfather;//迭代往上调整
						parent = cur->_parent;
				
				}
				else if (parent&&parent->_col==RED&&(uncle == nullptr||(uncle!=nullptr&&uncle->_col==BLACK)) )//叔叔不存在或存在且为黑
				{
					if (grandfather->_left==parent&&cur==parent->_right)//叔叔不存在
					{
						//        g
						//	  p
						//        c
						RotateL(parent);
						swap(parent, cur);
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
						
					}
					else if (grandfather->_left == parent && cur == parent->_left)
					{
						//        g
						//    p
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else if (grandfather->_right == parent && cur == parent->_left)
					{
						//    g
						//		 p
						//    c
						RotateR(parent);
						swap(parent, cur);
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED; 

					}
					else if (grandfather->_right == parent && cur == parent->_right)
					{
						//    g
						//		 p
						//			 c
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					break;

				}

			}
			
			_root->_col = BLACK;
			return true;
		}
	}

旋转代码

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

		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;
		
		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else if(ppnode->_right==parent)
			{
				ppnode->_right = subR;
			}
			else
			{
				cout << "内部错误！" << endl;
				assert(false);
			}
			subR->_parent = ppnode;
		}

	}
RotateR
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 (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else if (ppnode->_right == parent)
			{
				ppnode->_right = subL;
			}
			else
			{
				cout << "内部错误！" << endl;
				assert(false);
			}
			subL->_parent = ppnode;
		}
	}

判断是否为红黑树的函数（也就是检查是否符合规则）

checkIsRBTree
	bool checkIsRBTree()
	{
		if (_root == nullptr)//空树也是红黑树
		{
			return true;
		}
		if (_root->_col != BLACK)
		{
			cout << "根结点不为黑！" << endl;
			return false;
		}
		Node* cur = _root;
		size_t standardBlackCount = 0;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				standardBlackCount++;
			}
			cur = cur->_left;
		}
		size_t k = 0;
		return _checkIsRBTree(_root, standardBlackCount, k); 
	}

	//传一个最短基准值 判断每条路径是否超过其两倍
	bool _checkIsRBTree(Node* root,size_t standardCount,size_t blackCount)
	{
		if (root == nullptr)
		{
			if (standardCount != blackCount)
			{
				cout << "不符合每条路径上的黑结点数目相同！" << endl;
				return false;
			}
			
			return true;
		}
		//统计当前路径的黑结点的数量
		if(root->_col==BLACK)
		blackCount++;

		Node* parent = root->_parent;
		if (root->_col == RED && parent && parent->_col == RED)
		{
			cout << "存在连续红结点！" << endl;
			return false;
		}
		
		return _checkIsRBTree(root->_left,standardCount,blackCount) && _checkIsRBTree(root->_right,standardCount,blackCount);

	}

拷贝构造函数（深拷贝）

RBTree(const RBTree<K, V>& t)
	{
		_root = copyNode(t._root);
	}
	Node* copyNode(Node* root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* newroot = new Node(root->_kv);
		newroot->_left = copyNode(root->_left);
		newroot->_left = copyNode(root->_right);
		return newroot;
	}

获取树的最小和最大高度

size_t getMaxHight()
	{
		return _getMaxHight(_root);
	}
	size_t _getMaxHight(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		size_t LMH = _getMaxHight(root->_left);
		size_t RMH = _getMaxHight(root->_right);
		return LMH > RMH ? LMH + 1 : RMH + 1;
	}

	size_t getMinHight()
	{
		return _getMinHight(_root);
	}

	size_t _getMinHight(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		size_t LMH = _getMinHight(root->_left);
		size_t RMH = _getMinHight(root->_right);
		return LMH < RMH ? LMH + 1 : RMH + 1;
	}

红黑树的迭代器实现

在这里插入图片描述

operator-- 就是类比operator++ 即可推出，这里就不多bb了 。

	template<class T,class Ref,class Ptr>
	struct __RBTree_Iterator
	{
		typedef __RBTree_Iterator<T, Ref, Ptr> self;
		typedef RBTreeNode<T> Node;
		__RBTree_Iterator(Node* root)
			:_root(root)
		{

		}
		Ref operator*()//这里是无参的返回的额是当前迭代器对象的数据 
		{
			return _root->_data;
		}
		Ptr operator->()
		{
			return &(_root->_data);
		}
		self& operator=(const self& it)
		{
			_root = it._root;
		}
		self& operator++()
		{
			if (_root->_right == nullptr)
			{
				Node* cur = _root;
				Node* parent = _root->_parent;
				while (parent&&parent->_left != cur)//要保证最后一个结点的 
				{
					cur = cur->_parent;
					parent = parent->_parent;
				}
				_root = parent;
			}
			else
			{
				Node* right = _root->_right;
				while (right->_left)
				{
					right = right->_left;
				}
				_root = right;
			}
			return *this;
		}
		self& operator++(int)
		{
			//self tmp = *this;
			self tmp(*this);
			++ *this;
			return tmp;

		}
		self& operator--()
		{
			if (_root->_left==nullptr)
			{
				Node* cur = _root;
				Node* parent = _root->_parent;
				while (parent&&parent->_right != cur)
				{
					cur = cur->_parent;
					parent = parent->_parent;
				}
				_root = parent;
			}
			else
			{
				Node* left = _root->_left;
				while (left->_right)
				{
					left = left->_right;
				}
				_root = left;
			}
			return *this;
		}
		self& operator--(int)
		{
			//self tmp = *this;
			self tmp(*this);
			-- *this;
			return tmp;
		}

		bool operator==(const self& it)const 
		{
			return _root == it._root;
		}
		bool operator!=(const self& it)const 
		{
			return _root != it._root;
		}

		Node* _root;
	};
*insist
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
【c++/数据结构】红黑树-RBTree
LLZK_的博客
10-30 1232
什么叫红黑树？同AVL树一样，红黑树也是近似平衡的二叉搜索树，与AVL树不同的是红黑树没有了平衡因子，但增加了一个枚举变量，来标明结点的颜（RED or BLACK）。因为红黑树可以保证它的最长路劲不超过它最短路径的两倍，所以它近似平衡。红黑树具有以下几点性质： 1. 每个结点都必须具有一种颜色（RED or BLACK）。 2. 根结点为黑色。 3. 如果一个结点为红色，那么它的两个孩
浅识红黑树
真有人考408的博客
09-27 179
红黑树的基本介绍
浅谈红黑树（R-B Tree）原理
qq_28326489的博客
05-08 243
红黑树的实现基于平衡二叉树。 红黑树的特点： 节点分为红色或者黑色； 根节点必为黑色； 叶子节点都为黑色，且为null； 连接红色节点的两个子节点都为黑色（红黑树不会出现相邻的红色节点）； 从任意节点出发，到其每个叶子节点的路径中包含相同数量的黑色节点； 新加入到红黑树的节点为红色节点； 示例图： 红黑树自平衡基本操作： 变色：在不违反上述红黑树规则特点情况下，将红黑树某个node节点颜色由红变黑，或者由黑变红； 左旋：逆时针旋转两个节点，让一个节点被其右子节点取代，而该节点成为右子节点的.
算法分析与设计课程作业第十五周#1#2#3
hzl_ng的博客
12-21 303
算法分析与设计课程作业第十五周#1#2#3这次选了两道与期中考题目相似的题目以及一道动态规划题来做。
RBTree(红黑树)
sowhat
04-04 853
http://www.linuxidc.com/Linux/2017-01/139950.htm 红黑树        红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是Red或Black。通过对任何一条从根到叶子简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似于平衡。 红黑树是满足下面红黑性质的二叉搜索树：
二叉搜索树 全部题目
yanglq的博客
08-11 682
501. Find Mode in Binary Search Tree Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST. Assume a BST is defined a
红黑树
知行且执行
04-15 754
一、红黑树性质二叉搜索树中若一个节点没有父节点或子节点则该节点相应属性的值设为NIL，我们视NIL为二叉搜索树的叶节点(外部节点)，带关键字的为内部节点。一棵红黑树是满足下列五条性质的二叉搜索树： 1. 树的每个节点不是红色就是黑色 2. 树的根节点是黑色 3. 树的每个叶节点（NIL）为黑色 4. 若节点是红色则它的孩子必须是黑色（若有孩子的话） 5. 树中每一个节点到其
VC6.0红黑树
06-03
红黑树（Red-Black Tree）是计算机科学中一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。这种数据结构在众多的算法和数据结构中占有...通过研究提供的源码，可以加深对红黑树及其实现原理的认识，提高编程能力。
为什么MySQL数据库索引选择使用B+树?
01-19
学过数据结构的一般对最基础的树都有所认识，因此我们就从与我们主题更为相近的二叉查找树开始。 一、二叉查找树 （1）二叉树简介： 二叉查找树也称为有序二叉查找树，满足二叉查找树的一般性质，是指一棵空树具有...
数据结构各章实验 图的遍历 各种排序 二叉排序树
06-17
平衡二叉排序树（如AVL树和红黑树）进一步优化了性能，确保树的高度尽可能小，从而减少操作的时间复杂度。 这个资源包提供的详细源码、截图和测试数据，对初学者来说是一份宝贵的实践资料。通过学习和分析这些代码...
高一凡代码-第6章 树和二叉树.rar
12-14
4. 平衡二叉树：左右子树的高度差不超过1，如AVL树和红黑树，它们保持了良好的平衡，从而保证了搜索、插入和删除操作的时间复杂度为O(log n)。 在编程实现中，树和二叉树通常通过指针或引用来表示节点间的链接。...
小米Java程序员第二轮面试10个问题 你是否会被刷掉？
08-28
1. Java基础知识：包括Java集合的继承关系、Java中的红黑树实现、HashMap的实现、Java中的多线程编程等。 Java集合的继承关系是Java集合框架的基础，它定义了集合类之间的继承关系和实现关系。Java中的红黑树是Java...
红黑树（RBTree）原理及实现
weixin_52259848的博客
07-08 2485
红黑树（RBTree）原理及实现
红黑树RB-tree
IT_iverson的博客
02-09 427
AVL之外，另外一个颇具历史并且被广泛运用的平衡二叉搜索树是RB-tree（红黑树）,所谓的红黑树其实也是一个二叉搜索树，但是他对二叉搜索树的每个结点是必须满足如下规则的。 1.每个结点不是红色就是黑色 2.根节点为黑色 3.如果结点为红色，其子节点必须为黑色（即不能有两个连续的红色结点，黑色结点可以连续） 4.任意结点至NULL（树尾端）的任何路径，所含的黑色结点数必须相同。 如下图就
LeetCode 98. Validate Binary Search Tree - 二叉搜索树（Binary Search Tree）系列题3
hgq522的博客
01-14 264
题目要求验证一棵二叉树是否为二叉搜索树(BST: Binary Search Tree)。首先要明白二叉搜索树的特点，对于一个节点，其左子树的所有节点值不能大于等于该节点值，其右子树的所有节点值不能小于等于该节点值，还有就是左右子树也都必须是二叉搜索树。 根据以上分析，很容易想到用递归法。本题可以有两种递归法，分别是自顶向下和自底向上。
PAT-ADVANCED1135——Is It A Red-Black Tree
清风阁
11-18 389
我的PAT-ADVANCED代码仓：https://github.com/617076674/PAT-ADVANCED 原题链接：https://pintia.cn/problem-sets/994805342720868352/problems/994805346063728640 题目描述： 题目翻译： 1135 这是一棵红黑树吗 在数据结构中有一种称为红黑树的平衡二叉搜索树。 ...
攻克红黑树
Immaturecld的博客
09-13 222
红黑树 性质 每个节点只有红色或者黑色两种情况 根节点一定是黑色 如果一个节点是红色，那么它的两个子节点一定是黑色 对于每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点 每一个叶子节点都是黑色（可以为nullptr） 由上述特点可以的出，红黑树的最长路径不超过最短路径的两倍 最长路径：最长的情况是红黑相间，红黑节点个数相同（节点个数=黑色个数*2） 最短路径：最短的情况是只有黑色节点，与最长路径黑色节点个数相同 所谓的红黑树，本身也就是双色树，颜色只是观察其特点，并不局限与红黑
LeetCode 29：验证二叉搜索树 Validate Binary Search Tree
爱写Bug
03-09 300
题目： 给定一个二叉树，判断其是否是一个有效的二叉搜索树。Given a binary tree, determine if it is a valid binary search tr...
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 372
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
徒手红黑树：机器学习入门与K-means算法详解
本资源是一期名为"机器学习概览-漏洞银行大咖面对面28-徒手红黑树"的讲座，由信息安全领域的专家"徒手红黑树"主讲。讲座涵盖了机器学习的基础概念和常见算法，旨在帮助听众理解这一领域的重要原理。 首先，讲座从...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值