数据结构——红黑树

已于 2022-07-12 17:48:23 修改
阅读量379 收藏 3
点赞数 1
文章标签： 数据结构 算法
于 2022-07-12 16:06:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66821676/article/details/125745191
版权

研究契机

本学期学校开设数据结构课程，在力所能及范围内研究了几个问题，以供自己复习参考。

红黑树特征

红黑树（Red-Black Tree）是具有如下特征的二元查找树：

1．每一个结点或者是红色或者是黑色。

2．每个叶结点都是黑色。

3．如果一个结点是红色，那么它的两个孩子结点都是黑色。

4．从任何一个结点到所有以该结点为子树的叶结点的简单路径上拥有相同的黑色结点。如下图就是一个红黑树的实例：

一般叶结点不存放数据，作为哨兵用来表示已经到达叶结点。

对于红黑树我们可以证明如下定理：任何一个具有n 个内部结点的红黑树其高度至多为2log（n+1）。该定理决定了红黑树可以保证查找时间复杂性一定时O（logn）（具有和平衡树类似的性质）。

解题实践

由于本学期开设的课程设计中有相关题目，以学校课程设计中的题目为例：

①设计并实现Red-Black Tree 的ADT，该ADT 包括Tree 的组织存储以及其上的基本操作：包括初始化，查找，插入和删除等。并分析基本操作的时间复杂性。

②实现Red-Black Tree ADT 的基本操作演示（要求应用图形界面）。

③演示实例为依次插入A L G O R I T H M 并依同样的次序删除。

算法思想

根据题目要求，我们首先要实现红黑树的基本操作，包括初始化，查找，插入和删除等。而在之前，我们要设计红黑树输的基本数据结构，用结构体RBNodee表示，里有elementType类型的data存储结点元素，int类型的color代表该结点的颜色，初始值为RBNode_Red，RBNode类型的parent指向其父亲结点、lChild指向其左孩子结点，rChild指向其右孩子结点。

在实现具体操作前，我们先来了解一下红黑树的左旋和右旋，无论是左旋还是右旋都是对两个结点进行的操作，而在传值时，我们传其中父亲结点的值，左旋传入x，对x和x的右孩子y进行操作，右旋时传入y，对y和y的左孩子进行操作，注意：左旋和右旋时，进行操作的两个结点颜色互换

接下来考虑对红黑树各个操作的实现：

  1. 首先是红黑树的初始化，只需新建一个结点，将结点值赋给data，color改为RBNode_Black即可，其时间复杂度为o（1）。

  2. 然后是红黑树中元素的查找，首先将要插入的元素与根结点进行比较，若小于根结点，向左查找，若大于根结点，向右查找，找到位置，若未找到，返回NULL，其时间复杂度为o（log2n）。

  3. 红黑树的插入，规定p为操作结点的父结点，s为操作结点的叔叔结点，pp为操作结点的爷爷结点，我们首先要找到要插入的位置，规定我们插入的位置一定是一个叶子结点，而直接插入可能会破坏红黑树的性质，需分情况进行调整，且情况很多，比较复杂，并且需要用到递归，其时间复杂度为o（log2n）。

  4. 而红黑树的结点的删除则更加复杂，规定，删除结点为R，删除结点父结点为P，删除结点的兄弟结点为S，兄弟结点的左孩子为SL，右孩子为SR。我们首先需要找到要删除的结点，需要用到红黑树的查找函数，没有找到要删除的结点，直接返回，找到要删除的结点，需要分情况进行讨论，其时间复杂度为o（log2n）。

  5. 最后需要考虑的是如何打印红黑树，首先我们应求出红黑树的高度h。然后按照先序遍历的方式打印红黑树，我们设置红黑树每层之间的差距为dy，完全二叉树的叶子结点与父结点的横向差距为dx，先序遍历时传入一个参数i存储该节点的层数，再传入两个参数x，y代表要输出的坐标位置，i初始值为1，x，y初始值为根结点的位置，即函数原型为void printTree(RBNode* T,int i, int x, int y)，打印出根结点后依次为printTree(T->lChild, i + 1, x - d,y + dy); printTree(T->rChild, i + 1, x + d,y + dy);其中d = dx * 2h-i-1。

调试过程

在实现算法过程中，第一次出错是在插入算法写好，进行测试时。但是在检查算法后，并没有发现问题，对算法进行手工也没有问题，最终通过调试发现，在进行左旋右旋操作时，对根结点进行旋转之后，没有将根结点的指针进行改变。最终的解决方法是，在对根结点进行旋转时，并没有真正的旋转，而是将两个要旋转结点的值进行交换，然后进行一些操作，使之达到旋转的目的。

#define RBNode_Red 0
#define RBNode_Black 1
#include<stdio.h>
typedef char elementType;
typedef struct lBNode	//红黑树数据结构
{
	elementType data;	//存储数据
	int color = 0;		//初始颜色为红色
	struct lBNode* lChild, * rChild;
	struct lBNode* parent;
}RBNode, * RBTree;

void modulation(RBNode* s);		//红黑树调整函数
void modulation2(RBNode* p);	//红黑树删除时的调整函数
RBNode* pioneer(RBNode* p);		//求出p中序遍历的先驱结点

void initialRBTree(RBNode*& T, elementType x)	//初始化红黑树的根结点
{
	T = new RBNode;
	T->data = x;
	T->color = RBNode_Black;	//将根结点设为黑色
	T->lChild = NULL;
	T->rChild = NULL;
	T->parent = NULL;
}

void insertNode(RBNode* T, elementType x)	//向红黑树中插入结点
{
	if (T->data < x)	//根结点小于x时
	{
		if (T->rChild == NULL)	//若右子树不存在,即为插入位置
		{
			RBNode* p = new RBNode;
			p->data = x;
			p->lChild = NULL;
			p->rChild = NULL;
			T->rChild = p;
			p->parent = T;
			modulation(p);		//对新插入的结点进行调整
		}
		else     //若右子树存在，则递归插入
		{
			insertNode(T->rChild, x);
		}
	}
	else   //根结点大于x时
	{
		if (T->lChild == NULL)
		{
			RBNode* p = new RBNode;
			p->data = x;
			p->lChild = NULL;
			p->rChild = NULL;
			T->lChild = p;
			p->parent = T;
			modulation(p);		//对新插入的结点进行调整
		}
		else
		{
			insertNode(T->lChild, x);
		}
	}
}

void leftRotate(RBNode* s)		//红黑树左旋
{
	if (s->parent == NULL)		//s为根结点时
	{
		RBNode* p = s->rChild;
		elementType x;
		int color;

		//此处进行的操作没有改变根结点的位置，即不是真正意义上的左旋
		x = s->data;
		s->data = p->data;
		p->data = x;

		color = s->color;
		s->color = p->color;
		p->color = color;

		s->rChild = p->rChild;
		s->rChild->parent = s;
		p->rChild = p->lChild;
		
		//判断根结点是否存在左孩子
		if (s->lChild)
		{
			p->lChild = s->lChild;
			p->lChild->parent = p;
		}
		s->lChild = p;
	}
	else    //s不为根结点时
	{
		RBNode* p = s->rChild;
		p->parent = s->parent;
		//判断s为其父节点的哪个孩子结点
		if (s->parent->lChild == s)
		{
			s->parent->lChild = p;
		}
		else
		{
			s->parent->rChild = p;
		}
		s->parent = p;
		s->rChild = p->lChild;
		if (s->rChild)		s->rChild->parent = s;
		p->lChild = s;
	}
}

void rightRotate(RBNode* s)		//红黑树右旋
{
	if (s->parent == NULL)	//s为根结点时
	{
		RBNode* p = s->lChild;
		elementType x;
		int color;

		//此处进行的操作没有改变根结点的位置，即不是真正意义上的左旋
		x = s->data;
		s->data = p->data;
		p->data = x;

		color = s->color;
		s->color = p->color;
		p->color = color;

		s->lChild = p->lChild;
		s->lChild->parent = s;
		p->lChild = p->rChild;

		//判断根结点是否有右孩子
		if (s->rChild)
		{
			p->rChild = s->rChild;
			p->rChild->parent = p;
		}
		s->rChild = p;
	}
	else     //s不为根结点时
	{
		RBNode* p = s->lChild;
		p->parent = s->parent;
		//判断s为其父节点的哪个孩子结点
		if (s->parent->lChild == s)
		{
			s->parent->lChild = p;
		}
		else
		{
			s->parent->rChild = p;
		}
		s->parent = p;
		s->lChild = p->rChild;
		if (s->lChild)		s->lChild->parent = s;
		p->rChild = s;
	}
}

void modulation(RBNode* s)		//红黑树调整函数
{
	if (s->parent->color == RBNode_Black)	//s的父亲结点为黑色时不用调整
	{
		return;
	}
	RBNode* t = s->parent;
	RBNode* p = t->parent;
	if (p->lChild == t)	//如果s的父结点为其爷爷结点的左孩子
	{
		if (p->rChild == NULL || p->rChild->color == RBNode_Black)		//如果s的叔叔结点为黑色色，或不存在叔叔结点 
		{
			if (t->lChild == s)	//如果s为其父结点的左孩子
			{
				//变色进行右旋
				t->color = RBNode_Black;
				p->color = RBNode_Red;
				rightRotate(p);
			}
			else    //若s为父结点的右孩子
			{
				//先左旋后变色进行右旋
				leftRotate(t);
				s->color = RBNode_Black;
				p->color = RBNode_Red;
				rightRotate(p);
			}
		}
		else	//若叔叔结点为红色 
		{
			t->color = RBNode_Black;
			p->rChild->color = RBNode_Black;

			if (p->parent != NULL)	//如果爷爷结点不为为根结点，继续调整
			{
				p->color = RBNode_Red;
				modulation(p);
			}
		}
	}
	else    //如果s的父结点为其爷爷结点的右孩子，一切对称
	{
		if (p->lChild == NULL || p->lChild->color == RBNode_Black)		//如果s的叔叔结点为黑色，或不存在叔叔结点 
		{
			if (t->rChild == s)	//如果s为其父结点的右孩子
			{
				//变色进行左旋
				t->color = RBNode_Black;
				p->color = RBNode_Red;
				leftRotate(p);
			}
			else    //若s为父结点的左孩子
			{
				//先右旋后变色进行左旋
				rightRotate(t);
				s->color = RBNode_Black;
				p->color = RBNode_Red;
				leftRotate(p);
			}
		}
		else	//若叔叔结点为红色 
		{
			t->color = RBNode_Black;
			p->lChild->color = RBNode_Black;

			if (p->parent != NULL)	//如果爷爷结点不为为根结点，继续调整
			{
				p->color = RBNode_Red;
				modulation(p);
			}
		}
	}

}

//void printTree(RBNode* T, int i)
//{ //t代表遍历结点的位置，m为最后一个结点所在位置，i代表所在层次
//	int j;
//	if (T != NULL) {
//		printTree(T->rChild, i + 1); //访问右子树
//
//		for (j = 0; j < i - 1; ++j) printf("\t");
//		printf("%c", T->data);
//		if (T->color == RBNode_Red)
//		{
//			printf("R\n");
//		}
//		else
//		{
//			printf("B\n");
//		}
//
//		printTree(T->lChild, i + 1); //访问左子树
//	}
//}

RBNode* searchNode(RBNode* T, elementType x)	//查找函数，查找x所在结点
{
	if (T == NULL)
	{
		return NULL;
	}
	if (T->data > x)	//结点元素大于x，向左查找
	{
		return searchNode(T->lChild, x);
	}
	else if (T->data < x)		//结点元素小于x，向右查找
	{
		return searchNode(T->rChild, x);
	}
	else
	{
		return T;
	}
}

void deleteNode(RBNode*& p)		//删除结点p
{
	if (p->lChild == NULL && p->rChild == NULL)		//如果所删除的结点没有子节点
	{
		if (p->color == RBNode_Red)	//当p为红色时，直接删除
		{
			if (p->parent->lChild == p)
			{
				p->parent->lChild = NULL;
			}
			else
			{
				p->parent->rChild = NULL;
			}
			delete p;
		}
		else  //当p为黑色时
		{
			if (p->parent == NULL)	//若p为根结点
			{
				delete p;
				p = NULL;
			}
			else
			{
				modulation2(p);		//对黑色要删除的结点进行调整
				if (p->parent->lChild == p)
				{
					p->parent->lChild = NULL;
				}
				else
				{
					p->parent->rChild = NULL;
				}
				delete p;
			}
		}
	}
	else if (p->lChild == NULL)	//若P只有右孩子结点
	{
		RBNode* son = p->rChild;

		//如果p为根结点
		if (p->parent == NULL)
		{
			p->data = son->data;
			p->rChild = NULL;
			delete son;
		}
		else 
		{
			if (p->parent->lChild == p)
			{
				p->parent->lChild = son;
			}
			else
			{
				p->parent->rChild = son;
			}
			son->color = RBNode_Black;
			son->parent = p->parent;
			delete p;
		}
		
	}
	else if (p->rChild == NULL)	//若只有左孩子结点
	{
		RBNode* son = p->lChild;
		//如果p为根结点
		if (p->parent == NULL)
		{
			p->data = son->data;
			p->lChild = NULL;
			delete son;
		}
		else
		{
			if (p->parent->lChild == p)
			{
				p->parent->lChild = son;
			}
			else
			{
				p->parent->rChild = son;
			}
			son->color = RBNode_Black;
			son->parent = p->parent;
			delete p;
		}
	}
	//如果p既有左孩子又有右孩子
	else
	{
		//找到p的前驱结点
		RBNode* pion = pioneer(p);
		p->data = pion->data;

		deleteNode(pion);
	}
}

void deleteNode(RBNode*& T, elementType x)
{
	//找到要删除的结点
	RBNode* p = searchNode(T, x);
	if (p == NULL)
	{
		return;
	}
	//若p为根结点，且没有孩子结点
	if (p->parent == NULL && p->lChild == NULL && p->rChild == NULL)
	{
		deleteNode(T);
	}
	else
	{
		deleteNode(p);
	}
}

void modulation2(RBNode* p)		//对所删除结点为黑色的叶子结点进行调整
{
	RBNode* bro;
	if (p->parent == NULL)
	{
		return;
	}
	if (p->parent->lChild == p)		//如果p为其父结点的左孩子
	{
		bro = p->parent->rChild;
		if (bro->color == RBNode_Black)	//如果兄弟结点为黑色
		{
			if (bro->rChild && bro->rChild->color == RBNode_Red)		//若其有右孩子，且为红色
			{
				bro->rChild->color = RBNode_Black;
				bro->color = bro->parent->color;
				bro->parent->color = RBNode_Black;

				leftRotate(bro->parent);
			}
			else if (bro->lChild && bro->lChild->color == RBNode_Red)		//若其有左孩子其为红色
			{
				bro->lChild->color = RBNode_Black;
				bro->color = RBNode_Red;
				rightRotate(bro);
				//转换成上面情况，继续调整
				modulation2(p);
			}
			else    //如果其孩子没有红色结点
			{
				if (p->parent->color == RBNode_Red)
				{
					p->parent->color = RBNode_Black;
					bro->color = RBNode_Red;
				}
				else
				{
					bro->color = RBNode_Red;
					modulation2(p->parent);
				}
			}
		}
		else    //如果兄弟结点为红色
		{
			bro->color = RBNode_Black;
			bro->parent->color = RBNode_Red;
			leftRotate(bro->parent);
			modulation2(p);
		}
	}
	else     //如果p为父结点的右孩子，一切对称
	{
		bro = p->parent->lChild;
		if (bro->color == RBNode_Black)	//如果兄弟结点为黑色
		{
			if (bro->lChild && bro->lChild->color == RBNode_Red)		//若其有左孩子，且为红色
			{
				bro->lChild->color = RBNode_Black;
				bro->color = bro->parent->color;
				bro->parent->color = RBNode_Black;

				rightRotate(bro->parent);
			}
			else if (bro->rChild && bro->rChild->color == RBNode_Red)		//若其有右孩子，且为红色
			{
				bro->rChild->color = RBNode_Black;
				bro->color = RBNode_Red;
				leftRotate(bro);
				//转换成上面情况，继续调整
				modulation2(p);
			}
			else    //如果其孩子没有红色结点
			{
				if (p->parent == NULL)
				{
					return;
				}
				if (p->parent->color == RBNode_Red)
				{
					p->parent->color = RBNode_Black;
					bro->color = RBNode_Red;
				}
				else
				{
					bro->color = RBNode_Red;
					modulation2(p->parent);
				}
			}
		}
		else    //如果兄弟结点为红色
		{
			bro->color = RBNode_Black;
			bro->parent->color = RBNode_Red;
			rightRotate(bro->parent);
			modulation2(p);
		}
	}

}

RBNode* pioneer(RBNode* p)		//求出p中序遍历的先驱结点
{
	RBNode* pion;	//表示要返回的结点
	pion = p->lChild;
	while (pion->rChild)
	{
		pion = pion->rChild;
	}
	return pion;
}

void deleteTree(RBNode* T)		//删除整棵树
{
	if (T)
	{
		//后序遍历
		deleteTree(T->lChild);
		deleteTree(T->rChild);
		delete T;
	}
}
一介拔刀斋
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
ADT: Red-Black Tree 红黑树详解(附完整实现)
超悠閒的博客
02-15 598
ADT: Red-Black Tree 红黑树详解(附完整实现) 文章目录ADT: Red-Black Tree 红黑树详解(附完整实现)简介参考完整示例代码正文红黑树的前身今世从 BST 到 AVL从 AVL 到 RB-Tree红黑树的规则代码实现操作接口Color 颜色定义 & Node 节点结构 & 初始化工具方法Rotate 旋转Relative 查找亲戚Tansplant 取代`height()` 获取树的黑高`insert(K key, T data)` 插入节点红黑树插入总结红
图解红黑树
greenhand_coder
07-20 184
学习红黑树前，我们要先知道红黑树存在的意义是什么 这就要说到平衡二叉树了。我们都知道，平衡二叉树求的是绝对的平衡，平衡因子差绝对值是不能超过1的，所以每次调整都很费劲，插入删除操作旋转很麻烦很麻烦，相信敲过平衡二叉树代码的都知道。苏联的科学家提出了一种不那么平衡但是高度又比二叉搜索树小一点的树，叫做红黑树。 我们知道二叉平衡树通过它的规则，平衡因子来调节树的高度的。 对应的，红黑二叉树也是用规则来...
红黑树（图文详解+C语言200行代码实现）
zhao_Tao_WA的博客
07-04 2694
本文以图文形式详细介绍了红黑树的性质以及各种调整策略，包括插入调整和删除调整，最后以200行精简的C语言代码实现了红黑树
mininet编程实现交换机规则的插入、删除与修改。_红黑树的原理 (插入+ 删除) 案例分析
weixin_39765588的博客
11-26 277
1.红黑树的概念红黑树是一种自平衡的二叉查找树，是一种高效的查找树。它是由 Rudolf Bayer 于1978年发明，在当时被称为对称二叉 B 树(symmetric binary B-trees)。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的红黑树。红黑树具有良好的效率，它可在 O(logN) 时间内完成查找、增加、删除等操作。因此，红黑...
关于红黑树插入过程的正确描述
frcoder的博客
08-07 1295
前言 鉴于网上其它教程中对于红黑树的插入操作的叙述并不十分清楚准确全面，所以本文主要是对插入过程进行介绍。参见第3节。 本文对于红黑树的定义、概念、性质、以及操作过程的图形化表述等内容的叙述较为简略，请参考官方定义或其他教程。 1. 红黑树的基础概念 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位
红黑树
成天天的博客
03-04 925
参考博客：http://www.cnblogs.com/skywang12345/p/3245399.html红黑树：一种二叉查找树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似于平衡的（有性质5保证）。树中每个结点包含5个属性：color、key、left、...
算法和数据结构——左程云.zip
最新发布
06-16
这份名为"算法和数据结构——左程云.zip"的压缩包文件，很可能是他分享的一套全面的数据结构学习资源，特别适合大学生作为学习数据结构的参考资料。 数据结构是组织和存储数据的方式，它决定了数据的访问和操作效率...
数据结构实验——树和二叉树子系统
07-31
这对于后续学习更复杂的数据结构如AVL树、红黑树，以及在实际问题中应用二叉树算法，如二分查找、 Huffman编码等，都具有基础性的指导作用。通过亲手编写代码，不仅能巩固理论知识，还能提升编程技能和问题解决能力...
广工数据结构实验——平衡二叉树
07-06
在这个实验中，`平衡二叉树数据结构实验.cpp`很可能是实现平衡二叉树（可能是AVL树或红黑树）的C++源代码。它可能包含了基本的二叉树操作（如插入、删除和查找）以及平衡调整算法的实现。源代码可以帮助我们理解如何...
红黑树 实例
08-02
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。此资源免费，各位C友如有意见，可提出
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
算法基础--从TreeMap看红黑树
verzqli的博客
09-18 443
红黑树（Red Black Tree） 是一种自平衡二叉查找树,相对于普通的二叉树具有通过自旋和变色来保持树两端保持平衡的特点，从而获得较高的查找性能。 红黑树的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除。 二叉查找树 在正式介绍红黑树前，先简要介绍下二叉查找树（BST），二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： ...
数据结构之红黑树简介
weixiaohuai的博客
11-14 3478
一、红黑树定义 红黑树是二叉查找树，二叉查找树这一数据结构并不难，而红黑树之所以难是难在它是自平衡的二叉查找树，在进行插入和删除等可能会破坏树的平衡的操作时，需要重新自处理达到平衡状态。 红黑树是一种含有红色和黑色节点并能自平衡的二叉查找树，红黑树和其他二叉查找树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的性质，从而获得较高的查找性能。它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的：它可以在 O(log n) 时间内做查找，插入和删除，这里的 n 是树中元素的
红黑树的结构
XHumble的博客
07-08 227
红黑树的结构：为了后续实现关联式容器简单，所以为红黑树中增加了一个头节点，头节点也是黑色，它的parent指针域指向红黑树的根节点，left指针域指向红黑树的最小节点（最左侧节点），right指针域指向红黑树中的最大节点（最右侧节点） ...
红黑树（附完整C代码）
热门推荐
weewqrer的博客
07-09 2万+
版权声明：原创不易，转载请注明转自weewqrer 红黑树红黑树简介首先红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或者BLACK。通过对一条从根节点到NIL叶节点（指空结点或者下面说的哨兵）的简单路径上各个结点在颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡的。 用途红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可
java数据结构 红黑树
08-21
- *3* [Java数据结构——红黑树](https://blog.csdn.net/weixin_30699463/article/details/95256212)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值