AVL树和红黑树

已于 2024-04-03 09:08:02 修改
阅读量651 收藏 23
点赞数 14
文章标签： c++
于 2024-04-02 20:50:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74494481/article/details/136923254
版权

AVL树和红黑树

  • AVL树
    • 理论
    • 代码实现
  • 红黑树
    • 理论
    • 代码实现

AVL树

理论

我们知道二叉搜索树拥有极高的搜索效率，但当二叉搜索树退化成单支时，其查找效率会大幅下降，因此我们需要避免其出现单支的情况，并且尽可能让其接近满二叉树。解决办法是每次插入一个新结点时，都要保证所有结点的左右子树高度差都不能超过1，倘若新结点插入导致某颗子树左右子树的高度差超过1，就需要进行旋转处理，这样处理后的树称之为AVL树，可以保证其高度不会过高，其查找的时间复杂度的数量级为log(n)。

我们需要在每一个结点中增加一个变量bf以记录该结点的左右子树高度差（称之为平衡因子，一般是用右子树高度减去左子树高度的差作为平衡因子，AVL树中其值只能为-1，0，1）。当我们插入的新结点时，需要对从插入结点到根结点路径上的平衡因子进行调整，调整方法为：左子树高度增加，则当前结点平衡因子减1，右子树高度增加，则当前结点平衡因子加1，接着对其父结点也进行以上操作，直至根结点或者某个祖先结点的平衡因子变为0为止（当前结点平衡因子变为0说明新结点的插入并不影响以当前结点为根的子树的高度，那么自然就不会影响其到根结点路径上的祖先结点的平衡因子）。
倘若调整平衡因子过程中某个结点g的平衡因子变为了-2或者2，则需要进行旋转处理以合理调整树的高度，旋转的情况分为以下4种：

①g的左孩子为p，新插入结点c在p的左子树中
在这里插入图片描述

这种情况需要进行以g为根结点进行右单旋，具体步骤为：先将g的左孩子指向改为子树h2，h2子树的根结点的父亲指向改为指向g（如果子树h2存在的话），接着将p的左孩子指向改为指向g，p的父亲指向改为指向g指向的父结点，最后将g的父亲结点指向g的孩子指向改为指向p（如果g的父亲结点存在的话），g的父亲指向改为指向p。
在这里插入图片描述

此时p的平衡因子必定为0，调整后以p为根结点的子树的高度与插入结点前以g为根结点的子树高度相比并无变化，因此从p结点到根结点路径上面的祖先结点的平衡因子不需要再进行调整。

②g的右孩子为p，新插入结点c在p的右子树中
在这里插入图片描述

这种情况我们需要以g为根结点进行左单旋，具体步骤为：先将g的右孩子指向改为指向子树h2，再将h2的根结点的父亲指向改为指向g（如果子树h2不为空），接着将p的左孩子指向改为指向g，p的父亲指向改为指向g指向的父亲结点，最后将的父结点指向g的孩子指向改为指向p，g的父亲指向改为指向p。
在这里插入图片描述

此时p的平衡因子也必定为0，调整后以p为根结点的子树的高度与插入结点前以g为根结点的子树高度相比也无变化，因此从p结点到根结点路径上面的祖先结点的平衡因子也不需要再进行调整。

③g的左孩子为p，新插入结点c在p的右子树中
在这里插入图片描述

这种情况我们需要进行左右双旋，具体做法为：
1.以p结点为根结点进行左单旋
2.以g结点为根结点进行右单旋
在这里插入图片描述

此时结点t的平衡因子也必定为0，调整后以p为根结点的子树的高度与插入结点前以g为根结点的子树高度相比并无变化，因此从p结点到根结点路径上面的祖先结点的平衡因子不需要再进行调整。

④g的右孩子为p，新插入结点c在p的左子树中
在这里插入图片描述

这种情况我们需要进行右左双旋，具体做法为：
1.以p结点为根结点进行右单旋
2.以g结点为根结点进行左单旋
在这里插入图片描述

此时结点t的平衡因子也必定为0，调整后以p为根结点的子树的高度与插入结点前以g为根结点的子树高度相比并无变化，因此从p结点到根结点路径上面的祖先结点的平衡因子不需要再进行调整。

AVL树结点的删除我们不进行讨论，可以知道其结点的删除最坏情况下需要进行树的高度次的旋转，因此AVL树适用于数据是静态的情况，如果结构需要经常修改，AVL树就不太适用了。

代码实现

template<class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& data = T())
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _bf(0)
	{}

	AVLTreeNode<T>* _left;
	AVLTreeNode<T>* _right;
	AVLTreeNode<T>* _parent;
	T _data;
	int _bf;   // 节点的平衡因子
};

template<class T>
class AVLTree
{
	typedef AVLTreeNode<T> Node;
public:
	AVLTree()
		: _root(nullptr)
	{}
	
	// 在AVL树中插入值为data的节点
	bool Insert(const T& data)
	{
		Node* cur = new Node(data);
		if (nullptr == _root)
		{
			_root = cur;
			return true;
		}
		Node* tmp = _root;
		Node* parent = nullptr;
		
		//插入
		while (tmp)
		{
			parent = tmp;
			if (cur->_data > tmp->_data)
			{
				tmp = tmp->_right;
			}
			else if (cur->_data < tmp->_data)
			{
				tmp = tmp->_left;
			}
			else
			{
				return false;
			}
		}
		if (cur->_data > parent->_data)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		//调整平衡因子
		parent = cur;
		Node* grandpa = parent->_parent;
		while (grandpa)
		{
			if (parent == grandpa->_left)
			{
				--grandpa->_bf;
			}
			else
			{
				++grandpa->_bf;
			}

			if (2 == grandpa->_bf || -2 == grandpa->_bf)//旋转
			{
				if (parent == grandpa->_left && cur == parent->_left)
				{
					//右单旋
					RotateR(grandpa);
				}
				else if (parent == grandpa->_right && cur == parent->_right)
				{
					//左单旋
					RotateL(grandpa);
				}
				else if (parent == grandpa->_left && cur == parent->_right)
				{
					//左右双旋
					RotateLR(grandpa);
				}
				else if (parent == grandpa->_right && cur == parent->_left)
				{
					//右左双旋
					RotateRL(grandpa);
				}
				break;
			}
			else if (0 == grandpa->_bf)
			{
				break;
			}

			cur = parent;
			parent = grandpa;
			grandpa = grandpa->_parent;
		}

		return true;
	}

private:
	// 右单旋
	void RotateR(Node* parent)
	{
		Node* left_child = parent->_left;
		parent->_left = left_child->_right;
		if (left_child->_right)
		{
			left_child->_right->_parent = parent;
		}
		left_child->_right = parent;
		left_child->_parent = parent->_parent;
		if (parent->_parent)
		{
			if (parent->_parent->_left == parent)
			{
				//parent为其父结点的左孩子
				parent->_parent->_left = left_child;
			}
			else
			{
				//parent为其父结点的右孩子
				parent->_parent->_right = left_child;
			}
		}
		parent->_parent = left_child;

		if (_root == parent)
		{
			_root = left_child;
		}
		
		//调整平衡因子
		left_child->_bf = 0;
		parent->_bf = 0;
	}

	// 左单旋
	void RotateL(Node* parent)
	{
		Node* right_child = parent->_right;
		parent->_right = right_child->_left;
		if (right_child->_left)
		{
			right_child->_left->_parent = parent;
		}
		right_child->_left = parent;
		right_child->_parent = parent->_parent;
		if (parent->_parent)
		{
			if (parent->_parent->_left == parent)
			{
				//parent为其父结点的左孩子
				parent->_parent->_left = right_child;
			}
			else
			{
				//parent为其父结点的右孩子
				parent->_parent->_right = right_child;
			}
		}
		parent->_parent = right_child;

		if (_root == parent)
		{
			_root = right_child;
		}
		
		//调整平衡因子
		right_child->_bf = 0;
		parent->_bf = 0;
	}

	// 左右双旋
	void RotateLR(Node* parent)
	{
		int pLR_bf = parent->_left->_right->_bf;
		RotateL(parent->_left);
		RotateR(parent);

		//调整平衡因子
		if (1 == pLR_bf)
		{
			parent->_bf = 0;
			parent->_parent->_bf = 0;
			parent->_parent->_left->_bf = -1;
		}
		else if (-1 == pLR_bf)
		{
			parent->_bf = 1;
			parent->_parent->_bf = 0;
			parent->_parent->_left->_bf = 0;
		}
		else if (0 == pLR_bf)
		{
			parent->_bf = 0;
			parent->_parent->_bf = 0;
			parent->_parent->_left->_bf = 0;
		}

	}

	// 右左双旋
	void RotateRL(Node* parent)
	{
		int pLR_bf = parent->_right->_left->_bf;
		RotateR(parent->_right);
		RotateL(parent);

		//调整平衡因子
		if (1 == pLR_bf)
		{
			parent->_bf = -1;
			parent->_parent->_bf = 0;
			parent->_parent->_right->_bf = 0;
		}
		else if (-1 == pLR_bf)
		{
			parent->_bf = 0;
			parent->_parent->_bf = 0;
			parent->_parent->_right->_bf = 1;
		}
		else if (0 == pLR_bf)
		{
			parent->_bf = 0;
			parent->_parent->_bf = 0;
			parent->_parent->_right->_bf = 0;
		}
	}

private:
	Node* _root;
};

红黑树

理论

红黑树通过颜色来控制树的高度，可以保证树的最大高度不会超过最小高度的2倍，其结点的颜色由以下规则来约束：
1.每个结点不是红色就是黑色
2.空节点可以看做是黑色结点
3.根结点是黑色的
4.一条路径上不能存在连续的红色结点（即如果当前结点是红色结点，那么其父亲结点和左右孩子结点必定是黑色的）
5.从根结点到叶子结点的每条路径上的黑色结点个数相同

由以上规则可知，红黑树的最小高度路径是该路径上的所有结点都是黑色的，最大高度路径是该路径上黑色和红色结点交替出现，这样就可以保证树的最大高度不会超过最小高度的2倍。

因此，只要遵循以上规则，红黑树的高度就可以保证。

我们需要在每个结点中增加一个变量color记录当前结点的颜色，在进行插入时，新插入的结点的颜色是红色，如果新插入结点的父结点的颜色是黑色的，则红黑树不需要进行任何调整，否则就需要调整。用c表示当前结点，p表示c的父亲结点，g表示c的祖父结点，u表示c的叔叔结点，其需要进行调整情况可以粗分为以下2种（细分5种)：

  1. u存在且为红色结点
    我们只需要将p结点和u结点改为黑色，g改为红色，那么就可保证以g为根结点的子树必定遵循以上规则，接着将g赋给c，然后继续往上更新调整，直至不再出现连续红色结点或到根结点为止，如果更新到了根结点，我们最后必须让根结点变为黑色。
    在这里插入图片描述

  2. u为空结点或u为黑色结点
    ①c是p的左孩子，p是g左孩子
    我们只需要以g为根结点进行一次右单旋，然后将p结点改成黑色，g结点改成红色，就一定可以保证整棵树依旧是红黑树，不必再往上调整。
    在这里插入图片描述

    ②c是p的右孩子，p是g右孩子
    我们只需要以g为根结点进行一次左单旋，然后将p结点改成黑色，g结点改成红色，就一定可以保证整棵树依旧是红黑树，不必再往上调整。
    在这里插入图片描述

    ③c是p的右孩子，p是g左孩子
    我们只需要以p为根结点进行一次左单旋，然后以g为根结点进行一次右单旋，再将c结点改成黑色，g结点改成红色，就一定可以保证整棵树依旧是红黑树，不必再往上调整。在这里插入图片描述

    ④c是p的左孩子，p是g右孩子
    我们只需要以p为根结点进行一次右单旋，然后以g为根结点进行一次左单旋，再将c结点改成黑色，g结点改成红色，就一定可以保证整棵树依旧是红黑树，不必再往上调整。
    在这里插入图片描述
    红黑树结点的删除这里也不进行讨论。尽管红黑树的高度比AVL树高，但其在查找过程中性能与AVL树在同一个数量级上，为log(n)，且相比较于AVL树，红黑树降低了插入删除时旋转的次数，因此在经常增删的结构中红黑树的性能更优一点。

代码实现

enum Color
{
	red,
	black
};

template<class T>
struct RBTreeNode
{
	RBTreeNode(const T& data = T())
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _color(red)
	{}

	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data;
	Color _color;  // 节点颜色
};

template<class T>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	RBTree()
		:_root(nullptr)
	{}

	// 注意：为了简单起见，实现的红黑树不存储重复性元素
	bool Insert(const T& data)
	{
		//节点插入
		Node* newNode = new  Node(data);
		if (_root == nullptr)
		{
			_root = newNode;
			return true;
		}

		Node* cur = _root;
		while (cur)
		{
			if (data > cur->_data && cur->_right)
			{
				cur = cur->_right;
			}
			else if (data < cur->_data && cur->_left)
			{
				cur = cur->_left;
			}
			else if (data == cur->_data)
			{
				return false;
			}
			else
			{
				break;
			}
		}
		if (data > cur->_data)
		{
			cur->_right = newNode;
		}
		else
		{
			cur->_left = newNode;
		}
		newNode->_parent = cur;

		//节点调整
		Node* grandpa =cur->_parent;
		Node* parent = cur;
		cur = newNode;
		while (nullptr!=grandpa)
		{
			if (black == parent->_color)
			{
				//cur节点的父节点为黑色，无需调整
				return true;
			}
			Node* uncle = grandpa->_right;
			if (parent == uncle)
			{
				uncle = grandpa->_left;
			}

			if (uncle && red == uncle->_color)
			{
				//叔叔节点存在且为红色
				uncle->_color = black;
				parent->_color = black;
				grandpa->_color = red;

				cur = grandpa;
				if (cur == _root)
				{
					//如若cur已经是根节点，要将其修改为黑色
					cur->_color = black;
					break;
				}
			}
			else
			{
				//叔叔节点不存在或者叔叔节点为黑色
				if (parent == grandpa->_left && cur == parent->_left)
				{
					//右单旋
					RotateR(grandpa);
				}
				else if (parent == grandpa->_right && cur == parent->_right)
				{
					//左单旋
					RotateL(grandpa);
				}
				else if (parent == grandpa->_left && cur == parent->_right)
				{
					//左右双旋
					RotateLR(grandpa);
				}
				else if (parent == grandpa->_right && cur == parent->_left)
				{
					//右左双旋
					RotateRL(grandpa);
				}
				else
				{
					cout << "节点插入出错" << endl;
					exit(-1);
				}

				break;
			}

			parent = cur->_parent;
			grandpa = parent->_parent;
		}
	}
	
private:
	// 左单旋
	void RotateL(Node* grandpa)
	{
		//调整节点颜色
		grandpa->_color = red;
		grandpa->_right->_color = black;

		//节点旋转
		Node* right_child = grandpa->_right;
		grandpa->_right = right_child->_left;
		if (right_child->_left)
		{
			right_child->_left->_parent = grandpa;
		}
		right_child->_left = grandpa;
		right_child->_parent = grandpa->_parent;
		if (grandpa->_parent)
		{
			if (grandpa->_parent->_left == grandpa)
			{
				//parent为其父结点的左孩子
				grandpa->_parent->_left = right_child;
			}
			else
			{
				//parent为其父结点的右孩子
				grandpa->_parent->_right = right_child;
			}
		}
		grandpa->_parent = right_child;

		if (_root == grandpa)
		{
			_root = right_child;
		}
	}

	// 右单旋
	void RotateR(Node* grandpa)
	{
		//调整节点颜色
		grandpa->_color = red;
		grandpa->_left->_color = black;

		//旋转节点
		Node* left_child = grandpa->_left;
		grandpa->_left = left_child->_right;
		if (left_child->_right)
		{
			left_child->_right->_parent = grandpa;
		}
		left_child->_right = grandpa;
		left_child->_parent = grandpa->_parent;
		if (grandpa->_parent)
		{
			if (grandpa->_parent->_left == grandpa)
			{
				//grandpa为其父结点的左孩子
				grandpa->_parent->_left = left_child;
			}
			else
			{
				//grandpa为其父结点的右孩子
				grandpa->_parent->_right = left_child;
			}
		}
		grandpa->_parent = left_child;

		if (_root == grandpa)
		{
			_root = left_child;
		}
	}

	//左右双旋
	void RotateLR(Node* grandpa)
	{
		//调整节点颜色
		grandpa->_color = red;
		grandpa->_left->_right->_color = black;

		//旋转
		RotateL(grandpa->_left);
		RotateR(grandpa);
	}

	//右左双旋
	void RotateRL(Node* grandpa)
	{
		//调整节点颜色
		grandpa->_color = red;
		grandpa->_right->_left->_color = black;

		//旋转
		RotateR(grandpa->_right);
		RotateL(grandpa);
	}

private:
	Node* _root;
};
黑眼圈的小熊猫
关注
  • 14
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构：（四）avl树和红黑树
无
06-05 1071
AVL树和红黑树
AVL 树和红黑树
耕耘
10-24 182
AVL 树和红黑树比较
AVL树和红黑树区别
热门推荐
后台开发
08-28 1万+
二叉查找树： 二叉查找树就是左结点小于根节点，右结点大于根节点的一种排序树，也叫二叉搜索树。也叫BST。二叉查找树比普通树查找更快，查找、插入、删除的时间复杂度为O（logN）。但是二叉查找树有一种极端的情况，就是会变成一种线性链表似的结构。此时时间复杂度就变味了O（N）。(为了解决这种情况，出现了二叉平衡树) 平衡二叉树： 平衡二叉树全称平衡二叉搜索树，也叫AVL树。是一种自平衡的树。 AVL树也规定了左结点小于根节点，右结点大于根节点。并且还规定了左子树和右子树的高度差不得超过1。这样保证.
红黑树和AVL树
TABE_的博客
04-26 4198
一，AVL树（平衡二叉树） （1）简介 AVL树是带有平衡条件的二叉查找树，一般是用平衡因子差值判断是否平衡并通过旋转来实现平衡，左右子树树高不超过1，和红黑树相比，AVL树是严格的平衡二叉树，平衡条件必须满足（所有节点的左右子树高度差的绝对值不超过1）。不管我们是执行插入还是删除操作，只要不满足上面的条件，就要通过旋转来保持平衡，而旋转是非常耗时的，由此我们可以知道AVL树适合用于插入与删除次数比较少，但查找多的情况。 （2）局限性 由于维护这种高度平衡所付出的代价比从中获得的效率收益还大，故而实际的应用
初识AVL树和红黑树
hxt的博客
12-02 254
一、平衡二叉查找树 二叉查找树支持快速插入、删除、查找操作，各个操作的时间复杂度跟树的高度成正比。而平衡二叉查找树是为了解决普通二叉查找树在频繁的插入、删除等动态更新的情况下，出现时间复杂度退化的问题 平衡二叉查找树中平衡的意思，其实就是让整棵树左右看起来比较对称、比较平衡，不要出现左子树很高、右子树很矮的情况。这样就能让整棵树的高度相对来说低一些，相应的插入、删除、查找等操作的效率高一些 平衡二...
红黑树与AVL树
qq_38769551的博客
09-13 530
一、在理解红黑树之前，我们先看一下二叉查找树 由于红黑树本质上就是一棵二叉查找树，所以在了解红黑树之前，咱们先来看下二叉查找树。 二叉查找树特性： 1、左子树上所有的节点的值都小于或等于他的根节点上的值 2、右子树上所有节点的值均大于或等于他的根节点的值 3、左、右子树也分别为二叉查找树 如图： 可以看到如果要查询10的话，10>9 因此到他的右子树，右子树根节点为13，10<1...
DS进阶：AVL树和红黑树
weixin_51142926的博客
04-24 2092
二叉搜索树（BST）虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。 而AVL树的平衡太过严格，导致维护效率很低，因此红黑树应运而生！！
【数据结构】 AVL树与红黑树
leijie1123的博客
11-13 2527
AVL树与红黑树的学习，以及其插入原理与插入的实现
详解set/map的底层结构——AVL树和红黑树
zcxmjw的博客
05-12 1038
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。AVL树的规则如下1.它的左右子树都是AVL树2.左右子树高度之差(这里我们简称为平衡因子)的绝对值不超过1如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在logN，搜索时间复杂度logN。
LengendOfDong#Blog#AVL树和红黑树的区别1
07-25
（1）AVL以及红黑树是高度平衡的树数据结构 （2）两种实现都缩放为O(lg N)，其中N是叶子的数量，但实际上AVL树在查找密集型任务上更快：利用更好的平衡，
AVL树和红黑树的性质与实现
AVL树和红黑树就是其中两种常用的自平衡二叉搜索树。 ## 2. 目的与意义 本文旨在介绍AVL树和红黑树的性质与实现原理。首先将详细说明AVL树的定义、性质以及插入和删除操作。然后，我们将深入探讨红黑树的定义、...
avl树和红黑树的区别
08-12
AVL树和红黑树都是自平衡二叉搜索树，它们在维护平衡性方面有一些不同之处： 1. 平衡性维护： - AVL树：通过在每个节点上存储平衡因子（左子树高度减去右子树高度）来维护平衡。当插入或删除节点后，AVL树可能需要...
【C++】链表
qq_38801607的博客
08-22 575
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
最新发布
lly202406的博客
08-25 489
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1331
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
c语言用if语句制作点单程序
2301_81968528的博客
08-20 308
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
初识顺序表---C语言
weixin_74202161的博客
08-23 349
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
Dijkstra(c++)
weixin_73378557的博客
08-24 496
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。同时dijkstra算法主要用于解决单源最短路问题（边权为正数），其可以分为两种版本，两种版本各有用处，并不存在好坏之分，接下来我们用n代表点的数量，用m代表边的数量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值