C++进阶——红黑树

于 2024-10-23 22:32:23 发布
阅读量1.1k 收藏 18
点赞数 31
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_79830926/article/details/143191524
版权

目录

一、概念

二、特征

三、模拟实现

1.大致框架

2.插入分析

3.插入代码

四、测试

一、概念

红黑树是一颗近似平衡的二叉搜索树，最长路径的长度不会超过最短路径的两倍，主要是通过控制结点的“颜色”来实现的，第一次接触红黑树可能会觉得很抽象，不过明白了其中原理便会觉得它设计得如此巧妙。

二、特征

红黑树的最长路径不能超过最短路径的二倍。

————这是红黑树能成为近似平衡的二叉搜索树的唯一需要。

由于这个特征，会导致其结点个数和最短路径的高度满足：

计算下来， h和2h（理论上的最长路径）也是logN级别的，那么它的查找效率能达到O(logN)。

所以为了实现最长路径不能超过最短路径的二倍这个特征，红黑树必须满足以下几点规则：

1. 每个节点不是红色就是黑色

2. 根节点必须是黑色

3. 红色结点的孩子只能是黑色结点

4.每条路径的黑色结点个数相同

我们来捋一下这些规则与红黑树特征的关系：

规则3限制了红色结点的孩子必然是黑色结点，而黑色结点的孩子或父亲不一定是红色结点，而每条路径的黑色结点个数又相同（规则4），所以最长路径（理论上，实际上不一定会存在）会是（规则2，根节点必须是黑色）黑色红色黑色红色……黑色红色，最短路径是黑色黑色黑色……黑色，最长的路径长度就会是最短路径的二倍。

也就是说，规则1规定了红黑树的框架（红色和黑色结点），规则3和规则4大大限制了最短路径和最长路径之间的倍数差，规则2为这个规则3和规则4的限制添加了最后的保障。

三、模拟实现

1.大致框架

和之前AVL树一样，我们实现的是key/value版本的红黑树，主要实现它的插入操作即可。

红黑树本质上就是结点的封装，那么结点里应该有什么？

红黑树不再需要靠平衡因子来保持平衡，所以只需要_col（标记颜色），_kv（key/value），_parent，_left，_right就ok了（父结点在之后的调整中会经常用到）

#pragma once
#include <iostream>
using namespace std;

// 枚举值代表颜色（当然用bool值也ok）
enum Colour
{
	RED,
	BLACK
};

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

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_parent(nullptr)
		,_left(nullptr)
		,_right(nullptr)
		,_col(RED) // 因为插入默认插入RED（除了根节点）
	{}
};

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

private:
	Node* _root = nullptr;
};

2.插入分析

首先，插入的结点应该是什么颜色的结点？

我们挨个分析：

如果插入的结点是黑色结点，那么就会出现这种情况：

如果插入的结点是红色结点，那么：

插入为黑色结点的孩子：

 

插入为红色结点的孩子：

uncle存在且是红色的情况：

上面这种情况继续向上调整的分析：继续向上调整时，cur变为grandfather（红色），其余都再更新

uncle存在且为黑色的情况：

uncle不存在的情况：

综合以上情况，我们分析出插入的结点必须为红色结点，

红色结点又要考虑的情况：

1.结点的插入位置（左孩子or右孩子）、

2.uncle的存在与否/颜色 

uncle的情况：

1.当uncle存在且为红色时，只需改变颜色就能完成红黑树的调整。

（需要注意的是这个调整会一直网上调整，有可能会调整到根节点，在写代码的时候要注意这个细节）

2.当uncle为其它情况时，就需要借助旋转+变色来帮我们完成调整。

当然，以上情况都是uncle在parent右边的情况，还有uncle在parent的右边的情况，这些情况就和前面完全镜像了，就不再拿出来一一分析

3.插入代码

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		_root->_col = BLACK;
		return true;
	}
	// 先查找
	Node* parent = nullptr, * cur = _root;
	while (cur)
	{
		if (cur->_kv.first > kv.first)
		{
			parent = cur;
			cur = parent->_left;
		}
		else if (cur->_kv.first < kv.first)
		{
			parent = cur;
			cur = parent->_right;
		}
		else
		{
			return false;
		}
	}
	// 注意插入结点的构造使其默认就是红色
	cur = new Node(kv);
	if (kv.first < parent->_kv.first) parent->_left = cur;
	else parent->_right = cur;
	cur->_parent = parent;

	// 插入完毕，接下来就是旋转/变色

	// 1. 插入位置为黑色结点的孩子，管都不用管
	// if (parent->_col == BLACK)

	// 2. 插入位置为红色结点的孩子
	// 为啥不是if，就是因为可能还需要继续向上调整
	while (parent && parent->_col == RED)
	{
		// 为啥不可能是空？因为parent是红色
		Node* grandfather = parent->_parent;

		// 镜像情况1，parent在左
		//      g
		// p        u
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			// uncle存在且为红色
			if (uncle && uncle->_col == RED)
			{
				// 只需要变色
				parent->_col = BLACK;
				grandfather->_col = RED;
				uncle->_col = BLACK;

				// 可能仍需要继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				// uncle是黑色或不存在（这个不重要，旋转不影响）
				// 变色+旋转
				if (cur == parent->_left)
				{
					//        g
					//    p      u
					// c
					// 单旋+变色
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//        g
					//    p      u
					//        c
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				// 如果是通过旋转调整的，就直接break
				// 因为留在调整局部最上面的是黑色结点，不需要继续向上调整
				break;
			}
		}
		// 镜像情况2 parent在右
		//      g
		// u        p
		else
		{
			Node* uncle = grandfather->_left;
			// uncle存在且为红色
			if (uncle && uncle->_col == RED)
			{
				// 只需要变色
				parent->_col = BLACK;
				grandfather->_col = RED;
				uncle->_col = BLACK;

				// 可能仍需要继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				// uncle是黑色或不存在（这个不重要，旋转不影响）
				// 变色+旋转
				if (cur == parent->_right)
				{
					//        g
					//    u      p
					//                c
					// 单旋+变色
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//        g
					//    u      p
					//        c
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				// 如果是通过旋转调整的，就直接break
				// 因为留在调整局部最上面的是黑色结点，不需要继续向上调整
				break;
			}
		}
	}
	// 最后不管根节点是不是变成红色了，都改成黑色
	// 这样就不用讨论cur是根节点（红色）但是跳出循环的那种情况了
	_root->_col = BLACK;
	return true;
}

// 右单旋  rotate 旋转 right 右
void RotateR(Node* parent)
{
	// 连接
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	subL->_right = parent;
	parent->_left = subLR;

	// 更新_parent
	subL->_parent = parent->_parent;
	parent->_parent = subL;
	if (subLR)	subLR->_parent = parent;

	// 根结点的情况
	if (parent == _root)	_root = subL;
	// 非根结点	 更新“看不见的”parent
	else if (parent == subL->_parent->_left)	subL->_parent->_left = subL;
	else subL->_parent->_right = subL;
}

// 左单旋
void RotateL(Node* parent)
{
	// 连接
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	subR->_left = parent;
	parent->_right = subRL;

	// 更新_parent
	subR->_parent = parent->_parent;
	parent->_parent = subR;
	if (subRL)	subRL->_parent = parent;

	// 根结点的情况
	if (parent == _root)	_root = subR;
	// 非根结点	 更新“看不见的”parent
	else if (parent == subR->_parent->_left)	subR->_parent->_left = subR;
	else subR->_parent->_right = subR;
}

四、测试

我们可以复用AVL树的测试代码，不过需要有新增的判断是否为红黑树的测试。

判断是否为红黑树，只需要判断是否符合红黑树的规则即可。

1. 每个节点不是红色就是黑色

2. 根节点必须是黑色

3. 红色结点的孩子只能是黑色结点

4.每条路径的黑色结点个数相同

我们着重思考3、4怎么测试

3：如果遍历找出每个红色结点，再去看该红色结点的左右孩子结点（而且不一定存在）是比较繁琐的，但是如果我们反其道而行之，既然红色结点的孩子只能是黑色结点，那么红色结点的父亲就必然不能是红色结点，一旦红色结点的父亲是红色结点，那么就不符合红黑树的规则

4：我们可以先随便找一条路径，算出其黑色结点的个数，然后再使用递归比较一下其它路径的黑色结点个数是否与该路径黑色结点个数相等，如果不相等，就不符合红黑树的规则

本博客所有实现代码（包括测试）：

// RBTree.h
#pragma once
#include <iostream>
using namespace std;

// 枚举值代表颜色（当然用bool值也ok）
enum Colour
{
	RED,
	BLACK
};

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

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_parent(nullptr)
		,_left(nullptr)
		,_right(nullptr)
		,_col(RED) // 因为插入默认插入RED（除了根节点）
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
	
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		// 先查找
		Node* parent = nullptr, *cur = _root;
		while (cur)
		{
			if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = parent->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = parent->_right;
			}
			else
			{
				return false;
			}
		}
		// 注意插入结点的构造使其默认就是红色
		cur = new Node(kv);
		if (kv.first < parent->_kv.first) parent->_left = cur;
		else parent->_right = cur;
		cur->_parent = parent;

		// 插入完毕，接下来就是旋转/变色

		// 1. 插入位置为黑色结点的孩子，管都不用管
		// if (parent->_col == BLACK)

		// 2. 插入位置为红色结点的孩子
		// 为啥不是if，就是因为可能还需要继续向上调整
		while (parent && parent->_col == RED)
		{
			// 为啥不可能是空？因为parent是红色
			Node* grandfather = parent->_parent;

			// 镜像情况1，parent在左
			//      g
			// p        u
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				// uncle存在且为红色
				if (uncle && uncle->_col == RED)
				{
					// 只需要变色
					parent->_col = BLACK;
					grandfather->_col = RED;
					uncle->_col = BLACK;

					// 可能仍需要继续向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					// uncle是黑色或不存在（这个不重要，旋转不影响）
					// 变色+旋转
					if (cur == parent->_left)
					{
						//        g
						//    p      u
						// c
						// 单旋+变色
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//        g
						//    p      u
						//        c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					// 如果是通过旋转调整的，就直接break
					// 因为留在调整局部最上面的是黑色结点，不需要继续向上调整
					break;
				}
			}
			// 镜像情况2 parent在右
			//      g
			// u        p
			else
			{
				Node* uncle = grandfather->_left;
				// uncle存在且为红色
				if (uncle && uncle->_col == RED)
				{
					// 只需要变色
					parent->_col = BLACK;
					grandfather->_col = RED;
					uncle->_col = BLACK;

					// 可能仍需要继续向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					// uncle是黑色或不存在（这个不重要，旋转不影响）
					// 变色+旋转
					if (cur == parent->_right)
					{
						//        g
						//    u      p
						//                c
						// 单旋+变色
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//        g
						//    u      p
						//        c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					// 如果是通过旋转调整的，就直接break
					// 因为留在调整局部最上面的是黑色结点，不需要继续向上调整
					break;
				}
			}
		}
		// 最后不管根节点是不是变成红色了，都改成黑色
		// 这样就不用讨论cur是根节点（红色）但是跳出循环的那种情况了
		_root->_col = BLACK;
		return true;
	}

	// 右单旋  rotate 旋转 right 右
	void RotateR(Node* parent)
	{
		// 连接
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		subL->_right = parent;
		parent->_left = subLR;

		// 更新_parent
		subL->_parent = parent->_parent;
		parent->_parent = subL;
		if (subLR)	subLR->_parent = parent;

		// 根结点的情况
		if (parent == _root)	_root = subL;
		// 非根结点	 更新“看不见的”parent
		else if (parent == subL->_parent->_left)	subL->_parent->_left = subL;
		else subL->_parent->_right = subL;
	}

	// 左单旋
	void RotateL(Node* parent)
	{
		// 连接
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		subR->_left = parent;
		parent->_right = subRL;

		// 更新_parent
		subR->_parent = parent->_parent;
		parent->_parent = subR;
		if (subRL)	subRL->_parent = parent;

		// 根结点的情况
		if (parent == _root)	_root = subR;
		// 非根结点	 更新“看不见的”parent
		else if (parent == subR->_parent->_left)	subR->_parent->_left = subR;
		else subR->_parent->_right = subR;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

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

	int Size()
	{
		return _Size(_root);
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	bool IsBalance()
	{
		if (_root == nullptr)
			return true;

		if (_root->_col == RED)
			return false;

		// 参考值（算的是最左路径的黑色结点个数）
		int refNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++refNum;
			}
			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}

private:
	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			// 前序遍历走到空时，意味着一条路径走完了
			if (refNum != blackNum)
			{
				cout << "存在黑色结点的数量不相等的路径" << endl;
				return false;
			}
			return true;
		}

		// 检查孩子不太方便，因为孩子有两个，且不一定存在，反过来检查父亲就方便多了
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色结点" << endl;
			return false;
		}

		if (root->_col == BLACK)
		{
			blackNum++;
		}

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

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

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

		return _Size(root->_left) + _Size(root->_right) + 1;
	}
private:
	Node* _root = nullptr;
};

// Test.cpp
#include<iostream>
#include<vector>
using namespace std;

#include"RBTree.h"

void TestRBTree1()
{
	RBTree<int, int> t;
	// 常规的测试用例
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	// 特殊的带有双旋场景的测试用例
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };

	for (auto e : a)
	{
		t.Insert({ e, e });
	}

	t.InOrder();
	cout << t.IsBalance() << endl;
}

// 插入一堆随机值，测试平衡，顺便测试一下高度和性能等
void TestRBTree2()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
	}

	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();

	cout << "Insert:" << end2 - begin2 << endl;
	cout << t.IsBalance() << endl;

	cout << "Height:" << t.Height() << endl;
	cout << "Size:" << t.Size() << endl;

	size_t begin1 = clock();
	// 确定在的值
	//for (auto e : v)
	//{
	//	t.Find(e);
	//}
	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
	}
	size_t end1 = clock();
	cout << "Find:" << end1 - begin1 << endl;
}


int main()
{
	TestRBTree2();

	return 0;
}

okkkkkkkkk~

完结撒花啦~

Eclipse 在编辑窗口显示打印边距（换行参考线）
My Garage
08-11 2670
Window -> Preferences -> General -> Editors -> Text Editors: 勾选 Show print margin
Eclipse Preference设置
SpringsSpace
08-04 1476
0. 概述     Eclipse 采用Workspace→Project两级的工程组织方式，eclipse会在workspace目录下新建.metadata文件夹，     用于放置各种配置文件。启动Eclipse后,还可以在菜单File→Switch Workspace中切换到不同的Workspace中。     一个Project默认启动时,总会继承它所在的Workspace中的一些设...
eclipse margin column的显示
a1314loveyou的专栏
05-10 326
Window - Preferences - General - Editors - Text Editors - Show print margin
Zend Development Environment - Show print margin at column:
胡争辉
10-01 1405
Zend Development Environment - Show print margin at column: 在linux终端中，宽度默认是80字符，为了便于在服务器端编辑，可以把php源文件也限制为80字符，此时可以选中Show print margin at column:复选框，并设置为80。 [Zend Development Environment关键词]
Eclipse设置打印线
以家为家，以乡为乡，以国为国，以天下为天下
09-17 2365
在调出Preferences之后，选中Text Editors，先选中Show print margin，在Print margin column框中填入180即可，然后选择下面的Print margin，点击右边的color，可以变更颜色，将其改成鲜艳的红色即可。
eclipse关于java类每行最大长度的设置，即每行显示多少列或字数而不换行
u010741112的博客
11-23 1585
eclipse关于java类每行最大长度的设置，即每行显示多少列或字数而不换行
Win7_Eclipse_C++开发环境搭建
03-28
- 勾选`Show print margin`并设置`Print margin column`为80，以便在编辑器中显示一行代码的最大长度。 - 勾选`Insert spaces for tabs`以使用空格代替制表符。 2. **CDT编译设置** - 选择`Window -> ...
eclipse如何自动换行
最新发布
05-30
> Editors -> Text Editors，在右侧的面板中勾选“Show print margin”和“Show line numbers”，然后在“Print margin column”输入框中输入一个适当的值，比如80，表示当一行代码超过80个字符时，Eclipse会自动将...
OpenCV学习之路(一)----配置OpenCV_Eclipse开发环境
fandong12388的专栏
09-21 2618
一、eclipseCDT搭建C/C++开发环境 二、eclipseCDT搭建OpenCV开发环境 一、eclipseCDT搭建C/C++开发环境(转载自作者：jamesfancy[配置Eclipse+MinGW开发C/C++程序]) 在MinGW主页很容易找到MinGW的下载页面。之后看到一大堆需要下载的包，头都大了。于是决定下载Automated MinGW Installer，让它在线下载安装M
eclipse java 行宽_eclipse关于java类每行最大长度的设置
weixin_42474537的博客
02-23 489
1.限制每行最大字符Preferences -> Java -> Code Style -> Formatter点击 "Edit..."，切换到"Line Wrapping"选项卡，在"General settings"的设置中的"Maximum line width"改为每行代码最大的字符数，一些代码规范会要求一个代码不超过120个字符，如sonar、PMD等代码静态扫描如果一...
[Web前端] Margin 失效问题, 设置了 Margin 却不见效果, 解决方案.
诺尔的博客
03-07 4334
首先演示下: .box1{ width: 300px; height: 300px; } .box2{ width: 200px; height: 200px; } .box3{ width: 100px; height: 100px; } .border-with{ border: solid 1px pink; } .padding-with{ padding: 1px; } .style-pink{ background-colo
Eclipse中，控制每行最大长度的提示线
mk_yyy的专栏
08-29 1117
General Editors TestEditors设置宽度
eclipse html 布局,Eclipse Forms的两个新布局TableWrapLayout和ColumnLayout
weixin_42097450的博客
06-15 346
1. TableWrapLayout和SWT的GridLayout是一样的，它也有layout data，叫做TableWrapData。都是以列进行划分，Control一个一个放进去。主要作用就是：使得文本控件Label，Text，Hyperlink等可以根据宽度，wrap显示文本，不够宽度就显示多行。注意，文本控件样式要有SWT.WRAP，TableWrapLayout才会起效果。如果文本控件...
由浅入深漫谈margin属性
dayun的专栏
07-05 775
 blankzheng的blog：http://www.planabc.net/margin在中文中我们翻译成外边距或者外补白（本文中引用外边距）。他是元素盒模型（box model）的基础属性。一、margin的基本特性margin属性包括margin-top,margin-right,margin-bottom,margin-left,margin，可以用来设置box的marg
Eclipse中每行80字符限制的提示线
MoonsunS的博客
10-01 6753
Eclipse可以用一条线来提示自己在编码时每行的字符数是否超过限制，具体设置方法
html margin-top 不起作用
热门推荐
风华绝代的博客
01-13 1万+
margin-top不起作用
Eclipse黑暗主题设置教程：一键变黑
在这个给定的文件中，我们可以了解到如何将Eclipse集成开发环境（IDE）的界面设置成黑色主题，以提高夜间编程的视觉舒适度或个人偏好。下面是根据标题、描述和标签中所包含的知识点进行的详细说明： ### Eclipse...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值