[C++随笔录] 红黑树

最新推荐文章于 2024-11-15 21:44:47 发布
最新推荐文章于 2024-11-15 21:44:47 发布
阅读量167 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 1024程序员节 算法 数据结构
@沐雨
本文链接：https://blog.csdn.net/qq_67549203/article/details/133832322
版权

红黑树

红黑树的特点

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

  • 红黑树的特点:

    1. 节点颜色不是红色就是黑色
    2. 根节点是黑色的
    3. 每一条路径的黑色节点数目是相同的, (注意: 这里的路径是从根节点到NIL(黑色)节点)
    4. 每一条路径不允许出现连续的红色节点

  • 路径是从根节点 到 NIL节点的

🗨️满足上面的条件, 为啥就能保证 红黑树确保没有一条路径会比其他路径长出俩倍呢?

  • 根据上述的特点, 我们可以得知:
    当 每条路径的黑色节点数目一定的情况下 , 最短路径是 全黑, 最长路径是 黑红相间的
    如果我们保证 最长路径 不超过 最短路径的二倍就可以了

红黑树的模拟实现

红黑树的底层结构

  1. 颜色类型
// 枚举
enum Color
{
	RED,
	BLACK
};
  1. RBTreeNode类
template<class K, class V>
struct RBTreeNode
{
public:
	RBTreeNode(const pair<K, V> kv)
		:_kv(kv)
	{}

public:
	pair<K, V> _kv;
	Color _color = BLACK;
	RBTreeNode<K, V>* _left = nullptr;
	RBTreeNode<K, V>* _right = nullptr;
	RBTreeNode<K, V>* _parent = nullptr;
};
  1. RBTree类
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;

public:
	RBTree()
	{}

private:
	// 根节点
	Node*  _root = nullptr;
	// 记录旋转次数
	int RotateCount =  0;
}

insert的实现

实现思路

二叉搜索树的插入逻辑 + 更新黑红比例

bool Insert(const pair<K, V> kv)
{
	if (_root == nullptr)
	{
		// 根节点是黑色的
		_root = new Node(kv);
		_root->_color = BLACK;
		return true;
	}

	Node* parent = _root;
	Node* cur = _root;
	while (cur)
	{
		if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	// 新建一个节点, 默认是红色
	cur = new Node(kv);
	cur->_color = RED;

	// 链接cur 和 parent
	if (cur->_kv.first > parent->_kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	// 更改黑红比例
	// ...
	// ...

	// 更新完黑红比例后, 就返回true
	return true;
}

🗨️ 不能出现连续的红色节点 ⇒ 我们插入节点给个黑色节点多好, 为啥还要给红色节点冒风险呢?


因为, 我们插入的节点颜色是 红色, 插入的位置就有两种可能:

  1. 插入到黑色节点的后面 — — 正常的情况, 不需要进行更新
  2. 插入到红色节点的后面 — — 出现连续的红色节点, 需要 更新这一条支路 (当前节点到祖宗节点这一条路径)中的黑红比例

更新黑红比例的逻辑

由于 插入前, 是符合红黑树的性质,
插入的节点是红色 ⇒ 插入后才会出现连续的红色节点

⇒ 设插入的新节点为 cur(红色) ,
则父亲节点 paren 为 红色, 祖父节点 grandfather 为 黑色 ⇒ 这才符合 插入前符合红黑树的特点, 插入后才会出现连续的红色节点的情况

其实, 更新 当前节点到 祖宗节点这一条路径的 黑红比例 的本质是 看uncle的情况
首先, 要确定 uncle 位于grandfather的哪一侧 && uncle不一定存在, 但parent一定存在
⇒ 要确定parent 位于 grandfather的那一侧:

  1. parent 位于 grandfather的左侧
  2. parent 位于 grandfather的右侧

其次, 才是 uncle 的存在情况 以及 颜色情况

  1. uncle存在且为红

  2. uncle不存在
    如果 uncle不存在 ⇒ cur为新增节点

  • 如果cur不是新增节点, 那么 parent后面的节点必定是黑色的, 那么就违反了 每一条路径的黑色节点的个数是相同

  1. uncle存在且为黑

    如果uncle存在, 那么必定是 黑色 ⇒ 那么 cur 也应该是 黑色.
    现在看到的cur 是红色的, 是由下面的更新上来的


通过上面的图示, 我们得出 : 插入时, uncle主要分为两种情况

  1. uncle存在且为红 — — 由于更新后的头结点为红 ⇒ 我们需要继续向上更新下去
  2. uncle不存在 或 uncle存在且为黑 — — 由于更新后的头结点为黑 ⇒ 我们不需要继续向上更新下去

insert的完整代码

bool Insert(const pair<K, V> kv)
{
	if (_root == nullptr)
	{
		// 根节点是黑色的
		_root = new Node(kv);
		_root->_color = BLACK;
		return true;
	}

	Node* parent = _root;
	Node* cur = _root;
	while (cur)
	{
		if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	// 新建一个节点, 默认是红色
	cur = new Node(kv);
	cur->_color = RED;

	// 链接cur 和 parent
	if (cur->_kv.first > parent->_kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	// 更改黑红比例
	// 父亲节点存在且为红, 才有机会继续向上更新下去
	while (parent && parent->_color == RED)
	{
		Node* grandfather = parent->_parent;
		
		// parent 为 grandfather的左侧
		if (grandfather->_left == parent)
		{
			Node* uncle = grandfather->_right;

			// u存在且为红
			if (uncle && uncle->_color == RED)
			{
				// 颜色变化
				grandfather->_color = RED;
				parent->_color = uncle->_color = BLACK;

				// 继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else // u不存在 或 u存在且为黑色
			{
				if (cur == parent->_left)
				{
					RotateR(grandfather);

					grandfather->_color = RED;
					parent->_color = BLACK;
				}
				else
				{
					RotateL(parent);
					RotateR(grandfather);

					cur->_color = BLACK;
					grandfather->_color = RED;
				}
				
				// 更新后的头节点为黑色, 不需要继续向上更新
				break;
			}
		}
		// parent 为 grandfather的右侧
		else if (grandfather->_right == parent)
		{
			Node* uncle = grandfather->_left;

			// u存在且为红
			if (uncle && uncle->_color == RED)
			{
				// 颜色变化
				grandfather->_color = RED;
				uncle->_color = parent->_color = BLACK;

				// 继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			// u不存在 或 u存在且为黑色
			else
			{
				if (parent->_right == cur)
				{
					RotateL(grandfather);

					parent->_color = BLACK;
					grandfather->_color = RED;
				}
				else
				{
					RotateR(parent);
					RotateL(grandfather);

					cur->_color = BLACK;
					grandfather->_color = RED;
				}
				
				// 更新后的头节点为黑色, 不需要继续向上更新
				break;
			}
		}
		else
		{
			assert("黑红比例失控!");
		}
	}
	
	// 有可能更新过程中会把 root更新为红色 
	// && root节点的颜色必须为黑色
	// -->暴力统一处理根节点的颜色
	_root->_color = BLACK;

	return true;
}

insert的验证

  1. 每一条路径的 黑节点个数相同 ⇒ 先找一个 基准值(root的左子树中 黑节点的个数)
    如果后面的路径中 有的黑节点的个数 跟 基准值不同, 那就返回false.
  2. 不能有连续的红节点 ⇒ 当前节点为红节点, 那么父亲节点不能为红节点
  3. root 节点的颜色要为 黑色

验证代码

// 外面调用接口
bool IsBalance()
{
	return IsBalance(_root);
}

bool IsBalance(Node* root)
{
	if (root == nullptr)
		return true;

	// root节点为红, 就直接返回false
	if (root->_color != BLACK)
	{
		return false;
	}

	// 基准值 -- root左子树中的黑节点个数
	int benchmark = 0;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_color == BLACK)
			++benchmark;

		cur = cur->_left;
	}
	
	// 检查每条路径中黑节点个数 && 不能出现连续的红节点
	return CheckColour(root, 0, benchmark);
}

bool CheckColour(Node* root, int blacknum, int benchmark)
{
	// 到叶子节点, 比较路径中黑节点的个数 和 基准值
	if (root == nullptr)
	{
		if (blacknum != benchmark)
			return false;

		return true;
	}

	if (root->_color == BLACK)
	{
		++blacknum;
	}
	
	// 不能存在连续的红节点
	if (root->_color == RED && root->_parent && root->_parent->_color == RED)
	{
		cout << root->_kv.first << "出现连续红色节点" << endl;
		return false;
	}

	return CheckColour(root->_left, blacknum, benchmark)
		&& CheckColour(root->_right, blacknum, benchmark);
}

Height

// 外面调用接口
int Height()
{
	return Height(_root);
}

int Height(Node* root)
{
	if (root == nullptr)
		return 0;

	int left = Height(root->_left);
	int right = Height(root->_right);

	return left > right ? left + 1 : right + 1;
}

GetRotateCount

int GetRoateCount()
{
	return RotateCount;
}

测试程序

void rbt_test()
{
	const int N = 10000000;
	vector<int> v;
	v.reserve(N);
	srand((unsigned int)time(NULL));

	for (size_t i = 0; i < N; i++)
	{
		int ret = rand();
		v.push_back(ret);
		// v.push_back(i);
	}

	muyu::RBTree<int, int> rbt;
	for (auto e : v)
	{
		rbt.Insert(make_pair(e, e));
		// cout << "Insert:" << e << "->" << avl.Isbalance() << endl;
	}
	cout << "红黑树是否达标-> " << rbt.IsBalance() << endl;
	cout << "红黑树的高度-> " << rbt.Height() << endl;
	cout << "红黑树旋转的次数-> " << rbt.GetRoateCount() << endl;
}

int main()
{
	rbt_test();
	
	return 0;
}

运行结果:

红黑树是否达标-> 1
红黑树的高度-> 19
红黑树旋转的次数-> 19119

源码

#pragma once

#include<iostream>

using namespace std;

namespace muyu
{
	// 枚举
	enum Color
	{
		RED,
		BLACK
	};

	template<class K, class V>
	struct RBTreeNode
	{
	public:
		RBTreeNode(const pair<K, V> kv)
			:_kv(kv)
		{}

	public:
		pair<K, V> _kv;
		Color _color = BLACK;
		RBTreeNode<K, V>* _left = nullptr;
		RBTreeNode<K, V>* _right = nullptr;
		RBTreeNode<K, V>* _parent = nullptr;
	};

	template<class K, class V>
	class RBTree
	{
		typedef RBTreeNode<K, V> Node;

	public:
		RBTree()
		{}

		void RotateL(Node* parent)
		{
			++RotateCount;

			Node* cur = parent->_right;
			Node* grandfather = parent->_parent;
			Node* curleft = cur->_left;

			// 旋转核心
			parent->_right = curleft;
			cur->_left = parent;

			// 更新父亲
			// 1. parent && curleft
			if (curleft)
			{
				curleft->_parent = parent;
			}
			parent->_parent = cur;

			// 2.更新cur
			if (grandfather == nullptr)
			{
				cur->_parent = nullptr;
				_root = cur;
			}
			else
			{
				if (grandfather->_left == parent)
				{
					grandfather->_left = cur;
				}
				else
				{
					grandfather->_right = cur;
				}

				cur->_parent = grandfather;
			}

		}

		void RotateR(Node* parent)
		{
			++RotateCount;

			Node* cur = parent->_left;
			Node* grandfather = parent->_parent;
			Node* curright = cur->_right;

			// 旋转核心
			parent->_left = curright;
			cur->_right = parent;

			// 更新链接关系
			// 1. parent && curright
			if (curright)
			{
				curright->_parent = parent;
			}
			parent->_parent = cur;

			// 2.更新cur
			if (grandfather == nullptr)
			{
				cur->_parent = nullptr;
				_root = cur;
			}
			else
			{
				if (grandfather->_left == parent)
				{
					grandfather->_left = cur;
				}
				else
				{
					grandfather->_right = cur;
				}

				cur->_parent = grandfather;
			}
		}

		bool Insert(const pair<K, V> kv)
		{
			if (_root == nullptr)
			{
				// 根节点是黑色的
				_root = new Node(kv);
				_root->_color = BLACK;
				return true;
			}

			Node* parent = _root;
			Node* cur = _root;
			while (cur)
			{
				if (kv.first > cur->_kv.first)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (kv.first < cur->_kv.first)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			// 新建一个节点, 默认是红色
			cur = new Node(kv);
			cur->_color = RED;

			// 链接cur 和 parent
			if (cur->_kv.first > parent->_kv.first)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			cur->_parent = parent;

			// 更改黑红比例
			while (parent && parent->_color == RED)
			{
				Node* grandfather = parent->_parent;

				if (grandfather->_left == parent)
				{
					Node* uncle = grandfather->_right;

					// u存在且为红
					if (uncle && uncle->_color == RED)
					{
						// 颜色变化
						grandfather->_color = RED;
						parent->_color = uncle->_color = BLACK;

						// 继续向上调整
						cur = grandfather;
						parent = cur->_parent;
					}
					else // u不存在 或 u存在且为黑色
					{
						if (cur == parent->_left)
						{
							RotateR(grandfather);

							grandfather->_color = RED;
							parent->_color = BLACK;
						}
						else
						{
							RotateL(parent);
							RotateR(grandfather);

							cur->_color = BLACK;
							grandfather->_color = RED;
						}

						break;
					}
				}
				else if (grandfather->_right == parent)
				{
					Node* uncle = grandfather->_left;

					// u存在且为红
					if (uncle && uncle->_color == RED)
					{
						// 颜色变化
						grandfather->_color = RED;
						uncle->_color = parent->_color = BLACK;

						// 继续向上调整
						cur = grandfather;
						parent = cur->_parent;
					}
					// u不存在 或 u存在且为黑色
					else
					{
						if (parent->_right == cur)
						{
							RotateL(grandfather);

							parent->_color = BLACK;
							grandfather->_color = RED;
						}
						else
						{
							RotateR(parent);
							RotateL(grandfather);

							cur->_color = BLACK;
							grandfather->_color = RED;
						}

						break;
					}
				}
				else
				{
					assert("黑红比例失控!");
				}
			}

			// 暴力统一处理根节点的颜色
			_root->_color = BLACK;

			return true;
		}

		int Height()
		{
			return Height(_root);
		}

		int Height(Node* root)
		{
			if (root == nullptr)
				return 0;

			int left = Height(root->_left);
			int right = Height(root->_right);

			return left > right ? left + 1 : right + 1;
		}

		bool CheckColour(Node* root, int blacknum, int benchmark)
		{
			if (root == nullptr)
			{
				if (blacknum != benchmark)
					return false;

				return true;
			}

			if (root->_color == BLACK)
			{
				++blacknum;
			}

			if (root->_color == RED && root->_parent && root->_parent->_color == RED)
			{
				cout << root->_kv.first << "出现连续红色节点" << endl;
				return false;
			}

			return CheckColour(root->_left, blacknum, benchmark)
				&& CheckColour(root->_right, blacknum, benchmark);
		}

		bool IsBalance()
		{
			return IsBalance(_root);
		}

		bool IsBalance(Node* root)
		{
			if (root == nullptr)
				return true;

			if (root->_color != BLACK)
			{
				return false;
			}

			// 基准值
			int benchmark = 0;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_color == BLACK)
					++benchmark;

				cur = cur->_left;
			}

			return CheckColour(root, 0, benchmark);
		}

		int GetRoateCount()
		{
			return RotateCount;
		}

	private:
		Node* _root = nullptr;
		int RotateCount = 0;
	};
}

十年磨一剑，霜刃未曾试。
今日把示君，谁有不平事。
— — 贾岛《剑客》

雨 子
关注
专栏目录
C/C++ RBTree(红黑树) 算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-22 2113
红黑树的主要目的是确保树的高度平衡，以保证在最坏情况下的插入、删除和查找操作的时间复杂度都能保持在O(log n)。b. 如果删除节点有两个子节点，找到其后继节点(比该节点大的最小节点)，将后继节点的值复制到删除节点，并删除后继节点，最后修复红黑树的性质。因此，在插入新节点时，需要将新节点的颜色设置为红色，并通过修复函数来保持根节点的黑色性质。a. 如果删除节点是叶节点或者只有一个子节点，直接删除并修复红黑树的性质。为了验证实现的正确性，可以对插入的节点进行中序遍历，并确保结果是有序的。
[C++随笔录] AVL树
qq_67549203的博客
11-09 146
AVL树的详细逻辑 和 模拟实现
美团面试笔录
yu487的专栏
01-28 293
技术一面： 一面基本上面的还算基础 没有过多的刁难 不过问题量特别大 1、自我介绍 巴拉巴拉，大致说了下实习和自己平时自己喜欢做的事情 2、我们先聊聊java基础知识吧，说出Object类的常用方法？(没有定义属性，一共13个方法) 各方法讲解：https://blog.csdn.net/alinshen/article/details/73548923 总结： Object() (类构造器...
【代码随想录】总结篇
qq_36767396的博客
04-25 1222
根据代码随想录总结的经典leetcode题目中常见的数据结构和算法思想
如何给你的函数变量命名
海枫的专栏
01-07 6242
如何给你的变量命名   最近在项目中做了几次代码检视，发现代码中经常出现变量函数命名不是很完美的情况。有些变量名字，稍为一看，可以很容易看出它要表达的意思，但一样可以取一个更贴切的名字；而有一些名字，就显得特别别扭了。   本文不讨论命名风格（匈牙利风格中，还是Linux风格），仅从变量表达的意思上，应该选取什么样的英文词汇进行表达。由于我一直从事Linux开发，因此本文的命名风格是Lin
C++——红黑树
dongxue727504的博客
12-07 3035
C++之红黑树板块讲解
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3239
红黑树详解
[C++]红黑树
sewerperson的博客
05-24 45
红黑树介绍和原理,以及其模拟实现
红黑树-使用C++实现-简单练习
12-05
在C++中实现红黑树，需要对数据结构和算法有深入理解。 在给定的文件中，"rbtree.cpp"很可能是实现红黑树节点定义和操作的代码，包括旋转、颜色调整、插入和删除等功能。"main.cpp"则是测试和驱动程序，用于验证...
红黑树精短C++代码
04-13
红黑树实现前去后继排名的查询，代码经过精心简短，题目测试参考洛谷
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）
shanshan的博客
11-11 501
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。
STL之vecor的使用(超详解)
2302_80220709的博客
11-11 783
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）
TI毫米波雷达（五）—— chirp
slyywd的博客
11-14 986
TI的毫米波雷达可以通过定义chirp配置文件来控制一帧中的chirp参数，而且可以在chirp RAM中修改这些配置文件。Chirp配置文件可以作为基础的chirp时序模板，用来生成参数各异的chirp。TI的毫米波雷达可以接收四个不同的chirp配置文件，但是chirp可配置RAM中可以预编程512个独特的chirp。每个chirp都可以引用四个配置文件之一，然后按需要进行细调。一个帧由chirp可配置RAM中起始索引到结束索引间的chirp序列组成，最大可循环255次。
C++ 中的string类
2201_75357870的博客
11-15 692
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。
C++ 编程基础（5）类与对象 | 5.7、友元
个人技术博客
11-14 924
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。
C语言之数组
m0_75253775的博客
11-11 1029
前面我们整理了C语言函数相关知识点,C语言中函数有两种特殊情况。
量化交易backtrader实践(三)_指标与策略篇(8)_股票软件指标参考C
最新发布
AouSdu
11-15 575
主要是学习和实践股票软件中的内置的技术指标公式并且在backtrader中没有的，本节为趋势型指标公式。
lambda 表达式与mutable
王尚权 qq:2515162716
11-15 665
通常情况下，lambda表达式捕获的变量是不可变的，使用mutable关键字可以破坏这种不可变性，允许对捕获变量进行修改。在C++中，mutable关键字和引用捕获方式（&）有不同的用途和效果，它们可以在某些情况下结合使用，但它们的基本功能和影响是不同的。在这个例子中，x既是通过引用捕获的，也是mutable关键字作用的对象。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。
【代码随想录day29】【C++复健】134. 加油站；135. 分发糖果；860.柠檬水找零；406. 根据身高重建队列
yumenohimiko的博客
11-14 619
感觉贪心的题真的很考验一个人的智商，而我，碰巧没有。134. 加油站偷看了解析思路，但依然因为一个低级失误导致被卡了很久... 并且写出来的代码也非常的麻烦，主要体现在我每到一个新节点，就必须求证似的让iter走完一整圈才算结束，但卡哥的方法一个for循环就结束了。卡哥的思路也相当的清晰：简单来说就是当你一圈下来：1 如果和小于0，那么说明无论如何无解，也不用往后再看了。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雨 子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值