二叉搜索树和红黑树概述以及模板实现（2）--红黑树

最新推荐文章于 2022-10-15 22:03:48 发布
最新推荐文章于 2022-10-15 22:03:48 发布
阅读量1.1k 收藏
点赞数
分类专栏： 算法 C++ 文章标签： insert tree null each up 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hopeztm/article/details/7176794
版权
算法 同时被 2 个专栏收录
60 篇文章 3 订阅
订阅专栏
C++
39 篇文章 0 订阅
订阅专栏

其实很多人会意识到，如果使用二叉搜索树，在数据不好的情况下，最后查找的效果会变成线性。例如数据 1 2 3 4 5 6 7，根为1，其他数据依次插入在右侧，最后变成一个线性结构，性能就会变差。如何改善二叉搜索树，使得树的高度接近logN，这种特殊的二叉搜索树就可以用红黑树来实现。

红黑树满足的五个条件

1. 每个节点或是红色，或者是黑色

2. 根是黑色的

3. 每个叶节点（NIL）是黑色的

4. 如果一个节点是红色的，则它的两个儿子都是黑色的

5. 对于每个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑节点。


4 5 性质保证了 这个特殊的二叉搜索树局部上是趋近平衡的，算法导论中证明了一棵具有n个内点的红黑树，高度至多是2lg(n+1),图是一个rb树的例子



树节点的定义为：

typedef enum{RED,BLACK} Color;

	template<typename T>
	class RBTreeNode
	{
	public:
		RBTreeNode()
		{
			pLeft = pRight = pParent = NULL;
		}
		RBTreeNode(T _data):data(_data)
		{
			pLeft = pRight = pParent = NULL;
		}

	public:

		T data;
		RBTreeNode<T> *pLeft;
		RBTreeNode<T> *pRight;
		RBTreeNode<T> *pParent;
		Color color;

	};
除了多一个数据颜色以外，其他的定义和二叉搜索树是一样的。

操作：

正因为红黑树要求满足这五个性质，所以在构造插入节点的，和删除节点的过程中，都要动态局部修改树，使得性质得到继续的满足。

在插入的过程中，经常会遇到用左旋和右旋操作来改变树的结构，同时维持二叉搜索树的性质。

用一个图来说明左旋和右旋，图中是左旋，右旋是左旋的一个相反的过程。


其实要处理的包括三对指针域

例如旋转的是pNode和它的右孩子

则要修改pNode->Parent 的连接关系，pNode的父子关系，还有pNode右孩子的左孩子（14为根的那个子树）

相应的代码如下：

//left rotate
	//
	template<typename T>
	void RBTree<T>::left_rotate(RBTreeNode<T> *_pNode)
	{
		RBTreeNode<T> *pRightSon = _pNode->pRight;
		if(pRightSon == &nil)
		{
			return ;
		}
		//process the parent of _pNode
		if(_pNode->pParent != &nil)
		{
			if(_pNode->pParent->pLeft == _pNode)
			{
				_pNode->pParent->pLeft = pRightSon;
				pRightSon->pParent = _pNode->pParent;
			}
			else if(_pNode->pParent->pRight == _pNode)
			{
				_pNode->pParent->pRight = pRightSon;
				pRightSon->pParent = _pNode->pParent;
			}
		}
		//in this situation, parent of _pNode is the root
		else
		{
			m_pRoot = pRightSon;
			pRightSon->pParent = &nil;
		}



		RBTreeNode<T> *pTmp = _pNode->pLeft;

		pRightSon->pLeft = _pNode;
		_pNode->pParent = pRightSon;


		_pNode->pRight = pTmp;
		pTmp->pParent = _pNode;
	}
不难写出右旋代码。

在插入一个新节点的时候，和普通二叉搜索树一样，找到一个合适的位置插入。并且使得新的节点是红色，代码如下：

//insert a new node into the rb tree
	template<typename T>
	void RBTree<T>::insert(T data)
	{
		//create a new node
		RBTreeNode<T>* newNode = new RBTreeNode<T>(data);
		newNode->color = RED;
		newNode->pParent = newNode->pRight = newNode->pLeft = &nil;
	
		//if current tree is empty
		if(m_pRoot == NULL)
		{
			m_pRoot = newNode;
			m_pRoot -> color = BLACK;
			m_pRoot->pParent = &nil;
			return ;
		}
		//pNode for iterating
		//pInsert for insertions

		RBTreeNode<T> *pNode = m_pRoot;
		RBTreeNode<T> *pInsert = &nil;

		while(pNode != &nil)
		{
			if(data > pNode->data)
			{
				pInsert = pNode;
				pNode = pNode->pRight;
			}
			else if(data < pNode->data)
			{
				pInsert = pNode;
				pNode = pNode->pLeft;
			}
			else
			{
				return ;
			}
		}


		if(pInsert != &nil)
		{
			if(data > pInsert->data)
			{
				pInsert->pRight = newNode;
		
				
			}
			else
			{
				pInsert->pLeft = newNode;
	
			}
			newNode->pParent = pInsert;
			insert_fix_up(newNode);
		}
		

	}
但是这样一来，红黑树的性质就可能被破坏掉了。如果树种仅有一个节点，性质2被破坏，如果树中有多个节点，新插入的newNode的父亲如果是红色节点，这个时候性质4就被破坏了。实际中我们主要关注性质4被破坏，因为性质2 的破坏很容易修正，仅仅将根设为黑色即可，因为这样的操作不会破坏原有的任何性质。


如果newNode是红色，并且父亲是黑色的。很显然，性质不会破坏

只要父亲是红色的，则性质就不对。所以我们分析这个如何处理。

首先看newNode的叔叔节点，假如叔叔是红色的，这样的话，我们只要同时变化newNode的父亲和叔叔的颜色为黑色，同时设置爷爷为红色，则所有性质都可以保持。

但是如果叔叔是黑色的，则不能仅仅这样设置了，以为无论如何简单的改变颜色都会使得性质破坏掉。

所以这个时候正确的操作是先旋转在旋转。

代码如下：

template <typename T>
	void RBTree<T>::insert_fix_up(RBTreeNode<T> *_pNode)
	{
		RBTreeNode<T>* y;

		while(_pNode->pParent->color == RED)
		{
			if(_pNode->pParent == _pNode->pParent->pParent->pLeft)
			{
				y = _pNode->pParent;
				if(y->pParent->pRight->color == RED)
				{
					_pNode->pParent->pParent->pRight->color = BLACK;
					_pNode->pParent->color = BLACK;
					_pNode->pParent->pParent->color = RED;
					_pNode = _pNode->pParent->pParent;
				}
				else
				{
					if(_pNode->pParent->pRight == _pNode)
					{
						left_rotate(_pNode->pParent);
						y = _pNode;
						_pNode = _pNode->pParent;
					}

					y->color = BLACK;
					y->pParent->color = RED;
					right_rotate(y->pParent);
					_pNode = y;
					
				}
			
			}
			else if(_pNode->pParent == _pNode->pParent->pParent->pRight)
			{
				y = _pNode->pParent->pParent->pLeft;
				if(y ->color == RED)
				{
					_pNode->pParent->color = BLACK;
					_pNode->pParent->pParent->color = RED;

					y->color = BLACK;
					_pNode = _pNode->pParent->pParent;

				}
				else
				{
					y = _pNode->pParent;
					if(_pNode->pParent->pLeft == _pNode)
					{
						y = _pNode;
						_pNode = _pNode->pParent;
						right_rotate(_pNode);
					}
					y->color = BLACK;
					y->pParent->color = RED;
					left_rotate(y->pParent);
					_pNode = y;
				}
				
			}

		}
		m_pRoot->color = BLACK;

	}

完整模板代码：



#include <iostream>
#include <stack>

namespace DataStructure
{
	typedef enum{RED,BLACK} Color;

	template<typename T>
	class RBTreeNode
	{
	public:
		RBTreeNode()
		{
			pLeft = pRight = pParent = NULL;
		}
		RBTreeNode(T _data):data(_data)
		{
			pLeft = pRight = pParent = NULL;
		}

	public:

		T data;
		RBTreeNode<T> *pLeft;
		RBTreeNode<T> *pRight;
		RBTreeNode<T> *pParent;
		Color color;

	};

	/**
	*To be a r&b tree, several characteristics must be satisfied:
	* 1. for each node, it must be black or red
	* 2. root must be black
	* 3. leaf node must be black
	* 4. if one node is red, then two sons must be black
	* 5. for each node, from which to each leaf, you will get the same number of black nodes, 
	*/
	template<typename T>
	class RBTree
	{
	public:
		typedef T dateType;
		typedef RBTreeNode<T> nodeType;


	public:

		RBTree()
		{
			m_pRoot = NULL;
			nil.pParent = nil.pRight = nil.pLeft = NULL;
			nil.color = BLACK;
		}
		//insert a new node into the rb tree
		void insert(T data);

		//remove a node from the rb tree
		void remove(RBTreeNode<T> *_removeNode);

		//left rotate
		void left_rotate(RBTreeNode<T> *_pNode);

		//right rotate
		void right_rotate(RBTreeNode<T>* _pNode);

		//find the tree node
		RBTreeNode<T>* find(T _data)const;

		//print all elements
		void print_elements()const;

		//insert fix up
		void insert_fix_up(RBTreeNode<T> *_pNode);
		

	private:
		RBTreeNode<T> *m_pRoot;/*! the root of the R&B tree*/
		RBTreeNode<T> nil;
	
	};

	template<typename T>
	void RBTree<T>::print_elements()const
	{
		if(m_pRoot == NULL)
		{
			return ;
		}

		std::stack<RBTreeNode<T>*> nStack;
		
		nStack.push(m_pRoot);
		RBTreeNode<T> *tmp = m_pRoot;
		std::cout<<"All Elements"<<std::endl;

		while(!nStack.empty())
		{
			while(tmp != &nil)
			{
				tmp = tmp->pLeft;
				nStack.push(tmp);
			}

			nStack.pop();
			if(!nStack.empty())
			{
				tmp = nStack.top();
				nStack.pop();

				std::cout<<tmp->data<<std::endl;
				tmp = tmp->pRight;
				nStack.push(tmp);
			}
		}
	
	}
	//find the tree node
	template<typename T>
	RBTreeNode<T>* RBTree<T>::find(T _data)const
	{
		RBTreeNode<T>* pElement = m_pRoot;
		while(pElement != &nil && pElement->data != _data)
		{
			if(_data > pElement->data)
			{
				pElement = pElement->pRight;
			}
			else
			{
				pElement = pElement->pLeft;
			}
		}
		if(pElement != &nil)
		{
			return pElement;
		}
		return NULL;
	}

	//insert a new node into the rb tree
	template<typename T>
	void RBTree<T>::insert(T data)
	{
		//create a new node
		RBTreeNode<T>* newNode = new RBTreeNode<T>(data);
		newNode->color = RED;
		newNode->pParent = newNode->pRight = newNode->pLeft = &nil;
	
		//if current tree is empty
		if(m_pRoot == NULL)
		{
			m_pRoot = newNode;
			m_pRoot -> color = BLACK;
			m_pRoot->pParent = &nil;
			return ;
		}
		//pNode for iterating
		//pInsert for insertions

		RBTreeNode<T> *pNode = m_pRoot;
		RBTreeNode<T> *pInsert = &nil;

		while(pNode != &nil)
		{
			if(data > pNode->data)
			{
				pInsert = pNode;
				pNode = pNode->pRight;
			}
			else if(data < pNode->data)
			{
				pInsert = pNode;
				pNode = pNode->pLeft;
			}
			else
			{
				return ;
			}
		}


		if(pInsert != &nil)
		{
			if(data > pInsert->data)
			{
				pInsert->pRight = newNode;
		
				
			}
			else
			{
				pInsert->pLeft = newNode;
	
			}
			newNode->pParent = pInsert;
			insert_fix_up(newNode);
		}
		

	}
	template <typename T>
	void RBTree<T>::insert_fix_up(RBTreeNode<T> *_pNode)
	{
		RBTreeNode<T>* y;

		while(_pNode->pParent->color == RED)
		{
			if(_pNode->pParent == _pNode->pParent->pParent->pLeft)
			{
				y = _pNode->pParent;
				if(y->pParent->pRight->color == RED)
				{
					_pNode->pParent->pParent->pRight->color = BLACK;
					_pNode->pParent->color = BLACK;
					_pNode->pParent->pParent->color = RED;
					_pNode = _pNode->pParent->pParent;
				}
				else
				{
					if(_pNode->pParent->pRight == _pNode)
					{
						left_rotate(_pNode->pParent);
						y = _pNode;
						_pNode = _pNode->pParent;
					}

					y->color = BLACK;
					y->pParent->color = RED;
					right_rotate(y->pParent);
					_pNode = y;
					
				}
			
			}
			else if(_pNode->pParent == _pNode->pParent->pParent->pRight)
			{
				y = _pNode->pParent->pParent->pLeft;
				if(y ->color == RED)
				{
					_pNode->pParent->color = BLACK;
					_pNode->pParent->pParent->color = RED;

					y->color = BLACK;
					_pNode = _pNode->pParent->pParent;

				}
				else
				{
					y = _pNode->pParent;
					if(_pNode->pParent->pLeft == _pNode)
					{
						y = _pNode;
						_pNode = _pNode->pParent;
						right_rotate(_pNode);
					}
					y->color = BLACK;
					y->pParent->color = RED;
					left_rotate(y->pParent);
					_pNode = y;
				}
				
			}

		}
		m_pRoot->color = BLACK;

	}
	//remove a node from the rb tree
	template<typename T>
	void RBTree<T>::remove(RBTreeNode<T> *_removeNode)
	{

	}

	//left rotate
	//
	template<typename T>
	void RBTree<T>::left_rotate(RBTreeNode<T> *_pNode)
	{
		RBTreeNode<T> *pRightSon = _pNode->pRight;
		if(pRightSon == &nil)
		{
			return ;
		}
		//process the parent of _pNode
		if(_pNode->pParent != &nil)
		{
			if(_pNode->pParent->pLeft == _pNode)
			{
				_pNode->pParent->pLeft = pRightSon;
				pRightSon->pParent = _pNode->pParent;
			}
			else if(_pNode->pParent->pRight == _pNode)
			{
				_pNode->pParent->pRight = pRightSon;
				pRightSon->pParent = _pNode->pParent;
			}
		}
		//in this situation, parent of _pNode is the root
		else
		{
			m_pRoot = pRightSon;
			pRightSon->pParent = &nil;
		}



		RBTreeNode<T> *pTmp = _pNode->pLeft;

		pRightSon->pLeft = _pNode;
		_pNode->pParent = pRightSon;


		_pNode->pRight = pTmp;
		pTmp->pParent = _pNode;
	}

	//right rotate
	template<typename T>

	void RBTree<T>::right_rotate(RBTreeNode<T>* _pNode)
	{
		RBTreeNode<T> *pLeftSon = _pNode->pLeft;
		if(pLeftSon == &nil)
		{
			return ;
		}

		if(_pNode->pParent != &nil)
		{
			if(_pNode->pParent->pLeft == _pNode)
			{
				_pNode->pParent->pLeft = pLeftSon;
				pLeftSon->pParent = _pNode->pParent;

			}
			else
			{
				_pNode->pParent->pRight = pLeftSon;
				pLeftSon->pParent = _pNode->pParent;
			}
		}
		else
		{
			m_pRoot = pLeftSon;
			pLeftSon->pParent = &nil;
		}

		//process the parental relation between _pNode and pLeftSon
		RBTreeNode<T> *pTmp = pLeftSon->pRight;

		pLeftSon->pRight = _pNode;
		_pNode->pParent = pLeftSon;

		_pNode->pLeft = pTmp;
		pTmp->pParent = _pNode;
	}
}

文西
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树，红黑树，AVL平衡树，B树
05-08
完整实现二叉搜索树，红黑树，AVL平衡树，B树的搜索插入删除基本功能和其它功能。红黑树和B树参考自算法导论。
二叉搜索树-----红黑树
最新发布
qq_63943454的博客
08-26 440
红黑树也是一颗二叉搜索树，其作为map，set的底层容器，具有非常好的搜索性能，仅仅通过控制颜色和位置就能达到一种，近似平衡的效果，大大减少了旋转的次数。
二叉树——二叉查找树和红黑树
LengDanRan
08-10 1764
二叉树 二叉树，是一个非常重要的数据结构，在日常的开发中起着很重要的作用，它也衍生出来的各种高效的复杂的数据结构，为我们解决问题提供了高效的解决方案。 二叉树，它是由各个数据节点和左右链接构成的一种类似树的数据结构。一棵二叉树，我们只需要知道根节点，便可以访问到树中各个节点；同时树中的每一个节点，都有自身包装的数据和指向它的左右子节点的链接，如果不存在子节点，为null值，每一个节点（除去根节点）都有一个父亲节点。 节点（TreeNode）的数据结构 private class TreeNode {
数据结构之二叉查找树(Binary Search Tree)和红黑树(Red Black Tree)
刘跃辉的博客
09-23 5884
二叉查找树又可以称之为 : 二叉搜索树 , 二叉排序树 , 它或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势 , 下图中这棵树，就是一棵典型的二叉查找树。
二叉查找树和红黑树
梦的灰色边沿...
03-18 359
文章目录1 二叉查找树1.1 原理1.2 二叉查找树插入1.3 二叉查找树删除1.2 缺陷2 红黑树2.1 平衡树2.1.1 简介2.1.2 平衡性的维护2.1.2.1 LL(右单旋转)2.1.2.2 RR(左单旋转)2.1.2.3 LR平衡旋转(先左后右旋转)2.1.2.4 RL RL平衡旋转(先右后左旋转)2.2 2-3 查找平衡树2.2.1 简介2.2.2 2-3平衡树的插入2.2.2.1 ...
二叉树与红黑树见解
Ge_yangwen的博客
10-15 1521
红黑树是一种自平衡的二叉查找树，是一种高效的查找树。红黑树具有良好的效率，它可在 O(logN) 时间内完成查找、增加、删除等操作1。大家应该都学过平衡二叉树(AVLTree)，了解到AVL树的性质，其实平衡二叉树最大的作用就是查找,AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。AVL树的效率就是高在这个地方。如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状态就被破坏，它就不再是一棵二叉树；
PHP实现绘制二叉树图形显示功能详解【包括二叉搜索树、平衡树及红黑树】
12-19
最近老师布置了一个作业：理解并实现平衡二叉树和红黑树，本来老师是说用C#写的，但是我学的C#基本都还给老师了，怎么办？那就用现在最熟悉的语言PHP来写吧！ 有一个问题来了，书上在讲解树的时候基本上会给出形象的...
平衡搜索树包括平衡二叉搜索树和红黑树介绍
11-28
主要包含平衡搜索树中的平衡二叉搜索树红黑的介绍，代码嵌入其中
哈希表树：哈希表，二叉搜索树，红黑树，epoll，socket，tcp，udp，多进程，共享内存，原子操作，惊群，协议栈
02-26
BST哈希图（基于二叉搜索树实现）哈希表+二叉搜索树实现key => value数据存储与修改。特点：千万级键=>值数据，插入，查询，修改，删除几级实现。红黑树实现插入初始初始都为红色1，代表必须是红色或黑色。 2，根...
二叉查找树和红黑树（转载）
song_chengbo的博客
05-30 329
转载地址：https://mp.weixin.qq.com/s/-8JFh5iLr88XA4AJ9mMf6g ———————————— ———————————— 二叉查找树（BST）具备什么特性呢？ 1.左子树...
红黑树、二叉搜索树的实现和性能比较
03-12
实现红黑树、二叉搜索树相关算法：插入（红黑树涉及树的调整：左旋、右旋等），删除，搜索（指定Key值节点）。 另外，红黑树实现计算树黑高的算法。
红黑树、平衡二叉查找树
为了更好的未来_加油
05-19 1364
红黑树、平衡二叉查找树 非常常用的查找结构，各操作的时间复杂度与树的高度成正比
二叉查找树与红黑树 总结
相由心生的博客
08-03 290
一、二叉查找树 1、递归遍历一颗二叉查找树的时间复杂度： best：O(logn)     worst：O(n) 2、查询二叉查找树的时间复杂度： best：Olog(n)     worst：On 3、查找前驱和后继的时间复杂度： 一般说前驱或后继是指在中序遍历下的。 时间复杂度是O(logn) 4、插入和删除元素 插入：时间复杂度 O(logn) 删除：删除的元素为z; ...
二叉搜索树和红黑树
weixin_30823001的博客
11-29 144
二叉搜索树的结构： typedef int ElemType; typedef struct SearchBiTree { ElemType Data; struct SearchBiTree *LChild,*RChild,*Parent; }SearchBiTree,*PSearchBiTree; 二叉搜索树的性质： 设 x 是二叉搜索树中的一个节点。如...
红黑树和二叉查找树
weixin_44280356的博客
11-26 577
https://www.bilibili.com/video/BV1tE411f7tP?p=1 本博客根据图灵诸葛老师的讲的，把自己的理解写出来。 查找算法有哪些 要想理解红黑树，首先要理解查找算法有哪些 暴力，就是利用for循环，比如循环遍历链表 二分查找，注意一定要有序才能进行二分查找 哈希，最高效，时间复杂度为O（1）。但是容易产生hash冲突，hashmap就是利用了hash查找，JDK1.8之后，hashmap结构为数组+链表+红黑树（链表长度大于8） 索引 平衡树 B+树 B-tree 红黑
二叉搜索树、平衡二叉搜索树和红黑树
Hansry的博客
11-27 1419
一. 二叉搜索树（Binary Sort Tree） 二叉搜索树，又称为二叉排序树（二叉查找树），它或许是一棵空树，或许是具有一下性质的二叉树： 1.若它的左子树不为空，则左子树上所有的节点的值小于根节点的值 2.若它的右子树不为空，则右子树上所有的节点的值都大于根节点的值 3.它的左右子树也分别是二叉搜索树 二叉搜索树的这种特性，使得我们在此二叉树上查找某个值就很方便了，从根节点开始，若要寻...
二叉查找树BST和红黑树，果然。。。
兴华的博客
11-04 1605
红黑树是一种可以自平衡的二叉查找树；
种树：二叉树、二叉搜索树、AVL树、红黑树、哈夫曼树、B树、树与森林
热门推荐
看，未来的博客
07-11 4万+
虽然今天不是植树节，但是我今天想种树。 文章目录树，什么是树？二叉树定义二叉树的创建二叉树的前中后序遍历前序遍历：中序遍历后序遍历已知前序、中序遍历结果，还原二叉树已知后序、中序遍历结果，还原二叉树二叉树的层序遍历二叉搜索树二叉搜索树是什么？构造二叉搜索树代码实现：平衡二叉搜索树（AVL树）什么是平衡二叉搜索树？AVL树的节点数据结构AVL树构造左旋右旋双旋转新增节点（背多分）LL(右旋)RR(左旋)LRRL插入节点 树，什么是树？ 树是我们计算机中非常重要的一种数据结构，同时使用树这种数据结构，可以..
二叉查找树、平衡树与红黑树关系
Daniel_Wu1的博客
03-20 333
虽然平衡树解决了二叉查找树退化为近似链表的缺点，能够把查找时间控制在 O(logn)，不过却不是最佳的，因为平衡树要求每个节点的左子树和右子树的高度差至多等于1，这个要求实在是太严了，导致每次进行插入/删除节点的时候，几乎都会破坏平衡树的第二个规则，进而我们都需要通过左旋和右旋来进行调整，使之再次成为一颗符合要求的平衡树。 显然，如果在那种插入、删除很频繁的场景中，平衡树需要频繁着进行...
对比红黑树和二叉搜索树
05-03
红黑树和二叉搜索树都是常用的数据结构，用于实现动态集合（Dynamic Sets）的操作。但是它们在性质上有很大的差别。 1. 插入和删除操作 二叉搜索树的插入和删除操作比红黑树简单，因为它不需要维护任何颜色属性。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值