红黑树的插入

已于 2024-08-12 13:17:44 修改
阅读量314 收藏 8
点赞数 6
分类专栏： c++ 算法 文章标签： 算法 c++
于 2024-08-12 13:06:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suinnn/article/details/141128708
版权
c++ 同时被 2 个专栏收录
21 篇文章 0 订阅
订阅专栏
算法
2 篇文章 0 订阅
订阅专栏

文章目录

3.红黑树

3.1概念

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

image-20240730115620218

3.2 性质

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的, 说明树里面不能出现连续的红色节点
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点), 这个性质是为了方便数树有几条路径

问题: 为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

解答: 根据性质3和性质4可知, 如果有一颗红黑树, 那么它的最短路径应是全黑节点, 最长路径应是一红一黑节点交替
于是, 我们可以得到一个结论, 假设每条路径有N个黑色节点, 那么每条路径的节点个数为[N, 2N]. 这样就满足了问题红黑树的特征, 即
最长路径中节点个数不会超过最短路径节点个数的两倍

3.3 RBTree的实现

3.3.1 insert的框架

与前面的avl树类似

#pragma once
enum Color
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode(const pair<K, V>& kv) : _kv(kv), _left(nullptr)
		, _right(nullptr), _parent(nullptr), _bf(RED) {}

	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	Color _color;
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool insert(const pair<K, V>& kv)
	{
		// a. 树为空，则直接新增节点，赋值给root指针
		if (_root == nullptr) {
			_root = new Node(kv);
			// 根节点是黑色的
			_root->_color = BLACK;
			return true;
		}
		// b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
		Node* cur = _root, * parent = nullptr;
		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 = new Node(kv);
		// cur->_color = ?? 
		if (kv.first < parent->_kv.first) {
			parent->_left = cur;
			cur->_parent = parent;
		}
		else {
			parent->_right = cur;
			cur->_parent = parent;
		}

		// new code....

		return true;
	}
private:
	Node* _root = nullptr;
};

3.3.2 insert的处理

新增节点, 选择红色, 因为黑色会影响其他路径

  1. 新增节点的父亲是黑色的, 不需要处理
  2. 新增节点的父亲是红色的, 需要处理
    (变色)or(变色+旋转)

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

情况1: cur为红，p为红，g为黑， u 存在且为红 \textcolor{red}{u存在且为红} u存在且为红

image-20240731121943681

while (parent && parent->_color == RED) {
	Node* grandparent = parent->_parent;
	if (parent == grandparent->_left) {
		Node* uncle = grandparent->_right;
		// uncle存在且为红, 情况1
		if (uncle && uncle->_color == RED) {
			//        g(b)
			//     p(r)  u(r)
			//  c(r)
			// 变色
			parent->_color = uncle->_color = BLACK;
			grandparent->_color = RED;
			// 继续向上处理
			cur = grandparent;
			parent = cur->_parent;
		}
	}
}
// 处理后_root可能会变色, 在这里它置为黑色
_root = BLACK;

​

情况2:cur为红，p为红，g为黑， u 不存在 / u 存在且为黑 \textcolor{red}{u不存在/u存在且为黑} u不存在/u存在且为黑

image-20240805162910573

while (parent && parent->_color == RED) {
	Node* grandparent = parent->_parent;
	if (parent == grandparent->_left) {
		Node* uncle = grandparent->_right;
		// uncle存在且为红, 情况1
		if (uncle && uncle->_color == RED) {
			//        g(b)
			//     p(r)  u(r)
			//  c(r)
			// 变色
			parent->_color = uncle->_color = BLACK;
			grandparent->_color = RED;
			// 继续向上处理
			cur = grandparent;
			parent = cur->_parent;
		}
		// uncle为黑或者不存在
		else {
			// cur在parent的左边, 情况2, 单旋
			if (cur = parent->_left) {
				//        g(b)
				//     p(r)  u(b)
				//  c(r)
				RotateR(grandparent);
				parent->_color = BLACK;
				grandparent->_color = RED;
			}
			break;
		}
	}
}
// 处理后_root可能会变色, 在这里它置为黑色
_root = BLACK;

情况3:cur为红，p为红，g为黑， u 不存在 / u 存在且为黑 \textcolor{red}{u不存在/u存在且为黑} u不存在/u存在且为黑, cur的位置与前面不同

image-20240805171707446

while (parent && parent->_color == RED) {
	Node* grandparent = parent->_parent;
	if (parent == grandparent->_left) {
		Node* uncle = grandparent->_right;
		// uncle存在且为红, 情况1
		if (uncle && uncle->_color == RED) {
			//        g(b)
			//     p(r)  u(r)
			//  c(r)
			// 变色
			parent->_color = uncle->_color = BLACK;
			grandparent->_color = RED;
			// 继续向上处理
			cur = grandparent;
			parent = cur->_parent;
		}
		// uncle为黑或者不存在
		else {
			// cur在parent的左边, 情况2, 单旋
			if (cur = parent->_left) {
				//        g(b)
				//     p(r)  u(b)
				//  c(r)
				RotateR(grandparent);
				parent->_color = BLACK;
				grandparent->_color = RED;
			}
            // cur在parent的右边, 情况3, 双旋
            else {
                //         g(b)
                //     p(r)    u(b)
                //		   c(r)
                RotateL(parent);
                RotateR(grandparent);
                cur->_color = BLACK;
                grandparent->_color = RED;
            }
			break;
		}
	}
}
// 处理后_root可能会变色, 在这里它置为黑色
_root = BLACK;

完善else条件

while (parent && parent->_color == RED) {
	Node* grandparent = parent->_parent;
	if (parent == grandparent->_left) {
		Node* uncle = grandparent->_right;
		// uncle存在且为红, 情况1
		if (uncle && uncle->_color == RED) {
			//        g(b)
			//     p(r)  u(r)
			//  c(r)
			// 变色
			parent->_color = uncle->_color = BLACK;
			grandparent->_color = RED;
			// 继续向上处理
			cur = grandparent;
			parent = cur->_parent;
		}
		// uncle为黑或者不存在
		else {
			// cur在parent的左边, 情况2, 单旋
			if (cur = parent->_left) {
				//        g(b)
				//     p(r)  u(b)
				//  c(r)
				RotateR(grandparent);
				parent->_color = BLACK;
				grandparent->_color = RED;
			}
			// cur在parent的右边, 情况3, 双旋
			else {
				//         g(b)
				//     p(r)    u(b)
				//		   c(r)
				RotateL(parent);
				RotateR(grandparent);
				cur->_color = BLACK;
				grandparent->_color = RED;
			}
			break;
		}
	}
	// parent == grandparent->_right
	else {
		// uncle存在且为红, 情况1
		if (uncle && uncle->_color == RED) {
			//        g(b)
			//    u(r)   p(r)
			//               c(r)
			// 变色
			parent->_color = uncle->_color = BLACK;
			grandparent->_color = RED;
			// 继续向上处理
			cur = grandparent;
			parent = cur->_parent;
		}
		// uncle为黑或者不存在
		else {
			// cur在parent的右边, 情况2, 单旋
			if (cur = parent->_right) {
				//        g(b)
				//     u(b)  p(r)
				//			      c(r)
				RotateL(grandparent);
				parent->_color = BLACK;
				grandparent->_color = RED;
			}
			// cur在parent的右边, 情况3, 双旋
			else {
				//         g(b)
				//     u(r)    p(b)
				//		   c(r)
				RotateR(parent);
				RotateL(grandparent);
				cur->_color = BLACK;
				grandparent->_color = RED;
			}
			break;
		}
	}
}
// 处理后_root可能会变色, 在这里它置为黑色
_root = BLACK;
return true;

3.3.3 中序遍历

void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
void _InOrder(Node* root)
{
	if (root == nullptr)	return;
	_InOrder(root->_left);
	cout << root->_kv.first << ' ';
	_InOrder(root->_right);
}

3.3.4检查是否平衡和获取树的高度

bool IsBalance()
{
	if (_root == nullptr)	return true;
	// 违反规则2
	if (_root->_color == RED)	return false;

	int refVal = 0;		// 参考值, 记录某一条路径上的黑色节点的数量
	Node* cur = _root;
	while (cur) {
		if (cur->_color == BLACK)
			refVal++;
		cur = cur->_left;
	}
	int blackNum = 0;

	return Check(_root, refVal, blackNum);
}

bool Check(Node* root, const int& refVal, int blackNum)
{
	if (root == nullptr) { 
		// cout << blackNum << endl;
		if(blackNum == refVal)
			return true; 
		else {
			cout << "有路径黑色节点数量不一致" << endl;
			return false;
		}
	}
	if (root->_color == BLACK)	blackNum++;
	if (root->_color == RED && root->_parent->_color == RED) {
		// 违反规则3
		cout << "有连续的红色节点" << endl;
		return false;
	}
	
	return Check(root->_left, refVal, blackNum) 
		&& Check(root->_right, refVal, blackNum);
}

int GetHeight()
{
	return _GetHeight(_root);
}
int _GetHeight(Node* root)
{
	if (root == nullptr)	return 0;
	int left = _GetHeight(root->_left);
	int right = _GetHeight(root->_right);
	return left > right ? left + 1 : right + 1;
}

3.4完整代码

#pragma once
#include <iostream>
#include <vector>
using namespace std;
enum Color
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode(const pair<K, V>& kv) : _kv(kv), _left(nullptr)
		, _right(nullptr), _parent(nullptr), _color(RED) {}

	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	Color _color;
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool insert(const pair<K, V>& kv)
	{
		// a. 树为空，则直接新增节点，赋值给root指针
		if (_root == nullptr) {
			_root = new Node(kv);
			// 根节点是黑色的
			_root->_color = BLACK;
			return true;
		}
		// b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
		Node* cur = _root, *parent = nullptr;
		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 = new Node(kv);
		cur->_color = RED;		// 新增节点给红色
		if (parent->_kv.first < kv.first) {
			parent->_right = cur;
			cur->_parent = parent;
		}
		else {
			parent->_left = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_color == RED) {
			Node* grandparent = parent->_parent;
			if (parent == grandparent->_left) {
				Node* uncle = grandparent->_right;
				// uncle存在且为红, 情况1
				if (uncle && uncle->_color == RED) {
					//        g(b)
					//     p(r)  u(r)
					//  c(r)
					// 变色
					parent->_color = uncle->_color = BLACK;
					grandparent->_color = RED;
					// 继续向上处理
					cur = grandparent;
					parent = cur->_parent;
				}
				// uncle为黑或者不存在
				else {
					// cur在parent的左边, 情况2, 单旋
					if (cur == parent->_left) {
						//        g(b)
						//     p(r)  u(b)
						//  c(r)
						RotateR(grandparent);
						parent->_color = BLACK;
						grandparent->_color = RED;
					}
					// cur在parent的右边, 情况3, 双旋
					else {
						//         g(b)
						//     p(r)    u(b)
						//		   c(r)
						RotateL(parent);
						RotateR(grandparent);
						cur->_color = BLACK;
						grandparent->_color = RED;
					}
					break;
				}
			}
			// parent == grandparent->_right
			else {
				Node* uncle = grandparent->_left;
				// uncle存在且为红, 情况1
				if (uncle && uncle->_color == RED) {
					//        g(b)
					//    u(r)   p(r)
					//               c(r)
					// 变色
					parent->_color = uncle->_color = BLACK;
					grandparent->_color = RED;
					// 继续向上处理
					cur = grandparent;
					parent = cur->_parent;
				}
				// uncle为黑或者不存在
				else {
					// cur在parent的右边, 情况2, 单旋
					if (cur == parent->_right) {
						//        g(b)
						//     u(b)  p(r)
						//			      c(r)
						RotateL(grandparent);
						parent->_color = BLACK;
						grandparent->_color = RED;
					}
					// cur在parent的左边, 情况3, 双旋
					else {
						//         g(b)
						//     u(r)    p(b)
						//		   c(r)
						RotateR(parent);
						RotateL(grandparent);
						cur->_color = BLACK;
						grandparent->_color = RED;
					}
					break;
				}
			}
		}
		// 处理后_root可能会变色, 在这里它置为黑色
		_root->_color = BLACK;
		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()
	{
		if (_root == nullptr)	return true;
		// 违反规则2
		if (_root->_color == RED)	return false;

		int refVal = 0;		// 参考值, 记录某一条路径上的黑色节点的数量
		Node* cur = _root;
		while (cur) {
			if (cur->_color == BLACK)
				refVal++;
			cur = cur->_left;
		}
		int blackNum = 0;

		return Check(_root, refVal, blackNum);
	}

	// 获得树的高度
	size_t GetHeight()
	{
		return _GetHeight(_root);
	}
	
	// 获得节点数
	size_t GetSize()
	{
		return _GetSize(_root);
	}
private:
	Node* _root = nullptr;
protected:
	// 新节点插入较高右子树的右侧---右右：左单旋  
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		// 由于parent不一定是整棵树的根,后面更新subR的parent时需要用到parentParent
		Node* parentParent = parent->_parent;

		parent->_right = subRL;
		// 注意,subRL可能为nullptr
		if (subRL)
			subRL->_parent = parent;
		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root) {
			_root = subR;
			subR->_parent = nullptr;
		}
		// parent不是整棵树的根
		else {
			if (parentParent->_left == parent)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;
		}
		subR->_parent = parentParent;
	}

	// 新节点插入较高左子树的左侧---左左：右单旋  
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* parentParent = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root) {
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
			if (parent == parentParent->_left)
				parentParent->_left = subL;
			else
				parentParent->_right = subL;
			subL->_parent = parentParent;
		}
	}

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

	bool Check(Node* root, const int& refVal, int blackNum)
	{

		if (root == nullptr) { 
			// cout << blackNum << endl;
			if(blackNum == refVal)
				return true; 
			else {
				cout << "有路径黑色节点数量不一致" << endl;
				return false;
			}
		}
		if (root->_color == BLACK)	blackNum++;
		if (root->_color == RED && root->_parent->_color == RED) {
			// 违反规则3
			cout << "有连续的红色节点" << endl;
			return false;
		}
		
		return Check(root->_left, refVal, blackNum) 
			&& Check(root->_right, refVal, blackNum);
	}

	size_t _GetHeight(Node* root)
	{
		if (root == nullptr)	return 0;
		size_t left = _GetHeight(root->_left);
		size_t right = _GetHeight(root->_right);
		return left > right ? left + 1 : right + 1;
	}
	size_t _GetSize(Node* root)
	{
		if (root == nullptr)	return 0;
		else return _GetSize(root->_left) + _GetSize(root->_right) + 1;
	}
};
冰红茶兑滴水
关注
专栏目录
红黑树插入时的自平衡
12-21
红黑树是一种自平衡二叉查找树，它的主要目的是在执行插入和删除操作时能快速地重新平衡，确保查找效率。红黑树的特性如下： 1. 每个节点要么是红色，要么是黑色。 2. 根节点必须是黑色。 3. 任何两个相邻的红色...
中科大红黑树插入算法实验报告
01-11
### 中科大红黑树插入算法实验报告 #### 一、背景介绍 红黑树（Red-Black Tree，简称RBT）是一种自平衡的二叉查找树，它通过确保树的高度始终保持在对数级别来保证查找操作的时间复杂度为O(log n)。红黑树在各种...
红黑树插入过程
weixin_67623483的博客
09-25 438
红黑树插入过程图解
数据结构之红黑树插入详解
weixiaohuai的博客
11-16 5693
一、概述 红黑树是一颗二叉平衡树，并且查找不会破坏树的平衡，所以查找跟二叉平衡树的查找没有什么区别，可以看前面的文章进行学习，这里不再过多阐述。本节我们主要总结红黑树插入相关的知识。 二、红黑树插入 红黑树的插入包含两个步骤： 在树中查找插入的位置； 插入后自平衡； 查找流程： 从根节点开始查找； 若根节点为空，那么插入节点作为根节点，结束； 若根节点不为空，那么把根节点作为当前节点； 若当前节点为null，返回当前节点的父节点，结束； 若当前节点key等于查找key，那么该key所在节点就是插入节点
红黑树插入操作
唐学长的博客
06-09 1320
红黑树的概念红黑树的性质红黑树的插入
数据结构-红黑树插入结点示例
学习记录
12-13 820
数据结构-红黑树插入结点示例
【C++】红黑树插入删除
fight_p的博客
12-14 1435
这是一篇关于红黑树插入删除为主要内容的文章，本文详细讲述了红黑树的插入情形以及如何解决，代码如何实现，当然最重要的就是红黑树的删除，虽然红黑树删除不简单，但是删除的无非就是叶子节点，一个孩子的节点，两个孩子的节点，被删节点是红色还是黑色。其中最重要的就是删除的黑色叶子节点这有些麻烦，其他的都很简单！本文把每个情况都详细罗列出来。其实看完之后红黑树的删除真的没有那么难！！！
【C++】红黑树插入过程详解
罅隙的博客
09-14 858
介绍红黑树的基本性质，重点讲解红黑树插入过程的实现
红黑树插入操作的平衡调整
haponchang的博客
05-21 1587
参考来源：极客时间 红黑树规定，插入的节点必须是红色的。而且，二叉查找树中新插入的节点都是放在叶子节点上。 如果插入节点的父节点是黑色的，那我们什么都不用做，它仍然满足红黑树的定义。 如果插入的节点是根节点，那我们直接改变它的颜色，把它变成黑色就可以了。 除此之外，其他情况都会违背红黑树的定义，于是我们就需要进行调整，调整的过程包含两种基础的操作：左右旋转和改变颜色。 新节点插入之...
数据结构之红黑树插入案例详解
weixiaohuai的博客
11-17 1211
一、概述 前面一篇文章介绍了红黑树插入的几种情况以及怎么自平衡操作，但是理论知识比较多，不好理解，今天我们用一个简单的示例总结一下前面的一些自平衡操作，包括变色、左旋、右旋等。 二、红黑树插入案例 【a】首先我们先准备一颗已经平衡的红黑树，如下图：
红黑树插入和删除的各种情况分析
jianjian的博客
01-11 2083
1.红黑树的定义 红黑树是一种自平衡的二叉查找树，是一种高效的查找树。 一颗m阶的B树，或为空树，或者满足依稀阿特性的M叉树； 每个节点是红色或黑色 根是黑色 所有叶子都是黑色（叶子是NIL节点） 如果一个节点是红色的，则他的两个儿子是黑色的（从每个叶子到根的所有路径上不能有两个连续的红色节点） 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点（简称黑高） 2.B树的数据结构 typedef int KEY_TYPE; //定义红黑树的节点 typedef struct _rbtree_n
红黑树及插入过程详解
weixin_49561506的博客
05-30 1466
介绍红黑树的特点，以及红黑树插入节点后的调整方式
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种自平衡二叉查找树，它的主要特点是在保持二叉查找树特性的同时，通过特定的颜色规则来确保树的平衡，以达到快速查找、插入和删除的目的。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。在插入新...
基于红黑树插入操作原理及java实现方法(分享)
08-28
基于红黑树插入操作原理及Java实现方法 红黑树是一种自平衡二叉查找树，它可以保证树的高度尽可能小，提高查找、插入、删除等操作的效率。红黑树的每个结点都有一个存储位来表示结点的颜色，可以是红色或黑色。红黑...
HashMap中红黑树插入节点的调整过程.doc
07-10
本文将详细解析HashMap中红黑树插入节点后的调整过程。 一、红黑树插入节点的概述 在HashMap中，当一个新节点插入到红黑树时，可能会破坏红黑树的性质，包括以下几点： 1. 每个节点要么是红色，要么是黑色。 2. ...
904. 水果成篮
YQ20210216的博客
09-27 353
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 1082
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
8608 实现二叉排序树的各种算法(2)
最新发布
huang1xiao1sheng的博客
09-30 679
用函数实现如下二叉排序树算法： （1） 插入新结点 （2） 前序、中序、后序遍历二叉树 （3） 中序遍历的非递归算法 （4） 层次遍历二叉树 （5） 在二叉树中查找给定关键字(函数返回值为成功1,失败0) （6） 交换各结点的左右子树 （7） 求二叉树的深度 （8） 叶子结点数 输入格式 第一行：准备建树的结点个数n 第二行：输入n个整数，用空格分隔 第三行：输入待查找的关键字 第四行：输入待查找的关键字 第五行：输入待插入的关键字 输出格式 第一行：二叉树的先序遍历序列
算法训练营打卡Day14
Zoe_igxgx的博客
09-25 259
题目1.226.翻转二叉树题目2.101. 对称二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值