C++第三十三弹---深入理解二叉搜索树：结构、操作与性能

于 2024-08-09 10:30:36 发布
阅读量778 收藏 129
点赞数 155
分类专栏： C++详解 文章标签： 算法 c++ C语言 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75584283/article/details/140590254
版权

✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】【C++详解】

目录

1. 二叉搜索树

2.1 二叉搜索树概念

2.2 二叉搜索树操作

2.2.1 二叉搜索树结构定义

2.2.2 二叉搜索树的插入

2.2.3 二叉搜索树的查找

2.2.4 二叉搜索树的删除

2.2.5 二叉搜索树的中序遍历

2.4 二叉搜索树的应用

2.5 二叉搜索树的性能分析

1. 二叉搜索树


2.1 二叉搜索树概念


二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树

2.2 二叉搜索树操作

2.2.1.二叉搜索树结构定义

二叉搜索树与数据结构初阶的链式二叉树结构类似，结点由左孩子右孩子与有效数据构成。

结点定义

template<class K>
//struct BinarySearchTreeNode
struct BSTreeNode
{
	BSTreeNode<K>* _left;   // 左孩子
	BSTreeNode<K>* _right;  // 右孩子
	K _key; // 有效数据

	// 构造函数
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}

};

主体结构定义

template<class K>
class BSTree
{
	// 将结点重命名
	typedef BSTreeNode<K> Node;
public:
	// 插入
	bool Insert(const K& key)
	{}
	// 查找
	bool Find(const K& key)
	{}
	// 删除
	bool Erase(const K& key)
	{}
    // 中序打印
    void InOrder()
    {}

private:
	// 成员变量
	Node* _root = nullptr;
};

2.2.2 二叉搜索树的插入


插入的具体过程如下：

  • a. 树为空，则直接新增节点，赋值给root指针
  • b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
bool Insert(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	// cur为空做特殊处理
	if (cur == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	while (cur)
	{
		// 插入值更大则插入到右边
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		// 小则在左边
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		// 二叉搜索树默认不能冗余，因此相等则返回false
		else
		{
			return false;
		}
	}
	// 为空则找到插入位置 需要先找到父亲的位置
	// key值大于父亲的值则在右侧
	cur = new Node(key);
	if (parent->_key < key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	return true;
}

2.2.3 二叉搜索树的查找

查找的具体过程如下：

  • a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
  • b、最多查找高度次，走到到空，还没找到，这个值不存在。
bool Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			cur = cur->_left;
		}
		else
		{
			return true;
		}
	}
	return false;
}

2.2.4 二叉搜索树的删除


首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
况：

  • a. 要删除的结点无孩子结点
  • b. 要删除的结点只有左孩子结点
  • c. 要删除的结点只有右孩子结点
  • d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下：

  • 情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除
  • 情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除
  • 情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题--替换法删除 

左子树为空

// 左树为空
if (cur->_left == nullptr)
{
	if (parent->_left == cur)
	{
		parent->_left = cur->_right;
	}
	else
	{
		parent->_right = cur->_right;
	}
	
	delete cur;
}

右子树为空

// 右树为空
else if (cur->_right == nullptr)
{
	if (parent->_left == cur)
	{
		parent->_left = cur->_right;
	}
	else
	{
		parent->_left = cur->_left;
	}
	
	delete cur;
}

左右子树均不为空

左右子树均不为空时，采用替换法删除结点，找左子树的最大值或者右子树的最小值，交换两个结点的值，然后删除替换的结点。

 1、正常情况

// 左右树均不为空
else
{
	Node* rightMinParent = nullptr;
	Node* rightMin = cur->_right;
	// 找替换的结点 右子树的最大值
	while (rightMin->_left)
	{
		rightMinParent = rightMin;
		rightMin = rightMin->_left;
	}

	swap(cur->_key, rightMin->_key);
	rightMinParent->_left = rightMin->_right;

	delete rightMin;
}

2、删除结点为根节点

// 左右树均不为空
else
{
	Node* rightMinParent = cur;
	Node* rightMin = cur->_right;
	// 找替换的结点 右子树的最大值
	while (rightMin->_left)
	{
		rightMinParent = rightMin;
		rightMin = rightMin->_left;
	}

	swap(cur->_key, rightMin->_key);
	//rightMinParent->_left = rightMin->_right;
	if (rightMinParent->_left == rightMin)
	{
		rightMinParent->_left = rightMin->_right;
	}
	else
	{
		rightMinParent->_right = rightMin->_right;
	}
	delete rightMin;
}

 

左子树为空且删除根节点 

修改左子树的为空的代码即可。

// 左树为空
if (cur->_left == nullptr)
{
	//if (parent == nullptr)
	if (cur == _root)// 删除的是根节点
	{
		_root = cur->_right;
	}
	else // 不是根节点
	{
		if (parent->_left == cur)
		{
			parent->_left = cur->_right;
		}
		else
		{
			parent->_right = cur->_right;
		}
	}
	delete cur;
}

右子树为空且删除根节点 

// 右树为空
else if (cur->_right == nullptr)
{
	if (cur == _root)// 删除根节点
	{
		_root = cur->_left;
	}
	else// 不是根节点
	{
		if (parent->_left == cur)
		{
			parent->_left = cur->_right;
		}
		else
		{
			parent->_left = cur->_left;
		}
	}
	delete cur;
}

删除函数完整代码 

bool Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			// 删除
			// 左树为空
			if (cur->_left == nullptr)
			{
				//if (parent == nullptr)
				if (cur == _root)// 删除的是根节点
				{
					_root = cur->_right;
				}
				else // 不是根节点
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
			}
			// 右树为空
			else if (cur->_right == nullptr)
			{
				if (cur == _root)// 删除根节点
				{
					_root = cur->_left;
				}
				else// 不是根节点
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_left = cur->_left;
					}
				}
				delete cur;
			}
			// 左右树均不为空
			else
			{
				Node* rightMinParent = cur;
				Node* rightMin = cur->_right;
				// 找替换的结点 右子树的最大值
				while (rightMin->_left)
				{
					rightMinParent = rightMin;
					rightMin = rightMin->_left;
				}

				swap(cur->_key, rightMin->_key);
				//rightMinParent->_left = rightMin->_right;
				if (rightMinParent->_left == rightMin)
				{
					rightMinParent->_left = rightMin->_right;
				}
				else
				{
					rightMinParent->_right = rightMin->_right;
				}
				delete rightMin;
			}
			return true;
		}
	}
	return false;
}

2.2.5 二叉搜索树的中序遍历

 由于成员变量是私有的，因此在类外不能访问根节点，此处中序遍历右三种方式进行遍历。

1、友元 2、Get获取函数 3、套一层函数

此处推荐使用套一层函数，因为更能体现封装效果。

void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

测试代码

void TestBSTree1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> t1;
	for (auto e : a)
	{
		t1.Insert(e);
	}
	t1.InOrder();// 中序遍历，升序
	t1.Erase(3);// 删除3
	t1.InOrder();
	t1.Erase(8);
	t1.InOrder();

	for (auto e : a)
	{
		t1.Erase(e);// 依次删除数组中的数
		t1.InOrder();
	}
}

 

2.4 二叉搜索树的应用


1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

  1. 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
  2. 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：

  1. 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
  2. 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。 

KV模型完整实现代码

template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
public:
	bool Insert(const K& key, const V& value)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		// cur为空做特殊处理
		if (cur == nullptr)
		{
			_root = new Node(key, value);
			return true;
		}
		while (cur)
		{
			// 插入值更大则插入到右边
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			// 小则在左边
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			// 二叉搜索树默认不能冗余，因此相等则返回false
			else
			{
				return false;
			}
		}
		// 为空则找到插入位置 需要先找到父亲的位置
		// key值大于父亲的值则在右侧
		cur = new Node(key, value);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				// 删除
				// 左树为空
				if (cur->_left == nullptr)
				{
					//if (parent == nullptr)
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
				}
				// 右树为空
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
					delete cur;
				}
				// 左右树均不为空
				else
				{
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					// 找替换的结点 右子树的最大值
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					swap(cur->_key, rightMin->_key);
					//rightMinParent->_left = rightMin->_right;
					if (rightMinParent->_left == rightMin)
					{
						rightMinParent->_left = rightMin->_right;
					}
					else
					{
						rightMinParent->_right = rightMin->_right;
					}
					delete rightMin;
				}
				return true;
			}
		}
		return false;
	}
	// 中序三种方式 1、友元 2、Get获取 3、套一层函数

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << ":" << root->_value << endl;
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptr;
};

kv模型应用测试 

输入单词，查找单词对应的中文翻译

void TestBSTree2()
{
	BSTree<string, string> dict;
	dict.Insert("string", "字符串");
	dict.Insert("left", "左边");
	dict.Insert("insert", "插入");

	string str;
	while (cin >> str)
	{
		// 搜索二叉树结点的地址
		BSTreeNode<string, string>* cur = dict.Find(str);
		if (cur)
		{
			cout << cur->_value << endl;
		}
		else
		{
			cout << "没有此单词" << endl;
		}
	}
}

 统计水果的个数

void TestBSTree3()
{
	// 统计水果的个数
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉","苹果","草莓", "苹果","草莓" };
	BSTree<string, int> countTree;
	for (const auto& str : arr)
	{
		//BSTreeNode<string, int>* cur = countTree.Find(str);
		auto cur = countTree.Find(str);
		// 没有该水果则插入
		if (cur == nullptr)
		{
			countTree.Insert(str, 1);
		}
		// 有该水果则将value值++
		else
		{
			cur->_value++;
		}
	}
	countTree.InOrder();
}

2.5 二叉搜索树的性能分析


插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

  1. 对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
  2. 但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log2 N
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N
问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上场了。 

小林熬夜学编程
关注
  • 155
    点赞
  • 踩
  • 129
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 118
    评论
专栏目录
C++二叉搜索树
weixin_63246738的博客
07-30 254
C++二叉搜索树
【c++】二叉搜索树
HenryBlog
04-20 287
目录一、概念二、操作2.1 查找2.2 插入2.3 删除 一、概念 二叉搜索树又称二叉排序树，它或者是一颗空树 特性： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若他的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、操作 2.1 查找 2.2 插入 我们需要判断树为空，则直接插入，return true 树不为空，按二叉搜索树性质查找插入位置，插入新节点 这里当我们new出一个新的节点需要注意，把他进行链接，不然出了此函数就栈销毁了，导
c++的二叉树
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
数据结构之二叉树（c++）
qq_57541265的博客
03-19 9280
本文章主要介绍二叉树的概念，二叉树的存储结构，二叉树的插入，删除，查找，遍历，等操作
C++ 二叉搜索树
m0_61548909的博客
07-23 605
或者是具有以下性质的二叉树若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树。...
《数据结构C语言版》——二叉树详解(图文并茂)
热门推荐
青春无问西东 岁月自成芳华
05-20 1万+
C语言版本的数据结构详解，讲解树、二叉树及其对应的定义、建立、性质
二叉树详解（C++）
qq_54169998的博客
11-04 9430
树状图是一种数据结构，它是由 n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树； 专业术语 中 文 描 述 根节点 一棵树的顶点 孩子节点 一个结点含有的子树的根结点称为该结点的子结点 叶子节点 .
《数据结构与算法分析C++描述第三版》答案
04-18
根据提供的信息，《数据结构与算法分析C++描述第三版》答案这一资料主要涵盖了该教材中的大量练习题解答。为了更好地理解和应用数据结构与算法的知识，下面将基于此书的章节内容进行详细的阐述。 ### 一、简介 在...
C++树（四）二叉树
最新发布
weixin_70468627的博客
07-25 1593
二叉搜索树（ Binary Search Tree ）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；能够快速查找数据也是二叉搜索树被用于各类数据结构的原因，但这种快速是有限制的，即不会出现退化，假如二叉搜索树退化为链表，则无法做到快速查找数据的要求，所以又出现了平衡二叉树。遍历二叉树的方法可以沿用遍历树的方法——递归。
C++数据结构——二叉树
caijiandl的博客
07-31 3476
二叉树 项目 项目 项目 项目1 项目2 项目3 计划任务 完成任务 二叉搜索树 二叉搜索树是二叉树的一种特殊形式。 二叉搜索树具有以下性质：每个节点中的值必须大于（或等于）其左侧子树中的任何值，但小于（或等于）其右侧子树中的任何值。 我们将在本章中更详细地介绍二叉搜索树的定义，并提供一些与二叉搜索树相关的习题。 完成本卡片后，你将： 理解二叉搜索树的特性 熟悉在二叉搜索树中的基本操作 理解高度平衡二叉搜索树的概念 二叉搜索树的定义 **二叉搜索树（BST）**是二叉树的一种
C++实现树 - 02 二叉树
Newin2020的博客
05-04 5460
写在前面： 这一讲我们来看看二叉树的实现，还不清楚树的结构的小伙伴建议先看看上面一讲关于树的定义。 二叉树的定义 二叉树是每个结点最多有两个子树的树结构。也就是说二叉树不允许存在度大于2的树。它有五种最基本的形态：二叉树可以是空集。根可以有空的左自树或者右子树；或者左右子树都是空。其中只有左子树或者右子树的叫做斜树。 二叉树的主要性质 性质 结论 性质一 在二叉树的 i 层上至多有 2 ^ ( i - 1 ) 个结点（ i >= 1 ） 性质二 深度为 k 的二叉树至多有 2.
二叉树（BinTree）
嘟嘟的博客
01-28 1085
BinTree 树是半线性结构，分层结构，具有无环性 二叉树的身影几乎出现在所有应用领域中 沿每个节点到根的唯一通路所经过的边的数目，称作节点的深度。 每个节点的孩子总数，称作其节点的度数或度。 树中所有节点的深度的最大值称作该树的高度。 仅含单个节点的树高度为 0，空树高度为 -1。 不含一度节点的二叉树称作真二叉树。 通讯 在开始通讯之前，双方应已经以某种方式，就编码规则达成过共同的约定或协议。 二进制编码： PFC 编码 → 前缀无歧义编码：任何两个原始字符所对应的二进制编码串，相互都不
引发了异常: 写入访问权限冲突。 **_Left** 是 nullptr。
m0_53276862的博客
01-26 3938
这里写自定 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 提
【C++】二叉搜索树
m0_62179366的博客
10-24 2048
二叉搜索树的简单应用及实现。
二叉搜索树（BST-Tree）(C++全)
weixin_48560325的博客
04-28 4846
目录 二叉搜索树基本概念 1，什么是根节点 2、什么是二叉搜索树 3、二叉搜索树结构 4、二叉搜索树的性质 5、复杂度 算法实现 1、创建一个二叉搜索树节点 2、打印二叉搜索树 3、二叉搜索树的插入 4、其他操作 （1）查找二叉搜索树的最大值 （2）查找二叉搜索树的最小值 （3）查找某一节点的前驱 （4）查找某一节点的后继 5、删除二叉搜索树的某一节点 步骤： 代码： 性能分析 二叉搜索树基本概念 1，什么是根节点 根结点（root）是树的一个组成部分，也
C++搜索二叉树
RXY24601的博客
05-27 1335
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
评论 118
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小林熬夜学编程

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

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

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

打赏作者

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

抵扣说明：

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

余额充值