C++ | 红黑树的规则及其插入过程的讲解与实现

已于 2024-05-07 15:11:01 修改
阅读量370 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： c++ 算法 开发语言
于 2022-08-27 16:54:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61432764/article/details/126544136
版权

文章目录

红黑树概念

总特征：任意节点到叶子节点的最长路径不超过最短路径的两倍

1.每个节点非红即黑
2.根节点为黑色
3.如果一个节点为红色，那么它的子节点必须是黑色（不能有连续的红节点）
4.对于某个节点来说，该节点到所有叶子节点的路径上的黑色节点数量相同

在这里插入图片描述
图片来自百度百科

话不多说，直接用C++实现红黑树的结构

整体结构

enum Colour
{
	RED,
	BLACK
};


template <class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	Colour _col;

	RBTreeNode(pair<K, V> kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}
};

template <class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv);
	bool IsRBTree();
	void Inorder() { _Inorder(_root); }
	void Leorder() { _Leorder(_root); }
private:
	void RotateL(Node* root);
	void RotateR(Node* root);
	int _HeightGreater(Node* root);
	int _HeightLess(Node* root);
	bool _IsRBTree(Node* root, int k, int blackCount);
	void _Inorder(Node* root);
	void _Leorder(Node* root);
private:
	Node* _root = nullptr;
};

插入的三种情况

插入节点颜色都是红色，因为如果插入节点为黑色，一定不符合任意节点到其所有叶子节点的黑色节点数量相同的规则，但插入节点为红色，可以根据红黑树的规则进行一定的调整，使其重新满足红黑树的性质

g是祖父节点，p是父节点，u是叔叔节点，cur可能是当前插入节点，也可能是a或b子树调整后的祖父节点

关于其中涉及到的旋转，在AVL的插入讲解这篇博客中有详细介绍

情况1

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

第一种情况：

  • 如果p与u都是红色，将p与u改为黑色，g改为红色
  • 如果g的父节点为黑（g可能是整棵树中的子树），调整结束
  • 如果g的父节点为红，需要以g为cur向上继续调整
  • 同理，如果p和u的位置调换，但u为红色，也是这样调整（就是上面的四种情况）

最后：

  • 如果子树的根节点g为树的根节点，将其改为黑，退出更新
  • 如果不是，则判断g的父节点是否为红
    • 如果为红，将g作为新的cur，并且根据cur的位置更新出g，u，p的位置，根据情况继续进行更新
    • 如果为黑，则退出更新

情况2

在这里插入图片描述
在这里插入图片描述

第二种情况：

  • 如果u不存在，cur就是新插入的节点，以g为根节点进行右旋转（p为g的右子节点则进行左旋转），最后将p和g的颜色反转
  • 如果u存在且为黑，那么cur不是新插入的节点，cur之前为黑（因为p为红，cur不可能为红），因为cur的子树调整导致了cur变红。这种情况下，调整方法与第一种是一样的。
    为什么第一种情况可以直接将p和u变为黑？
  • 因为这样做不违反每条路径上的黑节点数量相同的规则，u和p都为红的情况下，将一条路径上的两节点颜色反转，所有路径的黑色节点的数量没有发生变化
  • 但在u为黑的情况下，将p和u变黑，因为u本来就是黑的，所以只有某些路径的黑色节点数量增加，违反了第四条这个规则

总结：

  • 只有在出现连续两个节点为红色时，才会进行调整。所以cur和parent一定为红
  • 三种情况的判断关键在于：uncle节点的颜色
  • 若u为红，则反转u，p和g的颜色，对应第一种情况
  • 若u为黑，需要进行旋转以维持第四条规则，对应第二和三种情况

情况3

在这里插入图片描述
在这里插入图片描述

第三种情况：

  • u为黑或不存在，p为g的左子节点，cur为p的右子节点
  • 思路是往情况2靠，以cur为根节点进行左单旋，成为情况2，以情况2的方式旋转，变色
  • 同理，p为g的右子节点，cur为p的左子节点，也是一样的

Insert代码

template <class K, class V>
bool RBTree<K, V>::Insert(const pair<K, V>& kv)
{
	// 以搜索二叉树的规则插入
	if (_root == nullptr)
	{
		_root = new Node(kv);
		// 根节点为黑色
		_root->_col = BLACK;
		return true;
	}

	Node* cur = _root;
	Node* parent = nullptr;
	// 找合适的插入位置
	while (cur)
	{
		if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(kv);
	// 判断该插入parent的哪边
	if (kv.first < parent->_kv.first)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	cur->_parent = parent;
	// 插入结束

	// 保持平衡
	while (parent && parent->_col == RED) // 出现连续的红节点
	{
		Node* grandParent = parent->_parent;
		assert(grandParent);

		if (grandParent->_left == parent) // parent在祖父节点左边
		{
			Node* uncle = grandParent->_right;
			// u为红色，一定要提前判断u是否存在
			if (uncle && uncle->_col == RED)
			{
				uncle->_col = BLACK;
				parent->_col = BLACK;
				grandParent->_col = RED;
				if (grandParent == _root)
				{
					grandParent->_col = BLACK;
					return true;
				}
				else // grandParent不是根节点，但其父节点为黑色，也插入完成
				{
					if (grandParent->_parent && grandParent->_parent->_col == BLACK)
					{
						return true;
					}
					else // grandParent的父节点为红，出现连续红节点，更新节点，继续调整
					{
						cur = grandParent;
						parent = cur->_parent;
					}
				}
			} // end of if (uncle && uncle->_col == RED)

			else // u不存在或者为黑
			{
				// cur在p的左边
				if (cur == parent->_left)
				{
					RotateR(grandParent);
					grandParent->_col = RED;
					parent->_col = BLACK;
				}
				else // cur在p的右边，需要旋转成左边的情况
				{
					RotateL(parent);
					RotateR(grandParent);
					cur->_col = BLACK;
					grandParent->_col = RED;
				}
				return true;
			}
		} // end of - if (grandParent->_left == parent)

		else // p在grandParent的右边
		{
			Node* uncle = grandParent->_left;
			assert(grandParent);
			// u为红色
			if (uncle && uncle->_col == RED)
			{
				uncle->_col = BLACK;
				parent->_col = BLACK;
				grandParent->_col = RED;
				if (grandParent == _root)
				{
					_root->_col = BLACK;
					return true;
				}
				else
				{
					if (grandParent->_parent && grandParent->_parent->_col == BLACK)
					{
						return true;
					}
					// 更新继续调整
					else
					{
						cur = grandParent;
						parent = cur->_parent;
					}
				}
			} // end of if (uncle && uncle->_col == RED)

			else // u不存在或者为黑
			{
				// cur在p的右边
				if (cur == parent->_right)
				{
					RotateL(grandParent);
					grandParent->_col = RED;
					parent->_col = BLACK;
				}
				else // cur在p的右边，需要旋转成左边的情况
				{
					RotateR(parent);
					RotateL(grandParent);
					cur->_col = BLACK;
					grandParent->_col = RED;
				}
				return true;
			}
		} // end of - else
	}// end if - while
	return true;
}

验证红黑树

先求出一条路径上的黑色节点数量blackCount，然后调用子函数，子函数递归整棵树，用k记录当前路径的黑色节点数量，遇到黑色节点k++，当遇到节点为空的情况，比较k与blackCount是否相等。

另外每次递归要判断

  1. 根节点是否是黑色
  2. 如果该节点为红色，且父节点存在，如果父节点也为红，不满足红黑树性质
  3. 求出节点到叶子节点的最短路径与最长路径，判断最短路径的两倍不能小于最长路径
template <class K, class V>
bool RBTree<K, V>::_IsRBTree(Node* cur, int k, int blackCount)
{
	if (cur == nullptr)
	{
		if (blackCount != k)
		{
			cout << "路径上的黑色节点数量不相等" << endl;
			return false;
		}
		return true;
	}
	if (_root->_col != BLACK)
	{
		cout << "根节点为红色" << endl;
		return false;
	}

	// 求以cur为根节点的最小高度与最大高度
	int less = _HeightLess(cur);
	int greater = _HeightGreater(cur);

	if (less * 2 < greater)
	{
		cout << "最长路径超过最短路径两倍" << endl;
		return false;
	}

	if (cur->_col == RED && cur->_parent && cur->_parent->_col == RED)
	{
		cout << "出现连续红色节点" << endl;
		return false; // 检查连续的红色节点
	}

	if (cur->_col == BLACK)
	{
		k++;
	}

	// 递归验证左右子树
	return _IsRBTree(cur->_left, k, blackCount) && _IsRBTree(cur->_right, k, blackCount);
}

在这里插入图片描述

hpp所有代码

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;
#include <utility>
#include <assert.h>
#include <queue>
enum Colour
{
	RED,
	BLACK
};


template <class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	Colour _col;

	RBTreeNode(pair<K, V> kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}
};

template <class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv);
	bool IsRBTree();
	void Inorder() { _Inorder(_root); }
	void Leorder() { _Leorder(_root); }
private:
	void RotateL(Node* root);
	void RotateR(Node* root);
	int _HeightGreater(Node* root);
	int _HeightLess(Node* root);
	bool _IsRBTree(Node* root, int k, int blackCount);
	void _Inorder(Node* root);
	void _Leorder(Node* root);
private:
	Node* _root = nullptr;
};

template <class K, class V>
bool RBTree<K, V>::Insert(const pair<K, V>& kv)
{
	// 以搜索二叉树的规则插入
	if (_root == nullptr)
	{
		_root = new Node(kv);
		// 根节点为黑色
		_root->_col = BLACK;
		return true;
	}

	Node* cur = _root;
	Node* parent = nullptr;
	// 找合适的插入位置
	while (cur)
	{
		if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(kv);
	// 判断该插入parent的哪边
	if (kv.first < parent->_kv.first)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	cur->_parent = parent;
	// 插入结束

	// 保持平衡
	while (parent && parent->_col == RED) // 出现连续的红节点
	{
		Node* grandParent = parent->_parent;
		assert(grandParent);

		if (grandParent->_left == parent) // parent在祖父节点左边
		{
			Node* uncle = grandParent->_right;
			// u为红色，一定要提前判断u是否存在
			if (uncle && uncle->_col == RED)
			{
				uncle->_col = BLACK;
				parent->_col = BLACK;
				grandParent->_col = RED;
				if (grandParent == _root)
				{
					grandParent->_col = BLACK;
					return true;
				}
				else // grandParent不是根节点，但其父节点为黑色，也插入完成
				{
					if (grandParent->_parent && grandParent->_parent->_col == BLACK)
					{
						return true;
					}
					else // grandParent的父节点为红，出现连续红节点，更新节点，继续调整
					{
						cur = grandParent;
						parent = cur->_parent;
					}
				}
			} // end of if (uncle && uncle->_col == RED)

			else // u不存在或者为黑
			{
				// cur在p的左边
				if (cur == parent->_left)
				{
					RotateR(grandParent);
					grandParent->_col = RED;
					parent->_col = BLACK;
				}
				else // cur在p的右边，需要旋转成左边的情况
				{
					RotateL(parent);
					RotateR(grandParent);
					cur->_col = BLACK;
					grandParent->_col = RED;
				}
				return true;
			}
		} // end of - if (grandParent->_left == parent)

		else // p在grandParent的右边
		{
			Node* uncle = grandParent->_left;
			assert(grandParent);
			// u为红色
			if (uncle && uncle->_col == RED)
			{
				uncle->_col = BLACK;
				parent->_col = BLACK;
				grandParent->_col = RED;
				if (grandParent == _root)
				{
					_root->_col = BLACK;
					return true;
				}
				else
				{
					if (grandParent->_parent->_col == BLACK)
					{
						return true;
					}
					// 更新继续调整
					else
					{
						cur = grandParent;
						parent = cur->_parent;
					}
				}
			} // end of if (uncle && uncle->_col == RED)

			else // u不存在或者为黑
			{
				// cur在p的右边
				if (cur == parent->_right)
				{
					RotateL(grandParent);
					grandParent->_col = RED;
					parent->_col = BLACK;
				}
				else // cur在p的右边，需要旋转成左边的情况
				{
					RotateR(parent);
					RotateL(grandParent);
					cur->_col = BLACK;
					grandParent->_col = RED;
				}
				return true;
			}
		} // end of - else
	}// end if - while
	return true;
}



template <class K, class V>
void RBTree<K, V>::RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

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

	Node* pparent = parent->_parent;
	parent->_parent = subR;

	if (subRL)
		subRL->_parent = parent;
	if (_root == parent)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else // 该子树是树的一部分
	{
		subR->_parent = pparent;
		if (subR->_kv.first < pparent->_kv.first)
		{
			pparent->_left = subR;
		}
		else
		{
			pparent->_right = subR;
		}
	}
}

template <class K, class V>
void RBTree<K, V>::RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	subL->_right = parent;
	parent->_left = subLR;

	Node* pparent = parent->_parent;
	parent->_parent = subL;

	if (subLR)
		subLR->_parent = parent;
	if (_root == parent)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		subL->_parent = pparent;
		if (subL->_kv.first < pparent->_kv.first)
		{
			pparent->_left = subL;
		}
		else
		{
			pparent->_right = subL;
		}
	}
}


template <class K, class V>
int RBTree<K, V>::_HeightGreater(Node* root)
{
	if (root == nullptr)
	{
		return 0;
	}

	int leftH = _HeightGreater(root->_left);
	int rightH = _HeightGreater(root->_right);

	return leftH > rightH ? 1 + leftH : 1 + rightH;
}

template <class K, class V>
int RBTree<K, V>::_HeightLess(Node* root)
{
	if (root == nullptr)
	{
		return 0;
	}

	int leftH = _HeightLess(root->_left);
	int rightH = _HeightLess(root->_right);

	return leftH < rightH ? 1 + leftH : 1 + rightH;
}
template <class K, class V>
bool RBTree<K, V>::IsRBTree()
{
	int blackCount = 0;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_col == BLACK)
		{
			blackCount++;
		}
		cur = cur->_left;
	}
	int k = 0;

	return _IsRBTree(_root, k, blackCount);
}

template <class K, class V>
bool RBTree<K, V>::_IsRBTree(Node* cur, int k, int blackCount)
{
	if (cur == nullptr)
	{
		if (blackCount != k)
		{
			cout << "路径上的黑色节点数量不相等" << endl;
			return false;
		}
		return true;
	}
	if (_root->_col != BLACK)
	{
		cout << "根节点为红色" << endl;
		return false;
	}

	// 求以cur为根节点的最小高度与最大高度
	int less = _HeightLess(cur);
	int greater = _HeightGreater(cur);

	if (less * 2 < greater)
	{
		cout << "最长路径超过最短路径两倍" << endl;
		return false;
	}

	if (cur->_col == RED && cur->_parent && cur->_parent->_col == RED)
	{
		cout << "出现连续红色节点" << endl;
		return false; // 检查连续的红色节点
	}

	if (cur->_col == BLACK)
	{
		k++;
	}

	// 递归验证左右子树
	return _IsRBTree(cur->_left, k, blackCount) && _IsRBTree(cur->_right, k, blackCount);
}

template <class K, class V>
void RBTree<K, V>::_Inorder(Node* root)
{
	if (root == nullptr)
		return;

	_Inorder(root->_left);
	cout << root->_kv.first << ' ';
	_Inorder(root->_right);
}

template <class K, class V>
void RBTree<K, V>::_Leorder(Node* root)
{
	queue<Node*> q;
	q.push(root);
	int count = 1;
	while (!q.empty())
	{
		while (count)
		{
			Node* top = q.front();
			q.pop();
			count--;
			if (top)
			{
				q.push(top->_left);
				q.push(top->_right);
				cout << top->_col << ' ';
			}
			else
			{
				cout << "nullptr ";
			}
		}
		count = q.size();
		cout << endl;
	}
}
.SacaJawea
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++简单实现红黑树的插入
06-06
以下是关于红黑树插入操作的详细讲解。 红黑树有以下性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 ...
红黑树算法实现（C++版和C版）与PPT讲解
03-18
在本压缩包中，你将找到两种语言实现的红黑树算法——C++版和C版，以及一份关于红黑树的PPT讲解，这将有助于你深入理解和应用这种数据结构。 首先，我们来看红黑树的基本特性： 1. 每个节点都有颜色属性，可以是...
C++ | AVL树的规则及其插入过程的讲解与实现
凡事都是靠练习
08-26 431
手撕AVL树的插入逻辑
【C++】红黑树的插入实现
QiHai的博客
11-12 1435
特化AVL平衡二叉搜索树--红黑树的插入实现
【C++】红黑树插入过程详解
罅隙的博客
09-14 836
介绍红黑树的基本性质，重点讲解红黑树插入过程的实现
【C++】红黑树插入删除
fight_p的博客
12-14 1284
这是一篇关于红黑树插入删除为主要内容的文章，本文详细讲述了红黑树的插入情形以及如何解决，代码如何实现，当然最重要的就是红黑树的删除，虽然红黑树删除不简单，但是删除的无非就是叶子节点，一个孩子的节点，两个孩子的节点，被删节点是红色还是黑色。其中最重要的就是删除的黑色叶子节点这有些麻烦，其他的都很简单！本文把每个情况都详细罗列出来。其实看完之后红黑树的删除真的没有那么难！！！
C++红黑树
~
03-26 6479
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
C++ 红黑树 详细讲解
foodsx的博客
06-07 1008
C++ 红黑树 详细讲解
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 19万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
【C++ STL】-- 红黑树的插入实现
weixin_64609308的博客
12-10 779
详细图解，一步步讲解红黑树C++的插入实现，上万字讲解
C++之红黑树
cls的博客
05-23 1680
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 4.2.2 红黑树的性质 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的，但是没有连续的红节点 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径...
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
1. 容器（Containers）：这是STL的基础，它们是存储数据的对象，如`vector`(动态数组)、`list`(双向链表)、`set`(红黑树实现的集合)、`map`(关联数组)等。每个容器都有其特定的内存管理和访问特性，开发者可以根据...
c++ STL 详细讲解PPT版
05-11
常见的容器有vector（动态数组）、list（双向链表）、deque（双端队列）、set（红黑树实现的集合）、map（红黑树实现的关联数组）以及unordered_set和unordered_map（哈希表实现的集合和关联数组）。每个容器都有其...
C++自实现二叉树的基本操作
11-03
本文将详细讲解如何使用C++语言实现二叉树的基本操作，包括创建、销毁、插入、删除、查找和遍历，以及反转等操作。 1. **创建算法**： 创建二叉树分为创建空树和非空树。空树的创建只需分配一个空节点，非空树的...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1187
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
ROS参数服务器增删改查实操Python
m0_49289284的博客
07-24 1071
用Python实现了ROS参数服务器的增删改查
c++语言实现类似swoole扩展的项目实践
北风之神Boreas
07-24 368
项目本质其实是C++项目开发，学员学习后增加对C++技术栈的实践能力，毕竟互联网的核心基石依然是C/C++。 当你要改变以前吸收的知识来源于国内视频教程，国内文章教程 国内文章资料 转向全球老外大佬云集的github开源项目吸收时，就要学C和C++ 而你以前的IT技术就是国内的教程 国内的社区 国内的文章 ，但都是有局限的，所以要转向github社区吸收开源项目的东西来增强个人技术体系。 技术只来源于实践，不是光看，光记就会的东西，纸上得来终觉浅绝知此事要躬行。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 654
C++ primer plus 第16章string 类和标准模板库, 关联容器。
红黑树算法解析：节点后继与操作
"这篇文档是关于红黑树的算法介绍，由谭守标在安徽大学电子学院讲解。主要内容包括红黑树的概念、性质、旋转操作、插入操作、删除操作以及二叉查找树的相关算法，如中序遍历、查找算法等。" 红黑树是一种自平衡的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值