【C++进阶】【STL】set和map的讲解及模拟实现

于 2024-04-05 15:38:22 发布
阅读量1k 收藏 20
点赞数 32
分类专栏： c++大冒险 文章标签： c++ 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79551553/article/details/137375196
版权

🪐🪐🪐欢迎来到程序员餐厅💫💫💫

          主厨：邪王真眼

主厨的主页：Chef‘s blog  

 所属专栏：c++大冒险
 

 总有光环在陨落，总有新星在闪烁

一、 关联式容器

       在初阶阶段，我们已经接触过 STL 中的部分容器，比如： vector 、 list 、 deque 等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。那什么是关联式容器？它与序列式容器有什么区别？
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的
键值对，在数据检索时比序列式容器效率更高。

二、 键值对

     用来表示具有 一一对应关系 的一种结构，该结构中一般只包含两个成员变量 key 和 value ， key代表键值，value表示与key对应的信息 。 比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应
该单词，在词典中就可以找到与其对应的中文含义。
SGI-STL中关于键值对的定义 
template <class T1, class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair(): first(T1()), second(T2())
{}
pair(const T1& a, const T2& b): first(a), second(b)
{}
};

三、树形结构的关联式容器

       STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。树型结构的关联式容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是： 使用红黑树作为其底层结果 ，容器中的元素是一个有序的序列。

3.1 set

  • 1. set是按照一定次序存储元素的容器
  • 2. 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。
  • set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
  • 3. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行 排序。
  • 4. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对 子集进行直接迭代。
注意事项：
  • 1. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放 value，但在底层实际存放的是由<value, value>构成的键值对。
  • 2. set中插入元素时，只需要插入value即可，不需要构造键值对。
  • 3. set中的元素不可以重复(因此可以使用set进行去重)。
  • 4. 使用set的迭代器遍历set中的元素，可以得到有序序列
  • 5. set中的元素默认按照小于来比较
  • 6. set中查找某个元素，时间复杂度为：log n

3.2 map的介绍

  • 1. map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
  • 2. 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的 内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员value_type绑定在一起，为其取别名称为pair: typedef pair<const key, T> value_type;
  • 3. 在内部，map中的元素总是按照键值key进行比较排序的。
  • 4. map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序 对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
  • 5. map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。

3.3 multiset  

  • 1. multiset是按照特定顺序存储元素的容器，其中元素是可以重复的。
  • 2. 在multiset中，元素的value也会识别它(因为multiset中本身存储的就是<value, value>组成 的键值对，因此value本身就是key，key就是value，类型为T). multiset元素的值不能在容器中进行修改(因为元素总是const的)，但可以从容器中插入或删除。
  • 3. 在内部，multiset中的元素总是按照其内部比较规则(类型比较)所指示的特定严格弱排序准则进行排序。
  • 4. multiset容器通过key访问单个元素的速度通常比unordered_multiset容器慢，但当使用迭 代器遍历时会得到一个有序序列。
注意事项：
  • 1. multiset中再底层中存储的是<value, value>的键值对
  • 2. mtltiset的插入接口中只需要插入即可
  • 3. 与set的区别是，multiset中的元素可以重复，set是中value是唯一的
  • 4. 使用迭代器对multiset中的元素进行遍历，可以得到有序的序列
  • 5. multiset中的元素不能修改
  • 6. 在multiset中找某个元素，时间复杂度为O(log 2N)
  • 7. multiset的作用：可以对元素进行排序

3.4 multimap的介绍

  • 1. Multimaps是关联式容器，它按照特定的顺序，存储由key和value映射成的键值对<key, value>，其中多个键值对之间的key是可以重复的。
  • 2. 在multimap中，通常按照key排序和惟一地标识元素，而映射的value存储与key关联的内 容。key和value的类型可能不同，通过multimap内部的成员类型value_type组合在一起， value_type是组合key和value的键值对:typedef pair<const Key, T> value_type;
  • 3. 在内部，multimap中的元素总是通过其内部比较对象，按照指定的特定严格弱排序标准对 key进行排序的。
  • 4. multimap通过key访问单个元素的速度通常比unordered_multimap容器慢，但是使用迭代 器直接遍历multimap中的元素可以得到关于key有序的序列。
multimap和map的唯一不同就是：map中的key是唯一的，而multimap中key是可以重复的。

四、改造红黑树

        我们现在知道了这些树形容器都是对红黑树进行了封装，但是如果直接用之前写的红黑树会导致set和map分别要建一颗红黑树，为了提高代码的复用率，我们要对红黑树改造，使得map和set可以共用一颗进行封装。

4.1红黑树节点

注意事项：

          在红黑树里存的值类型是T而不是之前的pair<K,V>,这是为了使之可以同时满足set（存键值），map（存键值对）

enum Color
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data;
	Color _col;

	RBTreeNode(const T& data)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};

4.2 迭代器

         之前的红黑树没有迭代器，我们要设计出双向的迭代器，要求是向后遍历等同于中序，以最左节点为begin,最右节点为end

template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, T&, T*> Iterator;
	typedef RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;

	RBTreeIterator(Node* node)
		: _node(node)
	{}

	RBTreeIterator(const Iterator& it)
		: _node(it._node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &(operator*());
	}

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

	bool operator==(const Self& s)
	{
		return _node == s._node;
	}
};

注意事项：

  • 1.看过我之前写的迭代器博客的老铁应该直到，为什么要有三个模板参数，这是为了使iterator和const迭代器都能调用同一个函数，而不用分别设计一个
  • 2.红黑树是二叉搜索树，它存的键值不能修改（因为你不能保证修改后还是搜索树），所以对*的重载返回值是Ref（const T&）
  • 3.->的返回值不应被修改，所以是Ptr（const T*）;
  • 4.迭代器的拷贝构造函数在普通迭代器调用时以普通迭代器拷贝出普通迭代器，在const迭代器调用时以普通迭代器拷贝出const迭代器

4.2.1 operator++

  1. 前置++：
    • 右不为空，找右子树的最左结点
    • 右为空，向上找孩子是父亲左的那个父亲
    • 返回引用
  2. 后置++：复用前置++，返回临时对象，返回值而非引用
Self& operator++()
{
	if (_node->right)//右不为空，找右子树的最左结点
	{
		_node = _node->right;
		while (_node->_left)
			_node = _node->_left;

	}
	else//右为空，向上找孩子是父亲左的那个父亲
	{
		while (_node->_parent && _node->_parent->right == _node)
		{
			_node = _node->_parent;
		}
	}
	return *this;
}
Self operator++(int)
{
	Iterator news = this;
	this++:
	return *news;
}

 

 

4.2.2 operator- - 

  1. 前置- -的思路：
    • 左不为空，找左子树的最右结点
    • 左为空，向上找孩子是父亲右的那个父亲
  2. 后置- -：复用前置- -，返回临时对象
Self& operator--()//左不为空，找左子树的最右结点
{
	if (_node->left)
	{
		_node=_node->_left
		while (_node->_right)
			_node = _node->right;
	}
	else//左为空，向上找孩子是父亲右的那个父亲
	{
		while (_node->_parent && node->_parent->_left == _node)
			_node = _node->_parent;
		_node = _node->parent;
	}
}
Self& operator--(int)
{
	Self tmp = *this;
	--*this;
	return tmp;
}

 

 

4.3 RBTree的修改

4.3.1 成员变量

注意事项：

  1. 直接给缺省值为nullptr，不必写构造函数
  2. 模板参数第一个为K，是键值类型
  3. 模板参数第二个为T，同时适用set（存储键值）和map（存储键值对）
  4. 模板参数第三个为KeyOfT（仿函数类型），用于获取不同数据T的键值key
template<class K, class T, class KeyOfT>
class RBTree
{
protected:
	typedef RBTreeNode<T> Node;
public:
protected:
	Node* _root = nullptr;
};

 4.3.2 begin和end

注意事项：

         begin返回最左节点的迭代器，end返回空迭代器（不是最右节点的迭代器！！！）

typedef RBTreeIterator<T, T&, T*>iterator;
typedef RBTreeIterator<T, const T&, const T *>const_iterator; 
iterator begin()
{
	Node* cur = _root;
	if (cur == nullptr)
		return iterator(nullptr);
	while (cur->_left)
		cur = cur->_left
		return iterator(cur);
}
const_iterator begin()const
{
	Node* cur = _root;
	if (cur == nullptr)
		return const_iterator(nullptr);
	while (cur->_left)
		cur = cur->_left;
	return const_iterator(cur);
}
iterator end()
{
		return iterator(nullptr);
}
const_iterator end()const
{
		return const_iterator(nullptr);
}

4.3.3 Find

思路：

  1. 返回迭代器
  2. 运用仿函数进行键值比较，从而适配map和set
iterator Find(const K& key)
{
	if (_root == nullptr)
	{
		return iterator(nullptr);
	}

	KeyOfT kot;
	Node* cur = _root;
	while (cur)
	{
		if (kot(cur->_data) < key)
		{
			cur = cur->_right;
		}
		else if (kot(cur->_data) > key)
		{
			cur = cur->_left;
		}
		else
		{
			return iterator(cur);
		}
	}

	return iterator(nullptr);
}

4.3.4 Insert

思路：

  1. 返回pair，第一个参数为迭代器，第二个参数为布尔值（记录是否插入成功）
  2. 运用仿函数进行键值比较从而适配map和set
pair<iterator, bool> Insert(const T& data)
{
	if (_root == nullptr)
	{
		_root = new Node(data);
		_root->_col = BLACK;
		return make_pair(iterator(_root), true);
	}

	KeyOfT kot;
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (kot(cur->_data) < kot(data))
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kot(cur->_data) > kot(data))
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return make_pair(iterator(cur), false);
		}
	}

	Node* newnode = new Node(data);
	cur = newnode;
	if (kot(parent->_data) < kot(data))
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	while (parent && parent->_col == RED)
	{
		Node* grandparent = parent->_parent;
		if (grandparent->_right == parent)//uncle在左，parent在右
		{
			Node* uncle = grandparent->_left;
			if (uncle && uncle->_col == RED)//uncle为红，变色+向上调整
			{
				parent->_col = uncle->_col = BLACK;
				grandparent->_col = RED;

				cur = grandparent;
				parent = cur->_parent;
			}
			else//uncle为空或为黑，变色+旋转
			{
				if (parent->_right == cur)//左单旋
				{
					RotateL(grandparent);
					parent->_col = BLACK;
					grandparent->_col = RED;
				}
				else//右左旋
				{
					RotateR(parent);
					RotateL(grandparent);
					cur->_col = BLACK;
					grandparent->_col = RED;
				}
			}
		}
		else//parent在左，uncle在右
		{
			Node* uncle = grandparent->_right;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandparent->_col = RED;

				cur = grandparent;
				parent = cur->_parent;
			}
			else
			{
				if (parent->_left == cur)//右单旋
				{
					RotateR(grandparent);
					parent->_col = BLACK;
					grandparent->_col = RED;
				}
				else//左右旋
				{
					RotateL(parent);
					RotateR(grandparent);
					cur->_col = BLACK;
					grandparent->_col = RED;
				}
			}
		}
	}
	_root->_col = BLACK;

	return make_pair(iterator(newnode), true);
}

五、set

5.1 成员变量与仿函数

细节：

  1. set类仿函数，直接返回参数key
  2. 成员变量的第二个模板参数为K，第三个模板参数为SetKeyOfT
template<class K>
class set
{
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
protected:
	RBTree<K, K, SetKeyOfT> _t;
};

5.2 begin和end

细节：
      1.set中存储的键值key均不允许修改，所以其普通迭代器和const迭代器均为红黑树的const迭代器。

        2.set调用普通begin()时，begin函数所调用的begin的返回值是普通迭代器，可要求返回值是const迭代器，便有从普通迭代器到const迭代器的转换，产生临时变量，用到了之前写的拷贝构造（以普通迭代器拷贝构造const迭代器）

typedef RBTree<K,K,SetKeyOfT>::const_iterator iterator;
typedef RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;
iterator begin()
{
	return _t.begin();
}
const_iterator begin()const
{
	return _t.begin();
}
iterator end()
{
	return _t.end();
}
const_iterator end()const
{
	return _t.end();
}

5.3 find

iterator find(const K& key)
{
	return _t.Find(key);
}

5.4 insert

pair<iterator, bool> insert(const K& key)
{
	return _t.Insert(key);
}

细节：

  1. 插入参数类型为K（键值）
  2. 此时也有从普通迭代器到const迭代器的转换

六、map

6.1 成员变量与仿函数

template<class K, class V>
class map
{
	struct MapKeyOfT
	{
		const K& operator()(const pair<const K, V>& kv)
		{
			return kv.first;
		}
	};
public:
protected:
	RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};

细节：

  1. map类仿函数，返回参数pair的first
  2. 成员变量的第二个模板参数为pair，第三个模板参数为MapKeyOfT

6.2 begin和end 

typedef RBTree<K, pair<const K,V>, MapKeyOfT>::const_iterator iterator;
typedef RBTree<K, pair<const K,V>, MapKeyOfT>::const_iterator const_iterator;
iterator begin()
{
	return _t.begin();
}
const_iterator begin()const
{
	return _t.begin();
}
iterator end()
{
	return _t.end();
}
const_iterator end()const
{
	return _t.end();
}

注意事项：

               map不允许修改key，所以除了迭代器都是const迭代器之外，还要对键值对里的key进行const修饰。

6.3 find 

iterator find(const K& key)
{
	return _t.Find(key);
}

6.4 insert

pair<iterator, bool> Insert(pair<const K, V>kv)
{
	return _t.Insert(kv);
}

6.5 operator[ ]

在插入和修改使用[ ]会很方便。

V& operator[](const K& key)
{
	pair<const K, V> kv(key,V());
	return _t.Insert(kv).first->second;
}

注意事项：

              返回值可以帮我们直接修改键值对中的V

总结、

今日份学习内容如下：

  • 1.了解了关联性容器和键值对的概念
  • 2.了解了以红黑树为基础的四大容器的作用
  • 3.重写了红黑树
  • 4.模拟了map和set，并分析了种种设置的原因

赠人一赞，日行一善

一颗青果
关注
  • 32
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
C/C++知识要点2——STL中Vector、Map、Set容器的实现原理
TommyZht的专栏
08-06 5945
1、Vector是顺序容器，是一个动态数组，支持随机存取、插入、删除、查找等操作，在内存中是一块连续的空间。在原有空间不够情况下自动分配空间，增加为原来的两倍。vector随机存取效率高，但是在vector插入元素，需要移动的数目多，效率低下。 注意：vector动态增加大小时，并不是在原空间之后持续新空间（因为无法保证原空间之后尚有可供配置的空间），而是以原大小的两倍另外配置一块较大的空间，然
C++STL vector list map set dqueue 等应用举例及PPT讲解示例,代码演示
06-28
C++STL vector list map set dqueue 等应用举例及PPT讲解示例，代码演示
STL之set实现
duziliulang123的博客
10-17 272
#ifndef __SET_H #define __SET_H #include"rbt.h" #include template,class Alloc=alloc> class set { public: typedef Key key_type; typedef Key value_type; typedef Compare key_compare; typedef Compare
C++ STL set和multiset的使用
weixin_34194359的博客
08-26 122
C++ STL set和multiset的使用 std::set&lt;int&gt; s;那个s这个对象里面存贮的元素是从小到大排序的，(因为用std::less作为比较工具。) 1，set的含义是集合，它是一个有序的容器，里面的元素都是排序好的，支持插入，删除，查找等操作，就   像一个集合一样。所有的操作的都是严格在logn时间之内完成，效率非常高。 set和multiset的区别是：s...
STL 中简单的set总结
Marcus-Bao的个人主页
12-11 1462
1、set会根据特定的排序准则自动将元素排序，set中元素不允许重复,search操作效率会很高O(log n) 2、关于set，必须说明的是set关联式容器。set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出 数据，在set中每个元素的值都唯一，不会重复添加，而且系统能根据元素的值自动进行排序。应该注意的是set中数元素的值不能直接被改变。C++
STL_set
0110_
11-13 882
Set是STL中一种标准关联容器 封装了高效的平衡检索二叉树 用来存放统一数据的集合，集合中值唯一且有序。 其中的元素不能直接被改变 Set的基本用法 需要添加头文件#include<set> c++11中可以像数组一样进行赋值 set<int> a; set支持insert（）插入，不支持push_back（）插入 for(int i=0;i<5;i...
浅析stl序列容器(map和set)的仿函数排序
09-05
STL（Standard Template Library，标准模板库）是C++中一个强大的工具，它提供了一系列的容器、迭代器、算法和仿函数（function object），极大地提高了编程效率和代码可读性。在本文中，我们将深入探讨如何使用仿...
STL中map、set的数据结构及底层实现.docx
10-28
在这个文档中，主要讨论了STL中两种关联容器——map和set的数据结构及其底层实现。 首先，map是一个键值对的集合，它将唯一的键映射到相应的值。在STL中，map通常使用红黑树（Red-Black Tree）作为其底层数据结构。...
STL中map、set的数据结构及底层实现.pdf
10-28
STL中的`map`和`set`是两种关联容器，它们都基于一种高效的数据结构——红黑树（Red-Black Tree）来实现。红黑树是一种自平衡的二叉查找树，它保证了在最坏情况下的搜索、插入和删除操作的时间复杂度为O(log n)。...
c++容器list、vector、map、set区别与用法详解
08-19
c++容器是c++标准模板库（STL）中的一个重要组件，提供了多种数据结构的实现，包括list、vector、map、set等。这些容器的使用可以大大提高开发效率和代码可读性。 list容器 list容器是一个双向链表，链表的每个...
以STL::map实现引用表
01-15
以STL::map实现引用表，如有错误，欢迎指教！
STL之set
ancientear的博客
03-18 271
1.set介绍 set容器是一种实现了平衡二叉树的数据结构，容器中的数据不能重复，即每个数据都是唯一的，并且会对存进去的数据进行自动排序。 构造set集合的主要目的是为了快速检索，去重与排序，使用set前，需要在程序头文件中包含声明#include&amp;lt; set&amp;gt; 2.set常用函数 insert(): 插入元素 erase(): 删除元素 find(): 返...
(第十二步) STL: stl_set容器实现
xfy_von的博客
08-14 150
set 特性： set所有元素都会根据元素的键值自动被排序。 set元素的键值就是实值，实值就是键值。 set不允许两个元素有相同的键值。 正常set的迭代器不可以改变set的元素值，但是前面红黑树迭代器设计偷了个懒，导致没能设计好const_iterator，其他的性能没有问题。 set设计完全使用红黑树的底层机制，所使用的接口完全由红黑树所提供的，因此set实现非常简单，都是调用红黑树的操作。 实现功能 begin() end()const empty() size() clear() find(
STL——map和set模拟实现
smx_dd的博客
01-26 337
map和set的底层是使用红黑树来实现的，接下来我利用红黑树来模拟实现一下map和set。 map详解博客链接：https://blog.csdn.net/smx_dd/article/details/86531881 set详解博客链接：https://blog.csdn.net/smx_dd/article/details/86555973 红黑树详解与实现博客链接：https://blog....
【STL】模拟实现STL中set容器
宫瑞阳的博客
03-01 170
模拟实现STL中set容器
STL中vector，Map，Set的实现原理
不很正派的专栏
01-29 5702
vectorvector的数据安排以及操作方式，与array非常类似，两者唯一的区别是空间运用的灵活性，array是静态空间，一旦配置了就不能改变，如果你想要大一点的空间，就必须首先配置一块新空间，然后将原来的元素一一复制进来，再把原来的空间释放给系统。但是vector是动态空间，随着元素的增加，它的内部机制会自行扩充空间以容纳新元素，因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮
STL容器Set的使用
fuxingdecsdn的博客
11-19 1641
首先了解一下set，我们所知道的set是STL中的一个容器，但是set实质上也是有不同的版本，我们最根本的划分就是根据其底层实现分别是红黑树和hash表分为两种，首先这两种结构最本质的区别就是有序和无序，红黑树的存储是有序的而hash表是无序存储，但它并不影响set的最主要的用法就是查找，而从查找角度来说hash表是更优于红黑树，从时间复杂度进行分析，红黑树的时间复杂度为O(logN)，而hash表
C++ STL set详解
Allen的博客
07-29 8813
C++ STL set详解 一.解释 　　关于set，必须说明的是set关联式容器。 set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出数据，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。 二.用法 1.头文件 #include &lt;set&gt; 2.常用操作 set&lt;int&gt; s 定义一个set容器 类型为...
c++stl，map和unordered_map
最新发布
06-28
C++ STL是C++标准库的一部分，包含了许多常用的数据结构和算法，如vector、list、map、set等。STL的设计目的是提供高效、可靠、通用的数据结构和算法，使得程序员可以更加方便地编写高质量的代码。 map和unordered_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值