搞懂红黑树及其应用场景

最新推荐文章于 2024-03-22 18:15:00 发布
最新推荐文章于 2024-03-22 18:15:00 发布
阅读量4.7k 收藏 24
点赞数 2
分类专栏： 算法与设计模式 文章标签： 数据结构 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WULI_LIN/article/details/110250771
版权

红黑树

1 性质

1. 每个结点是红的或黑的
2. 根结点是黑的
3. 每个叶子结点是黑色的
4. 如果一个结点是红的，则它的两个儿子都是黑的（不能有连续两个红色结点）
5. 对每个结点，从该节点到其子孙结点的所有路径上的包含相同数目的黑结点

2 插入

  • 插入结点时默认是插入的红色结点，因为只有插入红色结点，在没调整的情况下，才能保证性质 5（所有路径包含相同数目的黑结点）
  • 因为插入的结点为红色，因此如果父结点也为红色，则需要调整

调整方法

1). 插入结点为根结点 --> 变色
2). 插入结点的叔结点为红色 --> 父与叔结点变为黑色，祖结点变为红色，并将祖结点作为新插入的结点
3). 插入结点的叔结点为黑色 --> 这里要分 4 种情况, 下面解释 -->（/ \ < >）

  • 调整方法有变色和旋转
调整方法 3) 详细说明
  • 此处方法参考网上的一个方法，将分为 4 种情况，4 种情况分别用 (/ \ < >) 四个符号表示，最终目的是变成 ⋀
  1. 当插入结点、父结点、祖结点在一条线上的时候，如图即可用符号 / 和 \ 表示 ：
    在这里插入图片描述
  • 此处用上面左图来说明调整方法，右图变换同理
    在这里插入图片描述
    –> 那么对于 / ，把祖节点扳下来，怎么扳？你用右手向下扳最方便，让 / 变成 ⋀，即右旋
    –> 然后将父结点变为黑色，祖结点变为红色，父节点做为当前结点
  1. 当插入结点、父结点、祖结点不在一条线上时，如图即可用符号 < 和 > 表示：
    在这里插入图片描述
  • 此处用上面右图来说明调整方法，左图变换同理
    在这里插入图片描述

–> 那么对于 >，首先把父结点右旋 ( 将nil算进去就是一个 / )，让 < 变成
–> 然后 \ 按上面1的方法左旋，即可变成 ⋀
–> 最后按上面1的方法完成变色即可

左/右旋补充说明

在这里插入图片描述

3 删除

  • 删除的主要思想：寻找继子，把继子的值赋值给待删除的结点，最后删除继子

以下以xyz来表示结点：
x —> 待删除的结点
y —> 继子结点（实际删除的是这个结点）
z —> 轴心结点（继子的子结点，后续调整以它开始计算黑高）

如何找继子y

  1. 当x的子树不满（没有子树或只有一边子树），y为x本身
  2. 当x拥有左右子树，y为x右子树的最左（最小）结点 ------> y可理解为中序遍历时x的下一个结点

当删除的y为黑色时需要调整 因为影响了黑高
调整思想：（以下所说的子树包含z的父结点）

  • 因为黑高 -1，因此就要通过调整来达到黑高平衡 —> z子树+1 或 z结点的兄弟子树-1（递归上去）
  • 1. 想办法将z子树+1
    因为z子树-1，首先要想办在z子树上找一个红色结点变为黑色；
    如果z子树没有红色结点，就去z子树的兄弟子树上找红色结点，如果有就通过旋转将它调整到z子树上，然后变色；
  • 2. z子树没有办法+1，就想办法将兄弟子树-1（z的父结点下的这棵子树就-1
    如果兄弟子树也没有红色，那么就可以通过兄弟变为红色，使z和兄弟子树都-1（这样父结点下的这棵子树就-1了），然后父结点就可作为新的x去调整
  • 调整时先变色，后旋转
    在这里插入图片描述

调整方法总结
N轴心结点，S兄弟结点，P父结点
说明：N子树黑高为-1，S子树黑高为0

  1. 兄红
    S和P交换颜色(N子树-1，S子树0) --> 以P进行旋转(N子树-1，S子树0) --> N子树有红色结点（原P）可变黑色（N子树0，S子树0）
  2. 兄黑
    2.1 兄子树全黑
    2.1.1 P为红：P与S交换颜色(N子树0，S子树0)
    2.1.2P为黑：S结点变为红色(N子树-1，S子树-1，P子树-1) --> 因为P子树-1，所以将P作为N进行平衡处理
    2.2 兄子树不全黑
    2.2.1 红兄子与兄S在同一侧：该侧红兄子变黑(N子树-1，S子树+1) --> 以P进行旋转(N子树0，S子树0)
    2.2.2 红兄子与兄S不在同一侧：S和该红兄子交换颜色 --> P-S(红)-S子红(黑)形成 > 或 <，因此以S往同侧进行旋转，变为 \ 或 / （N子树-1，S子树0，但将S与红兄子变在同一侧）–> 按2.2.1进行调整

全部代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef enum _node_color{
	RED = 1,
	BLACK
} EN_NODE_COLOR;

typedef int KEY_TYPE;

typedef struct _rbtree_node {
	unsigned char color;
	KEY_TYPE key;
	void *value;

	struct _rbtree_node *left;
	struct _rbtree_node *right;
	struct _rbtree_node *parent;
} ST_RBTREE_NODE;

typedef struct _rbtree {
	ST_RBTREE_NODE *root;
	ST_RBTREE_NODE *nil;
} ST_RBTREE;

ST_RBTREE_NODE *rbtree_mini(ST_RBTREE *T, ST_RBTREE_NODE *x)
{
	while (x->left != T->nil)
	{
		x = x->left;
	}

	return x;
}

ST_RBTREE_NODE *rbtree_successor(ST_RBTREE *T, ST_RBTREE_NODE *x)
{
	return rbtree_mini(T, x->right);
}

void rbtree_left_rotate(ST_RBTREE *T, ST_RBTREE_NODE *x)
{
	ST_RBTREE_NODE *y = x->right;

	x->right = y->left;
	if (y->left != T->nil)
	{
		y->left->parent = x;
	}

	if (x->parent == T->nil)
	{
		T->root = y;
	}
	else if (x == x->parent->left)
	{
		x->parent->left = y;
		y->parent = x->parent;
	}
	else
	{
		x->parent->right = y;
		y->parent = x->parent;
	}

	x->parent = y;
	y->left = x;
}

void rbtree_right_rotate(ST_RBTREE *T, ST_RBTREE_NODE *x)
{
	ST_RBTREE_NODE *y = x->left;

	x->left = y->right;
	if (y->right != T->nil)
	{
		y->right->parent = x;
	}

	if (x->parent == T->nil)
	{
		T->root = y;
	}
	else if (x == x->parent->right)
	{
		x->parent->right = y;
		y->parent = x->parent;
	}
	else
	{
		x->parent->left = y;
		y->parent = x->parent;
	}

	x->parent = y;
	y->right = x;
}

void rbtree_insert_fixup(ST_RBTREE *T, ST_RBTREE_NODE *x)
{
	while (x->parent->color == RED)
	{
		if (x->parent == x->parent->parent->left)
		{
			ST_RBTREE_NODE *y = x->parent->parent->right;

			if (y->color == RED)		// 叔结点为红色
			{
				x->parent->color = BLACK;
				y->color = BLACK;
				x->parent->parent->color = RED;

				x = x->parent->parent;
			}
			else
			{
				if (x == x->parent->right)					// 为 < 形式
				{
					x = x->parent;
					rbtree_left_rotate(T, x);
				}

				x->parent->color = BLACK;					// 为 / 形式
				x->parent->parent->color = RED;
				rbtree_right_rotate(T, x->parent->parent);
			}
		}
		else
		{
			ST_RBTREE_NODE *y = x->parent->parent->left;

			if (y->color == RED)		// 叔结点为红色
			{
				x->parent->color = BLACK;
				y->color = BLACK;
				x->parent->parent->color = RED;

				x = x->parent->parent;
			}
			else
			{
				if (x == x->parent->left)					// 为 > 形式
				{
					x = x->parent;
					rbtree_right_rotate(T, x);
				}

				x->parent->color = BLACK;					// 为 \ 形式
				x->parent->parent->color = RED;
				rbtree_left_rotate(T, x->parent->parent);
			}
		}
	}

	T->root->color = BLACK;
}

void rbtree_insert(ST_RBTREE *T, ST_RBTREE_NODE *x)
{
	ST_RBTREE_NODE *y = T->root;
	ST_RBTREE_NODE *z = T->nil;

	while (y != T->nil)
	{
		z = y;
		if (x->key < y->key)
		{
			y = y->left;
		}
		else if (x->key > y->key)
		{
			y = y->right;
		}
		else
		{
			return;
		}
	}

	x->parent = z;
	if (z == T->nil)
	{
		T->root = x;
	}
	if (x->key < z->key)
	{
		z->left = x;
	}
	else
	{
		z->right = x;
	}

	x->left = T->nil;
	x->right = T->nil;
	x->color = RED;

	rbtree_insert_fixup(T, x);
}

void rbtree_delete_fixup(ST_RBTREE *T, ST_RBTREE_NODE *N)
{
	while ((N != T->root) && (N->color == BLACK))
	{
		if (N == N->parent->left)		// 兄在右
		{
			ST_RBTREE_NODE *S = N->parent->right;

			if (S->color == RED)		// 3.2兄红
			{
				S->color = BLACK;
				N->parent->color = RED;
				rbtree_left_rotate(T, N->parent);

				S = N->parent->right;
			}

			if (S->color == BLACK)		// 2.兄黑
			{
				if (S->left->color == BLACK && S->right->color == BLACK)		// 2.1 兄子全黑
				{
					S->color = RED;
					N = N->parent;		// parent如果为红，则相当于与兄交换颜色
				}
				else															// 2.2 兄子不全黑
				{
					if (S->right->color == BLACK)
					{
						S->left->color = BLACK;
						S->color = RED;

						rbtree_right_rotate(T, S);
						S = N->parent->right;
					}


					S->color = N->parent->color;
					S->right->color = BLACK;
					rbtree_left_rotate(T, S->parent);

					N = T->root;
				}
			}
		}
		else
		{
			ST_RBTREE_NODE *S = N->parent->left;

			if (S->color == RED)		// 3.1兄红
			{
				S->color = BLACK;
				N->parent->color = RED;
				rbtree_right_rotate(T, N->parent);

				S = N->parent->left;
			}

			if (S->color == BLACK)		// 2.兄黑
			{
				if (S->right->color == BLACK && S->left->color == BLACK)		// 2.1 兄子全黑
				{
					S->color = RED;
					N = N->parent;		// parent如果为红，则相当于与兄交换颜色
				}
				else															// 2.2 兄子不全黑
				{
					if (S->left->color == BLACK)
					{
						S->right->color = BLACK;
						S->color = RED;

						rbtree_left_rotate(T, S);
						S = N->parent->left;
					}


					S->color = N->parent->color;
					S->left->color = BLACK;
					rbtree_right_rotate(T, S->parent);

					N = T->root;
				}
			}
		}
	}

	N->color = BLACK;
}

ST_RBTREE_NODE *rbtree_delete(ST_RBTREE *T, ST_RBTREE_NODE *x)
{
	ST_RBTREE_NODE *y = T->nil;
	ST_RBTREE_NODE *z = T->nil;

	if (x == T->nil)
	{
		printf("delete node is nil\n");
		return T->nil;
	}

	if ((x->left == T->nil) || (x->right == T->nil))	// 子树不满
	{
		y = x;
	}
	else
	{
		y = rbtree_successor(T, x);
	}

	if (y->left != T->nil)
	{
		z = y->left;
	}
	else if (y->right != T->nil)
	{
		z = y->right;
	}
	z->parent = y->parent;

	if (y->parent == T->nil)
	{
		T->root = z;
	}
	else if (y == y->parent->left)
	{
		y->parent->left = z;
	}
	else
	{
		y->parent->right = z;
	}

	if (y != x)
	{
		x->key = y->key;
		x->value = y->value;
	}

	if (y->color == BLACK)
	{
		rbtree_delete_fixup(T, z);
	}

	return y;
}

ST_RBTREE_NODE *rbtree_search(ST_RBTREE *T, KEY_TYPE key)
{
	ST_RBTREE_NODE *x = T->root;

	while (x != T->nil)
	{
		if (key < x->key)
		{
			x = x->left;
		}
		else if (key > x->key)
		{
			x = x->right;
		}
		else
		{
			return x;
		}
	}

	return T->nil;
}

void rbtree_traversal(ST_RBTREE *T, ST_RBTREE_NODE *node)
{
	if (node != T->nil)
	{
		rbtree_traversal(T, node->left);
		printf("key:%d, color:%d\n", node->key, node->color);
		rbtree_traversal(T, node->right);
	}
}

int main(void)
{
	int array[20] = {8, 46, 70, 82, 32, 57, 38, 92, 48, 36, 74, 45, 39, 34, 84, 42, 59, 95, 20, 75};
	int len = sizeof(array) / sizeof(array[0]);
	ST_RBTREE_NODE *node = NULL;
	int i;

	ST_RBTREE *T = (ST_RBTREE *)malloc(sizeof(ST_RBTREE));
	if (T == NULL)
	{
		printf("malloc T failed\n");
		return -1;
	}
	memset(T, 0, sizeof(ST_RBTREE));

	T->nil = (ST_RBTREE_NODE *)malloc(sizeof(ST_RBTREE_NODE));
	if (T->nil == NULL)
	{
		printf("malloc T->nil failed\n");
		free(T);
		return -2;
	}
	memset(T->nil, 0, sizeof(ST_RBTREE));
	T->nil->color = BLACK;
	T->root = T->nil;

	node = T->nil;
	for (i = 0; i < len; i++)
	{
		node = (ST_RBTREE_NODE *)malloc(sizeof(ST_RBTREE_NODE));
		node->key = array[i];
		node->color = RED;
		node->value = NULL;

		rbtree_insert(T, node);
	}

	rbtree_traversal(T, T->root);

	printf("-----------------------------------\n");
	ST_RBTREE_NODE *del_cur = T->nil;
	rbtree_delete(T, rbtree_search(T, 74));
	if (del_cur != T->nil)
	{
		free(del_cur);
		del_cur = NULL;
	}

	rbtree_traversal(T, T->root);

	return 0;
}

总结用到红黑树的地方

参考文章：https://www.cnblogs.com/but999/p/12643956.html

  1. java8 hashmap中链表转红黑树。
  2. epoll在内核中的实现，用红黑树管理事件块（文件描述符）。
  3. Java的TreeMap实现
  4. linux进程调度Completely Fair Scheduler,用红黑树管理进程控制块
  5. nginx中，用红黑树管理timer
WULI_LIN
关注
  • 2
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Java语言实现的rbtree红黑树.zip
03-21
红黑树（Red-Black Tree...掌握红黑树的原理和操作，对于提升编程技能，尤其是处理效率要求高的场景，具有重要意义。通过Java实现的红黑树，开发者可以直观地看到代码层面的实现细节，有助于加深对这一数据结构的理解。
java算法- 红黑树
灰猫
01-07 234
treeMap 也是使用红黑树实现的 package com.numberone.tree; /** * 红黑树 */ public class RBTree<T extends Comparable<T>> { private final RBTreeNode<T> root; //node number private j...
红黑树的简介及应用
最新发布
迈达量化的博客
03-22 451
其中一种情况是，如果插入的节点的父节点和叔节点都是红色的，那么可以通过改变颜色和旋转操作来保持红黑树的性质。通过将交易数据按照不同的维度（如交易时间、交易品种等）存储在红黑树中，可以方便地进行数据查询、排序和聚合操作，从而得出交易数据的有用信息和结论。通过将交易策略的关键指标（如股票价格、交易量等）存储在红黑树中，可以快速地进行查询和比较操作，从而提高交易策略的执行速度和准确性。交易订单管理：红黑树可以用于管理交易订单，通过将订单按照价格或时间等关键指标进行排序，可以快速地查找、插入和删除订单。
红黑树及其应用介绍（万字长文）
sinat_30545761的博客
08-30 629
红黑树是一种特殊的二叉查找树，它遵循了特定的规则使得其具有了平衡性。红黑树在很多领域中都有广泛的应用，例如操作系统、数据库、图形学等。它的平衡性和高效的操作性能使得它成为一种非常优秀的数据结构。
红黑树的用途和实现
twopq的博客
11-08 3143
一、红黑树用途在哪里？ 1 map–> 2 nginx–> 3 定时器–> 4 cfs （进程调度的集合 ）（操作系统中用红黑树存储的集合）（查找速度快，有顺序） 5 内存管理（红黑树的平衡关系）； 问题：典型的malloc的内存碎片？ 解答：一块内存对应一个key； key指向的内存的地址 加上长度就是对内存碎片的管理， key value -->查找。 问题：红黑树有什么应用呢？ 1>大多数自平衡BST(self-balancing BST) 库函数都是用红黑树实现的，比如
红黑树的优势_红黑树在linux中的3种应用场景，看完终身难忘
weixin_29382705的博客
01-05 644
前言近期需要使用红黑树进行操作。此文目的只为巩固rbtree的一些概念和用法。代码原型为linux 中的rbtree下图为一个红g关于红黑树的概念有的人会想到RB，红黑树这个名词大家都听过，那红黑树在这过程中他用在那里呢，有的朋友说红黑树用在面试中，有的朋友说始终体会不到红黑树的优势到底在哪里，现在呢跟大家讲一下，在面试中红黑树出现的概率是很高的，大家记住哦《面试中红黑树出现的概率是很高的》有的人...
红黑树初解
qq_35540164的博客
08-22 763
红黑树初解 今天来复习一下红黑树的知识点，推荐51CTO这个微信公众号。 学过数据结构都知道二叉树的概念，而又有多种比较常见的二叉树类型，比如完全二叉树、满二叉树、二叉搜索树、均衡二叉树、完美二叉树等。 今天我们要说的红黑树就是就是一棵非严格均衡的二叉树，均衡二叉树又是在二叉搜索树的基础上增加了自动维持平衡的性质，插入、搜索、删除的效率都比较高。红黑树也是实现 TreeMap 存储结构的基石。 二...
红黑树原理详解
08-03
红黑树是一种自平衡的二叉查找树，因其良好的性能特点被广泛应用于多种场景中，包括操作系统中的内存管理、文件系统以及各种数据结构库中。本文旨在深入解析红黑树的基本原理及其实现细节。 #### 红黑树的由来 ...
轻松搞定面试中的红黑树问题
11-27
本文将深入探讨红黑树的相关概念及其应用场景，帮助读者更好地理解和掌握这一重要的数据结构。 #### 1. STL中的`set`底层使用的是什么数据结构？ C++标准模板库（STL）中的`set`容器底层使用的是红黑树（Red-Black...
红黑树及其源程序(pdf)
09-15
### 红黑树及其源程序解析 #### 红黑树简介 红黑树是一种自平衡二叉查找树，其特性在于通过特定的颜色标记（红色或黑色）和旋转操作来确保树的平衡，从而保证了操作的时间复杂度在最坏情况下也能保持为O(log n)，...
红黑树代码
05-07
通过阅读和分析这段代码，可以深入理解红黑树的工作原理及其在实际编程中的应用。 总的来说，红黑树是计算机科学中重要的数据结构之一，理解和掌握其原理对于提升编程能力，尤其是处理动态数据集时的性能优化至关...
红黑树（Red-Black tree）
学习日常分享
02-19 1760
红黑树定义 Red-Black tree, 简称RB-Tree 它是在1972年由鲁道夫·贝尔发明的，他称之为“对称二叉B树”，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的 特点：利用对树中的结点 “红黑着色”的要求，降低了平衡性的条件，达到局部平衡，有着良好的最坏情况运行时间，它可以在O(log n)时间内做查找，插入和删除，这里的n是树中元素的数目。 红黑树的应用 典型的用途是：关联数组 C++ STL中的关联式容器：集合set、多
红黑树的由来，特性，原理以及适用场景分析
Alan-zzx的博客
11-16 2819
注意：本文不涉及红黑树的具体实现，并且默认读者已经对二叉树，二叉查找树，AVL树等已经了解并熟悉。 一、平衡二叉查找树 定义：树中任意一个节点的左右子树高度差不大于1。 AVL树是一种严格按照定义来实现的平衡二叉查找树，所以，它的查找效率非常稳定，是O(log n)，由于严格按照左右子树高度差不大于一的规则，插入和删除操作中需要大量的操作来保持树的平衡，比较耗时。 因此，AVL树适用于大量查询，少...
红黑树概念及应用（c++）
weixin_45338913的博客
03-06 391
红黑树概念及应用
红黑树的定义与运用场景
热门推荐
ZCC的专栏
06-04 1万+
一、定义 红黑树的五个性质： 一般的，红黑树(一棵自平衡的排序二叉树)，满足以下性质，即只有满足以下性质的树，我们才称之为红黑树： 1）每个结点要么是红的，要么是黑的。 2）根结点是黑的。 3）每个叶结点，即空结点（NIL）是黑的。 4）如果一个结点是红的，那么它的俩个儿子都是黑的。 5）对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点。 抓住了红黑树的那5个性...
红黑树介绍和示例，以及在linux内核中的一些应用
szqy00的博客
08-27 1022
红黑树的自平衡特性确保了定时器事件的高效处理，提高定时器查找和触发的效率。每个运行中的进程都有一个进程控制块（进程描述符struct task_struct），这些块通过红黑树进行组织和调度，进程们都在进程调度器的红黑树中维护一个节点，通过对红黑树进行适当的旋转和平衡，这样可以根据进程的优先级和其他因素轻松地查找和选择下一个要运行的进程。虽然红黑树的查找操作在平均情况下具有较好的性能（O(log n)），但对于大量的读取操作而言，与无序数组相比，它可能有较高的性能开销，因为它需要维护平衡。
深入解析红黑树（RB-Tree）：原理、操作及应用
无敌岩雀的博客
03-17 1775
红黑树作为一种自平衡的二叉搜索树，在计算机科学领域中占据着重要的地位。它的设计旨在在维持树的平衡性的同时，保证各种操作的时间复杂度始终稳定在较低水平。红黑树的灵活性和高效性使得它成为众多编程语言和系统实现中不可或缺的数据结构之一。本文将带领读者深入探究红黑树的结构与原理。（c++实现）
C++——红黑树超详细讲解~~~~
陌上人如玉，公子世无双。
11-23 1958
红黑树： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质： 每个结点不是红色就是黑色。 根节点是黑色的。 如果一个节点是红色的，则它的两个孩子结点是黑色的。 对于每个结点，从该结点到其所有后代叶结点...
[**15.为什么要使用红黑树及其常用场景？**](#15)
06-10
红黑树是一种自平衡的二叉搜索树，它通过对插入和删除操作进行自动调整来保持树的平衡。红黑树的结构特点是每个节点都有一个颜色属性，可以是红色或黑色，同时满足以下性质： 1. 每个节点要么是黑色，要么是红色。 2. 根节点是黑色。 3. 每个叶子节点（NIL节点）是黑色的。 4. 如果一个节点是红色的，则它的两个子节点都是黑色的。 5. 对于每个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑节点。 红黑树的常用场景包括： 1. 作为一种高效的动态数据结构，红黑树广泛应用于STL库中的map和set等容器中。 2. 在Linux内核中，红黑树被用于管理定时器事件、进程调度和文件系统等。 3. 在计算机网络中，红黑树被用于路由表的查找和更新等。 4. 在数据库中，红黑树被用于索引。 总之，由于红黑树具有高效的查找、插入和删除操作，同时还能保持树的平衡，因此在计算机科学领域中得到了广泛的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值