C++进阶:3_二叉树进阶

于 2024-09-03 14:12:38 发布
阅读量797 收藏 18
点赞数 16
文章标签： c++ 数据结构 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Open__Ai/article/details/141860334
版权

二叉树进阶

一.内容安排说明

二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为：

  1. map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构
  2. 二叉搜索树的特性了解，有助于更好的理解map和set的特性
  3. 二叉树中部分面试题稍微有点难度，在前面讲解大家不容易接受，且时间长容易忘
  4. 有些OJ题使用C语言方式实现比较麻烦，比如有些地方要返回动态开辟的二维数组，非常麻烦。

因此本节借二叉树搜索树，对二叉树部分进行收尾总结。

二. 二叉搜索树

1. 二叉搜索树概念

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

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

image-20240903132717564

  • 补充
  1. 二叉搜索树的中序遍历(左子树 根 右子树)是升序
  2. 默认定义,搜索树不允许沉余(没有相同值)

2. 二叉搜索树操作(现阶段所讲的搜索树不允许修改。KV结构可以修改)

image-20240903133119582

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};
  1. 二叉搜索树的查找
    a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
    b、最多查找高度次，走到到空，还没找到，这个值不存在。
  2. 二叉搜索树的插入
    插入的具体过程如下：
    a. 树为空，则直接新增节点，赋值给root指针
    b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

image-20240903133411405

  1. 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点

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

  • 情况a：直接删除

  • 情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除

  • 情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除

  • 情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除

替换法删除

image-20240903133752422

  1. 替换节点可以直接删除:因为替换节点要么没有孩子,要么只有一个孩子

  2. 左子树最大节点没有右孩子,右子树最小节点没有左孩子

  3. 右子树最小节点找法:从右子树的根开始找左子树,当该节点没有左子树时,该节点即为最小值(即右子树最小节点).

    左子树最小节点找法同理.

  4. 搜索二叉树的最左节点是最小节点(值最小)，最右结点是最大节点(值最大).

image-20240903134248259

3. 二叉搜索树的实现

  • 此处为简单的初步实现,具体实现代码在后面
template<class T>
struct BSTNode
{
	BSTNode(const T& data = T())
		: _pLeft(nullptr), _pRight(nullptr), _data(data)
	{}
	BSTNode<T>* _pLeft;
	BSTNode<T>* _pRight;
	T _data;
};
template<class T>
class BSTree
{
	typedef BSTNode<T> Node;
	typedef Node* PNode;
public:
	BSTree() : _pRoot(nullptr)
	{}
	// 同学们自己实现，与二叉树的销毁类似
	~BSTree();
	// 根据二叉搜索树的性质查找：找到值为data的节点在二叉搜索树中的位置
	PNode Find(const T& data);
	bool Insert(const T& data)
	{
		// 如果树为空，直接插入
		if (nullptr == _pRoot)
		{
			_pRoot = new Node(data);
			return true;
		}
		// 按照二叉搜索树的性质查找data在树中的插入位置
		PNode pCur = _pRoot;
		// 记录pCur的双亲，因为新元素最终插入在pCur双亲左右孩子的位置
		PNode pParent = nullptr;
		while (pCur)
		{
			pParent = pCur;
			if (data < pCur->_data)
				pCur = pCur->_pLeft;
			else if (data > pCur->_data)
				pCur = pCur->_pRight;  // 元素已经在树中存在
			else
				return false;
		}
		// 插入元素
		pCur = new Node(data);
		if (data < pParent->_data)
			pParent->_pLeft = pCur;
		else
			pParent->_pRight = pCur;
		return true;
	}
	bool Erase(const T& data)
	{
		// 如果树为空，删除失败
		if (nullptr == _pRoot)
			return false;
		// 查找在data在树中的位置
		PNode pCur = _pRoot;
		PNode pParent = nullptr;
		while (pCur)
		{
			if (data == pCur->_data)
				break;
			else if (data < pCur->_data)
			{
				pParent = pCur;
				pCur = pCur->_pLeft;
			}
			else
			{
				pParent = pCur;
				pCur = pCur->_pRight;
			}
		}
		// data不在二叉搜索树中，无法删除
		if (nullptr == pCur)
			return false;
		// 分以下情况进行删除，同学们自己画图分析完成
		if (nullptr == pCur->_pRight)
		{
			// 当前节点只有左孩子或者左孩子为空---可直接删除
		}
		else if (nullptr == pCur->_pRight)
		{
			// 当前节点只有右孩子---可直接删除
		}
		else
		{
			// 当前节点左右孩子都存在，直接删除不好删除，可以在其子树中找一个替代结点，比如：
			// 找其左子树中的最大节点，即左子树中最右侧的节点，或者在其右子树中最小的节点，即右子树中最小的节点
			// 替代节点找到后，将替代节点中的值交给待删除节点，转换成删除替代节点
		}
		return true;
	}
	// 同学们自己实现
	void InOrder();
private:
	PNode _pRoot;
};

4. 二叉搜索树的应用

  1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
    比如：**给一个单词word，判断该单词是否拼写正确，**具体方式如下：
  • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
  • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
  1. **KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。**该种方式在现实生活中非常常见：
  • 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
  • 再比如统计**单词次数，**统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。
// 改造二叉搜索树为KV结构
template<class K, class V>
struct BSTNode
{
	BSTNode(const K& key = K(), const V& value = V())
		: _pLeft(nullptr), _pRight(nullptr), _key(key), _Value(value)
	{}
	BSTNode<T>* _pLeft;
	BSTNode<T>* _pRight;
	K _key;
	V _value
};
template<class K, class V>
class BSTree
{
	typedef BSTNode<K, V> Node;
	typedef Node* PNode;
public:
	BSTree() : _pRoot(nullptr) {}
	PNode Find(const K& key);
	bool Insert(const K& key, const V& value)
		bool Erase(const K& key)
private:
	PNode _pRoot;
};
void TestBSTree3()
{
	// 输入单词，查找单词对应的中文翻译
	BSTree<string, string> dict;
	dict.Insert("string", "字符串");
	dict.Insert("tree", "树");
	dict.Insert("left", "左边、剩余");
	dict.Insert("right", "右边");
	dict.Insert("sort", "排序");
	// 插入词库中所有单词
	string str;
	while (cin >> str)
	{
		BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret == nullptr)
		{
			cout << "单词拼写错误，词库中没有这个单词:" << str << endl;
		}
		else
		{
			cout << str << "中文翻译:" << ret->_value << endl;
		}
	}
}
void TestBSTree4()
{
	// 统计水果出现的次数
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
   "苹果", "香蕉", "苹果", "香蕉" };
	BSTree<string, int> countTree;
	for (const auto& str : arr)
	{
		// 先查找水果在不在搜索树中
		// 1、不在，说明水果第一次出现，则插入<水果, 1>
		// 2、在，则查找到的节点中水果对应的次数++
		//BSTreeNode<string, int>* ret = countTree.Find(str);
		auto ret = countTree.Find(str);
		if (ret == NULL)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.InOrder();
}

5. 二叉搜索树的性能分析

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

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

image-20240903135253256

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log2N

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N2

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上场了。

三. 二叉树进阶面试题

这些题目更适合使用C++完成，难度也更大一些

  1. 二叉树创建字符串。OJ链接
  2. 二叉树的分层遍历1。OJ链接
  3. 二叉树的分层遍历2。OJ链接
  4. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。OJ链接
  5. 二叉树搜索树转换成排序双向链表。OJ链接
  6. 根据一棵树的前序遍历与中序遍历构造二叉树。 OJ链接
  7. 根据一棵树的中序遍历与后序遍历构造二叉树。OJ链接
  8. 二叉树的前序遍历，非递归迭代实现 。OJ链接
  9. 二叉树中序遍历 ，非递归迭代实现。OJ链接
  10. 二叉树的后序遍历 ，非递归迭代实现。OJ链接

四.二叉搜索树的实现

namespace key
{
	template<class K>
	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)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			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
				{
					return false;
				}
			}
			cur = new Node(key);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}

		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;
		}

		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 (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					//右孩子空,父亲指向我的左
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					//左右孩子都有,替换法删除
					// 
					// 查找右子树的最左节点替代删除
					else
					{
						Node* rightMinParent = cur;//rightMinParent不能初始化为nullptr;
						Node* rightMin = cur->_right;//可能会导致rightMinParent->_left变成野指针的使用
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}
						swap(cur->_key, rightMin->_key);
						//不能swap待删除节点的_key和替换节点_key后递归删除key;
						//因为交换后已经不满足搜索二叉树, 找不到待删除节点。
						if (rightMin == rightMinParent->_left)
						{
							rightMinParent->_left = rightMin->_right;
						}
						else
						{
							rightMinParent->_right = rightMin->_right;
						}
						delete rightMin;
					}
					return true;
				}
			}
			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)	//root不能弄成缺省值,this是形参这块用不了
		{							//3种办法:1.友元2.get3.套一层
			if (root == nullptr)	//类里面写递归都会套一层
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
}

image-20240903141033125

namespace key_value
{
	template<class K,class V>
	struct BSTreeNode
	{
		BSTreeNode<K,V>* _left;
		BSTreeNode<K,V>* _right;
		K _key;
		V _value;

		BSTreeNode(const K& key,const V& value)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			,_value(value)
		{}
	};

	template<class K,class V>
	class BSTree
	{
		typedef BSTreeNode<K,V> Node;
	public:
		bool Insert(const K& key,const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key,value);
				return true;
			}

			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
				{
					return false;
				}
			}
			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 cur;//即nullptr,此时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 (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					//右孩子空,父亲指向我的左
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					//左右孩子都有,替换法删除
					// 
					// 查找右子树的最左节点替代删除
					else
					{
						Node* rightMinParent = cur;//rightMinParent不能初始化为nullptr;
						Node* rightMin = cur->_right;//可能会导致rightMinParent->_left变成野指针的使用
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}
						swap(cur->_key, rightMin->_key);
						//不能swap待删除节点的_key和替换节点_key后递归删除key;
						//因为交换后已经不满足搜索二叉树, 找不到待删除节点。
						if (rightMin == rightMinParent->_left)
						{
							rightMinParent->_left = rightMin->_right;
						}
						else
						{
							rightMinParent->_right = rightMin->_right;
						}
						delete rightMin;
					}
					return true;
				}
			}
			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)	//root不能弄成缺省值,this是形参这块用不了
		{							//3种办法:1.友元2.get3.套一层
			if (root == nullptr)	//类里面写递归都会套一层
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_key << ":"<<root->_value<<endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
}
小糖学代码
关注
  • 16
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++进阶：二叉树进阶
qq_71925940的博客
04-28 398
二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为：1.先铺垫二叉搜索树，而二叉搜索树也是一种树形结构2.3.因此本节借二叉树搜索树，对二叉树部分进行收尾总结。，或者是具有以下性质的二叉树。
C++进阶：搜索树
qq_71806743的博客
04-20 2014
【代码】C++进阶：搜索树。
C++进阶：AVL树
qq_71806743的博客
04-27 763
4. 根据抽象模型的实际场景数分析。
C++进阶：map和set
qq_71925940的博客
04-28 844
5.
C++进阶：红黑树
qq_71806743的博客
04-28 950
抽象子树结构cde中每条路径中有两个黑色结点。抽象子树cde中每条路径都包含一个黑色结点。抽象子树abcde为空。
C++进阶数据结构_AVL树
代码铺子
06-05 452
AVL是一颗绝对平衡的二叉搜索树，要求每个节点的左右子树的高度差的绝对值不超过1，这样可以保证查询时候的时间复杂度为logN。
C++_进阶：二叉搜索树
Lvision2的博客
08-17 745
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，4. 当**树不为空(root!= nullptr )**时，，再来处理该结点的删除问题–替换法删除。情况3比前两种复杂一点，需要在它的。先查找元素是否在二叉搜索树中，插入和删除操作都必须先查找，再实现二叉搜索树本体。
C++进阶：map与set容器的使用
qq_71806743的博客
04-24 1054
【代码】C++进阶：map与set容器的使用。
C++_进阶：AVL树模拟实现
Lvision2的博客
08-22 601
父节点指针变量，以及平衡因子变量。int _bf;
进阶C++__STL__set/ multiset和map/ multimap使用方法
qq_61386381的博客
08-21 895
一、关联式容器 二、键值对 三、树形结构的关联式容器 set/ multiset 容器 set基本概念 set构造和赋值 set大小和交换 set插入和删除 set查找和统计 set和multiset区别 set / multiset总结 pair对组创建 set容器排序 内置类型指定排序规则 自定义数据类型指定排序规则 map/ multimap容器 map基本概念 map构造和赋值 map大小和交换 map插入和删除 map查找和统计 map容器排序 map
Lever_3_C++进阶-STL_Day16-20
GaoJuno23的博客
06-02 683
Day_16 1-函数模版 ​ C++可以通过 重载 写很多一样名字的函数，然后根据参数进行选择调用： void swap1(char &a, char &b) void swap1(int &a, int &b) ​ 但是这样还不够简单！可以通过 函数模板 的方式，就只用写一个了！（和写函数差不多）。 ​ 函数模板的本质是类型的参数化。 template <typename T1> //写多少种T就要用多少种 void myswap(T1 &a,
C++进阶：STL之树形结构的关联式容器2（底层结构相关：二叉搜索树）
碧瑶的博客呀
10-22 281
底层结构 二叉搜索树 1、概念： 二叉搜索树又称二叉排序树，它可以是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 2、二叉搜索树的操作 （1）先实现构造 （2）查找：给定一个值data，如果data等于根结点的值，返回true表示找到了，如果data&...
C++进阶：STL之树形结构的关联式容器3（底层结构相关：AVL树）
碧瑶的博客呀
10-22 312
AVL树 虽然二叉搜索树可以提高查找的效率，但是如果数据有序或者接近有序，就有可能退化成单支树，查找元素相当于在顺序表中搜索元素，效率低下；因此，有两位数学家提出了解决上述问题的方法，就是当向二叉搜索树中插入某个结点后，保证每个结点的左右子树之差的绝对值不大于1，这需要对树中的结点进行调整。 一棵AVL树是空树，或者满足： 左右子树都是AVL树并且左右子树高度之差（平衡因子）的绝对值不超过1 1...
C++进阶：STL之树形结构的关联式容器4（底层结构：红黑树）
碧瑶的博客呀
11-05 354
红黑树的概念、性质（重要）、定义、实现（重要）、插入（重要）； 红黑树的迭代器、改造红黑树、使用红黑树实现map和set（重要）
【通讯协议数据采用大/小端存储的探讨】
最新发布
Joseph Wen的博客
09-02 547
本文探讨了解了小端存储的概念和实现方法并通过一个简单的C语言程序示例，展示了如何在通讯协议中采用小端存储。
c语言赋值截断
hutaotaotao的博客
09-02 468
c语言赋值过程与截断行为
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1204
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 3859
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值