010 数据结构_红黑树

最新推荐文章于 2024-05-20 22:31:31 发布
最新推荐文章于 2024-05-20 22:31:31 发布
阅读量998 收藏 16
点赞数 16
分类专栏： Fan——数据结构与算法学习之路 Fan——C++ 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Moonnight_bit/article/details/134714330
版权

前言

本文将会向你介绍红黑树的概念、性质，以及如何手撕红黑树

1 文章重点

文本首先引入红黑树的概念和性质，性质非常重要对于后面的插入操作来说，文章的核心放在了插入部分，另外看插入部分之前记得看声名和节点的定义哦~

2 引入红黑树

2.1概念

首先红黑树是一颗二叉搜索树，每个节点都有颜色,红色或黑色，最长路径最多是最短路径的二倍

2.2性质

1、 每个节点不是红色就是黑色。
2、 根部节点是黑色的。
3、 一条路径上不能出现连续的红色节点
4、每条路径都必须包含相同数量的黑色节点。

3 测试

	// 检测红黑树中是否存在值为data的节点，存在返回该节点的地址，否则返回nullptr
	Node* Find(const pair<K, V>& kv)
	{
		Node* cur = _root;
		Node* parent = _root;
		Node* grandParent = parent->_parent;
		//判断是否为空树
		if (_root == nullptr)
		{
			return nullptr;
		}
		//寻找插入位置
		else
		{
			Node* parent = cur;
			while (cur)
			{
				//记录父节点的位置，便于后续的链接操作
				parent = cur;
				//向左遍历
				if (cur->_kv.first > kv.first)
				{
					cur = cur->_left;
				}
				//向右遍历
				else if (cur->_kv.first < kv.first)
				{
					cur = cur->_right;
				}
				//已有
				else return cur;
			}
		}
	}

	//中序遍历，验证是否为二叉搜索树
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	size_t _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftHeight = _Height(root->_pLeft);
		int rightHeight = _Height(root->_pRight);
		return (leftHeight > rightHeight) ? leftHeight + 1 : rightHeight + 1;
	}
	int Height()
	{
		return _Height(_root);
	}
	bool Check(Node* root, int blackNum, const int ref)
	{
		if (root == nullptr)  //到根部看看当前路径黑色节点和标准值是否一致
		{
			//cout << blackNum << endl;
			if (blackNum != ref)
			{
				cout << "存在黑色节点数量不相等的路径" << endl;
				return false;
			}

			return true;
		}

		// 检查子比较复杂，可以反过来去检查红节点父是否为黑色
			if (root->_cl == RED && root->_parent->_cl == RED)
			{
				cout << "有连续的红色节点" << endl;

				return false;
			}

		if (root->_cl == BLACK)
		{
			++blackNum;  //为黑节点加一
		}

		return Check(root->_left, blackNum, ref)
			&& Check(root->_right, blackNum, ref);
	}

	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		if (root->_cl == RED)
		{
			return false;
		}
		int ref = 0;
		Node* cur = root;
		//计算一条路径的黑色节点标准值
		while (cur)
		{
			if (cur->_cl == BLACK)
			{
				ref++;
			}
			cur = cur->_left;
		}
		int blackNum = 0;
		return Check(root, blackNum, ref); 
	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}

Check 函数是一个递归函数，用于检查从当前节点到叶子节点的路径上的黑色节点个数是否与参考值 ref 相等。
参数 root 表示当前节点指针，blackNum 表示根节点到当前节点的路径上的黑色节点个数，ref 是参考值。
如果当前节点为空指针，即到达了叶子节点，那么检查路径上的黑色节点个数 blacknum 是否等于参考值 ref，如果不相等则返回false，否则返回 true。
如果当前节点的颜色为红色，并且父节点也是红色，表示存在连续的红节点，不符合红黑树的性质，返回 false。
如果当前节点的颜色为黑色，将 blackNum 值加一。 递归地调用 Check 函数检查左子节点和右子节点，并将当前节点的黑色节点个数blacknum 作为参数传递。

IsBalance 函数用于检查整个红黑树是否符合红黑树的性质。
如果红黑树为空树，即根节点为空，认为是一棵合法的红黑树，返回 true。
如果根节点的颜色是红色，违反了红黑树的性质，返回 false。
初始化 blacknum 为 0，用于记录每条路径的黑色节点个数。 初始化 ref 为 0，作为参考值。
通过遍历从根节点到最左子节点的路径，统计参考值 ref，即路径上的黑色节点个数。 调用 Check
函数，传入根节点、路径上的黑色节点个数 blacknum 和参考值 RefVal 进行检查

插入一千个数据(未全列出)
在这里插入图片描述

4 插入（重点）

声名

为了方便叙述，将进行以下定义
cur©——当前节点
parent§——父节点
grandParent(g)——父节点的父节点
uncle(u)——父节点的兄弟节点

节点的定义

enum Color
{
	RED,
	BLACK
};
template<class K, class V>
struct RBTreeNode
{
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	RBTreeNode* _pHead;
	Color _cl;
	pair<K, V> _kv;
template<class K, class V>
	RBTreeNode(const pair<K, V>& kv)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_pHead(nullptr)
		, _cl(RED)
		, _kv(kv)
	{}
};

_left：指向左子节点的指针。
_right：指向右子节点的指针。
_parent：指向父节点的指针。
_kv：存储键值对的成员变量。这里使用了 pair<K, V> 类型来表示键值对，其中 K 是键的类型，V 是值的类型。
_cl：表示节点的颜色。这里使用枚举类型来表示，其中 RED 表示红色，BLACK 表示黑色，构造出来的节点默认为红色

插入

对于新插入节点，我们设置为红色，原因是红黑树每条路径都必须包含相同数量的黑色节点（性质4），新插入红节点不一定破坏红黑树的结构，新插入黑色节点一定不符合性质4而且很难调整(新增一条路径的黑色节点，其他路径也需要增加（会很麻烦）)

bool Insert(const pair<K, V>& kv)
	{				
		//记录当前节点
		Node* cur = _root;
		//记录父节点
		Node* parent = _root;
		//判断是否为空树
		if (_root == nullptr)
		{
			//直接插入
			_root = new Node(kv);
			//插入成功
			_root->_cl = BLACK;
			return true;
		}
		//寻找插入位置
		else
		{	
			while (cur)
			{
				//记录父节点的位置，便于后续的链接操作
				parent = cur;
				//向左遍历
				if (cur->_kv.first > kv.first)
				{
					cur = cur->_left;
				}
				//向右遍历
				else if (cur->_kv.first < kv.first)
				{
					cur = cur->_right;
				}
				//已有
				else return false;
			}
			cur = new Node(kv);
			//插入+链接
			if (parent->_kv.first > kv.first)
			{
				parent->_left = cur;
			}
			else
			{
				parent->_right = cur;
			}
			//链接
			cur->_parent = parent;
		}
		//父亲为红，变色调整
		while (parent && parent->_cl == RED)
		{
			//以下代码暂时省略......
			
			//1、parent为grandparent的左
			//情况一：uncle存在且为红，变色即可
			//无需讨论cur的位置，变色即可
			//情况二：uncle不存在或者为黑，旋转+变色
			//需讨论cur的位置
					//（1）cur为parent的左（进行右单旋）
					//	 g
					// p   u
					//c
					//（2）cur为parent的右（进行左右双旋）
					//	 g
					// p   u
					//	c
			
			//2、parent为grandparent的右
				//情况一：uncle存在且为红，变色即可
				//无需讨论cur的位置，变色即可
				//情况二：uncle不存在或者为黑，旋转+变色
					//（1）cur为parent的右（进行左单旋）
					//	 g
					// u   p
					//		c
					//（2）cur为parent的右（进行右左双旋）
					//	 g
					// u   p
					//	 c
		}	
		//保持根部为黑色
		_root->_cl = BLACK;
		return true;
	}

注意：所有的情况解决方案都是根据规律总结出来的，由于将所有的情况列出来过于复杂，所以用抽象的子树来代替（三角形代表的就是抽象的子树），在这一情况中将会告诉你如果不用抽象子树来代替会有多复杂

（1）情况一：parent为grandparent的左

1.1uncle存在且为红，变色即可

Node* uncle = grandParent->_right;
if (uncle && uncle->_cl == RED)
{
	parent->_cl = uncle->_cl = BLACK;
	grandParent->_cl = RED;
	//继续向上调整
	cur = grandParent;
	parent = cur->_parent;
}

在这里插入图片描述
三角形表示抽象子树，下面会举例说明这里为什么会用抽象子树来表示
在这里插入图片描述
当c，d，e是没有黑色节点的子树，此时cur是新增，此时c，d，e子树处为一个红节点或者为空，a，b为空。我们只需要通过新插入节点以及p，u、g节点进行变色即可，如图将p，u变黑，将g变红即可
在这里插入图片描述
当c，d，e子树是包含一个黑色节点的子树，如图此时c（cur）便不是新插入的节点了，最下边的红色节点才是
在这里插入图片描述

这是c，d，e子树可能的情况，然而插入位置有4个，cde形状组合：444，合计组合为64*4 = 256种情况，如果c，d，e子树是包含2个黑色节点及以上的，那么情况是分析不完的
在这里插入图片描述
其实你会发现，只要满足某个规律（如下）
在这里插入图片描述
然后做出应有的调整
在这里插入图片描述
最后在向上调整就好了
在这里插入图片描述
以下情况（非必须）都会用抽象子树来模拟规律

1.2uncle不存在或者为黑，旋转+变色

1.2.1cur为parent的左（进行右单旋）
//（1）cur为parent的左
//	 g
// p   u
//c
if (cur == parent->_left)
{
	RotateR(grandParent);
	grandParent->_cl = RED;
	parent->_cl = BLACK;
}

为了能让你更好的理解。此情况（uncle不存在或者为黑）的调整将会结合uncle存在且为红，变色即可的情况
如图：c、d、e是包含一个黑色节点的子树
在这里插入图片描述

规律：uncle存在且为红，变色即可并向上调整
在这里插入图片描述
我们将会发现此时满足u为黑
在这里插入图片描述

右旋
在这里插入图片描述
在这里插入图片描述
变色
在这里插入图片描述
注意c、d、e是包含一个黑色节点的子树
此时你便可以看看是否满足红黑树的性质了
在这里插入图片描述

1.2.2cur为parent的右（进行右左双旋）
//（1）cur为parent的右
//	 g
// p   u
//	c
else
{
	//左右双旋
	RotateL(parent);
	RotateR(grandParent);
	grandParent->_cl = RED;
	cur->_cl = BLACK;
}

在这里插入图片描述

（2）情况二：parent为grandparent的右

2.1uncle存在且为红，变色即可

Node* uncle = grandParent->_left;
if (uncle && uncle->_cl == RED)
{
	parent->_cl = uncle->_cl = BLACK;
	grandParent->_cl = RED;
	//继续向上调整
	cur = grandParent;
	parent = cur->_parent;
}

在这里插入图片描述

2.2uncle不存在或者为黑，旋转+变色

2.2.1cur为parent的右（进行左单旋）
//（1）cur为parent的右（左单旋）
//	 g
// u   p
//		c
if (cur == parent->_right)
{
	RotateL(grandParent);
	grandParent->_cl = RED;
	parent->_cl = BLACK;
}

在这里插入图片描述

2.2.2cur为parent的左（进行右左双旋）
//（1）cur为parent的右（右左双旋）
//	 g
// u   p
//	 c
RotateR(parent);
RotateL(grandParent);
grandParent->_cl = RED;
cur->_cl = BLACK;

在这里插入图片描述

5 全部代码

enum Color
{
	RED,
	BLACK
};
template<class K, class V>
struct RBTreeNode
{
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	RBTreeNode* _pHead;
	Color _cl;
	pair<K, V> _kv;
template<class K, class V>
	RBTreeNode(const pair<K, V>& kv)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_pHead(nullptr)
		, _cl(RED)
		, _kv(kv)
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	//左单旋
	void RotateL(Node* pParent)
	{

		Node* subR = pParent->_right;
		Node* subRL = subR->_left;	//可能为空


		pParent->_right = subRL;
		subR->_left = pParent;

		Node* pPnode = pParent->_parent; //原来父亲的父亲

		pParent->_parent = subR;
		//可能为空
		if (subRL)
		{
			subRL->_parent = pParent;
		}
		
		//链接：旋转整棵树
		if (_root == pParent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		//链接：旋转子树
		else
		{
			if (pPnode->_left == pParent)
			{
				pPnode->_left = subR;
			}
			else if (pPnode->_right == pParent)
			{
				pPnode->_right = subR;
			}
			subR->_parent = pPnode;
		}
	}
	// 右单旋
	void RotateR(Node* pParent)
	{

		Node* subL = pParent->_left;
		Node* subLR = subL->_right;

		pParent->_left = subLR;
		//可能为空
		if (subLR)
		{
			subLR->_parent = pParent;
		}

		Node* pPnode = pParent->_parent;

		subL->_right = pParent;
		pParent->_parent = subL;

		//旋转部分子树
		if (_root == pParent)
		{			
			_root = subL;
			subL->_parent = nullptr;
		}
		//旋转整棵子树
		else
		{
			if (pPnode->_left == pParent)
			{
				pPnode->_left = subL;
			}
			else
			{
				pPnode->_right = subL;
			}
			subL->_parent = pPnode;
		}
	}
	bool Insert(const pair<K, V>& kv)
	{				
		//记录当前节点
		Node* cur = _root;
		//记录父节点
		Node* parent = _root;
		//判断是否为空树
		if (_root == nullptr)
		{
			//直接插入
			_root = new Node(kv);
			//插入成功
			_root->_cl = BLACK;
			return true;
		}
		//寻找插入位置
		else
		{	
			while (cur)
			{
				//记录父节点的位置，便于后续的链接操作
				parent = cur;
				//向左遍历
				if (cur->_kv.first > kv.first)
				{
					cur = cur->_left;
				}
				//向右遍历
				else if (cur->_kv.first < kv.first)
				{
					cur = cur->_right;
				}
				//已有
				else return false;
			}
			cur = new Node(kv);
			//插入+链接
			if (parent->_kv.first > kv.first)
			{
				parent->_left = cur;
			}
			else
			{
				parent->_right = cur;
			}
			//链接
			cur->_parent = parent;
		}
		//父亲为红，变色调整
		while (parent && parent->_cl == RED)
		{
			//记录原来节点的父亲的父节点
			Node* grandParent = parent->_parent;
			//情况一：uncle存在且为红，变色即可
			if (parent == grandParent->_left)
			{
				Node* uncle = grandParent->_right;
				if (uncle && uncle->_cl == RED)
				{
					parent->_cl = uncle->_cl = BLACK;
					grandParent->_cl = RED;
					//继续向上调整
					cur = grandParent;
					parent = cur->_parent;
				}
				//情况二：uncle不存在或者为黑，旋转+变色
				else
				{
					//（1）cur为parent的左
					//	 g
					// p   u
					//c
					if (cur == parent->_left)
					{
						RotateR(grandParent);
						grandParent->_cl = RED;
						parent->_cl = BLACK;
					}
					//（1）cur为parent的右
					//	 g
					// p   u
					//	c
					else
					{
						//左右双旋
						RotateL(parent);
						RotateR(grandParent);
						grandParent->_cl = RED;
						cur->_cl = BLACK;
					}
					break;
				}
			
			}
			//parent为grandparent的右
			else
			{
				//情况一：uncle存在且为红，变色即可
				Node* uncle = grandParent->_left;
				if (uncle && uncle->_cl == RED)
				{
					parent->_cl = uncle->_cl = BLACK;
					grandParent->_cl = RED;
					//继续向上调整
					cur = grandParent;
					parent = cur->_parent;
				}
				//情况二：uncle不存在或者为黑，旋转+变色
				else
				{
					//（1）cur为parent的右（左单旋）
					//	 g
					// u   p
					//		c
					if (cur == parent->_right)
					{
						RotateL(grandParent);
						grandParent->_cl = RED;
						parent->_cl = BLACK;
					}
					//（1）cur为parent的右（左单旋）
					else
					{
						//（1）cur为parent的右（右左双旋）
						//	 g
						// u   p
						//	 c
						RotateR(parent);
						RotateL(grandParent);
						grandParent->_cl = RED;
						cur->_cl = BLACK;
					}
					break;
				}
				
			}
		}	
		//保持根部为黑色
		_root->_cl = BLACK;
		return true;
	}

在这里插入图片描述

小结

今日的分享就到这里啦，如果本文存在疏漏或错误的的地方，还请您能够指出

Fan_558
关注
  • 16
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-红黑树.zip
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
数据结构_红黑树(C语言)
小黯
01-04 1607
已知新插入的结点为红色，而如果父结点也为红色，就会违反性质四，则说明此时需要调整红黑树同时在父亲结点为红色的条件下，则根据性质二，父亲结点一定不是根结点，且存在祖父结点。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 16万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
瑞_数据结构与算法_红黑树
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
01-30 2641
本文章为瑞_系列专栏之《数据结构与算法》的红黑树篇，红黑树是一种自平衡二叉查找树，较之 AVL树，插入和删除时旋转次数更少。所以红黑树和AVL的区别主要在于判断平衡的依据不同。无论是AVL树还是红黑树，都是为了确保树的平衡性，从而提高搜索、插入和删除操作的效率。
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【高阶数据结构】红黑树详解
m0_70980326的博客
08-17 1962
红黑树详解
C++进阶数据结构_红黑树
代码铺子
06-07 1170
R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉搜索树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。
基本数据结构之红黑树
qq_44182694的博客
01-28 1565
红黑树 红黑树（Red-Black Tree，R-B Tree）是一种自平衡的二叉查找树。在红黑树的每个节点上都多出一个存储位表示节点的颜色，颜色只能是红（Red）或者黑（Black）。 是根据AVL树进化而来的，由于AVL树每次插入都需要动态调整，这需要大量的时间，因此出现了红黑树。 红黑树不会像AVL树那样，每次插入都需要动态调整。因此当数据经常变化的时候，红黑树的效率要比AVL树要高。 红黑树的特性 红黑树的特性如下。 ◎ 每个节点或者是黑色的，或者是红色的。 ◎ 根节点是黑色的。 ◎ 每个叶子节点（
数据结构-红黑树
m0_61433144的博客
08-18 1066
红黑树也是一种二叉排序树，在红黑树中每个结点存储着对应的颜色(红色或者黑色)，由于AVL树的高度平衡是因为非常频繁地调用旋转来保存自身平衡的，代价较大。所以在AVL树的基础上进一步放宽条件，引入红黑树，即红黑树的最长路径不会比最短路径长两倍。......
深入理解高级数据结构之红黑树
小鱼学编程
09-10 6396
今天我们来学习红黑树
map，set底层数据结构红黑树
hbbfvv1h的博客
12-03 2506
红黑树的概念 ①红黑树与AVL树一样都是平衡二叉搜索树 ②通过从任一节点到其叶子节点的所有路径上都包含相同数目的黑节点的限制，确保没有一条路径会比其他路径长出俩倍，因而是接近平衡 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红结点) 对于每个结点，从该结点到其所有后代叶结点的简单路径上,包含相同数目的黑色结点 每个叶子结点都是黑色的(此处的叶子结点指的是空结点) 红黑树的极端情况 针对第三点我们很容易想到两种极端情况
数据结构之红黑树详解
12-31
在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。它是复杂的，但它的操作有着良好的最坏情况运行...
数据结构 红黑树的详解
01-20
数据结构 红黑树的详解 红黑树是具有下列着色性质的二叉查找树： 1.每一个节点或者着红色，或者着黑色。 2.根是黑色的。 3.如果一个节点是红色的，那么它的子节点必须是黑色。 4.从一个节点到一个NULL指针的每一条...
hongheishu.rar_binary tree_红黑树
09-21
红黑树算法，是高级数据结构中必须学习的一种特殊二元查找树，也是很有实际用处的一个算法。
[Collection与数据结构] Map与Set(二):哈希表
2301_80050796的博客
05-20 381
🏵️热门专栏:🍕 Collection与数据结构 (91平均质量分)🧀Java EE(94平均质量分)🍭MySql数据库(93平均质量分)🍬算法(97平均质量分)
数据结构之树与二叉树
最新发布
paradiso989的博客
05-20 733
本文介绍了数据结构中树与二叉树的基础概念以及实现方式
【无标题】
qq_24099547的博客
05-17 169
要求待查询的序列是有序数列, 每个取中间位置的值与目标值进行比较。
【数据结构/C语言】深入理解 双向链表
2302_78391795的博客
05-20 723
双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。 一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。
数据结构之链表
qq_63448996的博客
05-19 453
2.然后，从第二个节点开始，依次将每个节点插入到头节点之后。这样，原来的第二个节点就变成了新的头节点，原来的第三个节点就变成了新的第二个节点，
java数据结构 红黑树
08-21
- *1* [Java数据结构之红黑树的真正理解](https://download.csdn.net/download/weixin_38622475/12770272)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fan_558

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值