数据结构——AVL树

已于 2023-04-05 19:47:24 修改
阅读量289 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 AVL树
于 2023-04-02 17:14:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57249790/article/details/129908331
版权

目录

概念

结点定义

插入

旋转

左单旋

右单旋 

条件：parent->_bf == -2 && cur->_bf == -1​编辑

左右双旋

右左单旋

 验证

步骤

完整代码（包含验证代码）

总结

概念

二叉搜索树虽然可以提高我们查找数据的效率，但如果插入二叉搜索树的数据是有序或接近有序的，此时二叉搜索树会退化为单支树，在单支树当中查找数据相当于在单链表当中查找数据，效率是很低下的。

因此，两位俄罗斯的数学家G.M.A delson-Velskii和E.M.Landis在1962年发明了解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1（需要对树中的结点进行调整），即可降低树的高度，从而减少平均搜索长度。

AVL树可以是一棵空树，也可以是具有以下性质的一棵二叉搜索树：

  1. 树的左右子树都是AVL树。
  2. 树的左右子树高度之差（简称平衡因子）的绝对值不超过1（-1/01）。

如果一棵树是平衡的，那么它就是一颗AVL树。

结点定义

我们不同于普通的二叉搜索树的是，我们的AVL树的结点需要多一个父指针指向自己的父节点，还有一个记录平衡因子的变量，构成了特殊的三叉链结构。因为我们要保持AVL树的左右子树高度差的绝对值不超过1，所以要对树的结构进行旋转。所以通过看平衡因子的值就能知道是否左右子树高度不超过1。

template<class K, class V>
struct AVLTreeNode
{
    //需要存储的键值对
	pair<K, V> _kv;
    //特殊的三叉链结构
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;

	int _bf;//平衡因子（balance factor）
    //构造函数
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{}
};

插入

插入是我们学习AVL树的重点，因为我们可以通过插入来很好的学习到AVL树调节平衡的过程。

规则：

1、按照二叉搜索树的规则进行插入即可。

2、在插入的过程中去调节平衡因子。

平衡因子：

1、若是在parent的左边新增了结点，那么parent->_br--;

2、若是在parent的右边新增了结点，那么parent->_br++;

3、如果更新完平衡因子之后parent->_br为0。说明更新之前平衡因子是-1或者1，更新之后补全了矮的那棵树，所以为0，则不用继续往上更新平衡因子。

4、如果更新完平衡因子之后parent->_br为-1或1.说明更新之前平衡因子是0，因此更新后使parent的左树或者右树高了1，因此应该向上继续调整平衡因子。

5、如果更新完平衡因子之后parent->_br为-2或2.说明更新之前平衡因子是-1或1.当前的树已经严重不平衡，应当立即调节。

旋转

左单旋

条件：parent->_bf == 2 && cur->_bf == 1

注意：parent可能也有父节点，要注意进行链接。

void RotateL(Node* parent)
	{
		//先定义（链接好）我们需要用的两个结点
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* ppNode = parent->_parent;

		//旋转
		parent->_right = subRL;
		if (subRL)//若subRL为空就不能对其解引用了
			subRL->_parent = parent;



		subR->_left = parent;
		parent->_parent = subR;

		//进行根的链接工作
		if (ppNode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		//这个ppNode如果不为空，说明我们所遍历的这个树只是
		//一个子树，还要进行链接工作
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = nullptr;

		}
		subR->_bf = parent->_bf = 0;
	}

右单旋 

条件：parent->_bf == -2 && cur->_bf == -1

 与左单选相似！

void RotateR(Node* parent)
	{
		//定义
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppNode = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;


		subL->_right = parent;
		parent->_parent = subL;

		if (ppNode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		//这个ppNode如果不为空，说明我们所遍历的这个树只是
		//一个子树，还要进行链接工作
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		subL->_bf = parent->_bf = 0;
	}

左右双旋

条件：parent->_bf == -2 && cur->_bf == 1

 

 左右双旋需要注意的是，我们复用了单旋的步骤，但是不能复用他们最终平衡因子的赋值，因此我们需要自己一步一步的走，来计算最后各个节点的平衡因子。

void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);


		if (bf == -1)//左子树是新增
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)//右子树是新增
		{
			subL->_bf = -1;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 0)//subLR自身是新增的
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

右左单旋

条件：parent->_bf == 2 && cur->_bf == -1

void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == -1)//左子树是新增
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)//右子树是新增
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = -1;
		}

		else if (bf == 0)//subLR自身是新增的
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

 验证

步骤

1、首先我们要验证它是一个二叉搜索树，利用中序遍历是一个有序的序列就能得以验证。

2、验证是否为平衡二叉树，利用递归去计算树的高度，只要每个结点的两个子树高度之差的绝对值不大于1就说明是平衡二叉树。（可以顺便检查我们所计算的平衡因子是否异常）。

3、我们可以用一个随机数来进行插入，然后进行中序遍历，这样更能保证我们的树没问题。

完整代码（包含验证代码）

#pragma once
#include<assert.h>
#include<time.h>

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

	int _bf;//平衡因子balance factor

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{}
};


template<class K, class V>
struct AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		//如果为空树  直接插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}



		//创建一个父节点 以便于链接工作
		Node* parent = nullptr;
		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);

		if (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		//更新平衡因子
		while (parent)//parent为空，也就更新到根了
		{
			// 新增在右，parent++
			// 新增在左，parent--

			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				break;
			}



			//是否继续更新的依据：子树的高度是否变化
			// 1、parent->_bf==0说明之前parent->_bf 是 1  或者  -1
			// 说明之前parent一边高一边低，这次插入填上了之前矮的那边，parent所在的子树高度不变，不需要往上更新
			// 2、parent->_bf==1或-1说明之前是parent->_bf==0，两边一样高，现在插入一边更高了
			//parent所在子树高度变了，继续往上更新
			// 3、parent->_bf==2或-2，说明之前parent->_bf==1或者 -1，现在插入之后严重不平衡，违反规则
			// 就地处理--旋转
			// 
			// 
			// 
			// 旋转：
			// 1、让这颗子树左右高度不超过1
			// 2、旋转过程中继续保持他是搜索树
			// 3、更新调整孩子结点的平衡因子
			// 4、让这颗子树的高度跟插入前保持一致
			//

			//平衡因子为0说明这棵树已经是平衡二叉树了直接break
			if (parent->_bf == 0)
			{
				break;
			}
			//平衡因子是1或者-1说明这棵子树不需要更新了
			//继续找父亲向上更新
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			//平衡因子等于2说明当前父节点的子树已经严重不平衡
			//根据具体类型进行旋转
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//旋转
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}

			}
			//这个break非常关键 
			//因为我们已经把平衡因子调节完毕了就不需要在这颗树里面继续调平衡了
			break;

		}

	}
	void RotateL(Node* parent)
	{
		//先定义（链接好）我们需要用的两个结点
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* ppNode = parent->_parent;

		//旋转
		parent->_right = subRL;
		if (subRL)//若subRL为空就不能对其解引用了
			subRL->_parent = parent;



		subR->_left = parent;
		parent->_parent = subR;

		//进行根的链接工作
		if (ppNode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		//这个ppNode如果不为空，说明我们所遍历的这个树只是
		//一个子树，还要进行链接工作
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = nullptr;

		}
		subR->_bf = parent->_bf = 0;
	}
	void RotateR(Node* parent)
	{
		//定义
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppNode = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;


		subL->_right = parent;
		parent->_parent = subL;

		if (ppNode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		//这个ppNode如果不为空，说明我们所遍历的这个树只是
		//一个子树，还要进行链接工作
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		subL->_bf = parent->_bf = 0;
	}
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);


		if (bf == -1)//左子树是新增
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)//右子树是新增
		{
			subL->_bf = -1;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 0)//subLR自身是新增的
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == -1)//左子树是新增
		{
			subR->_bf = -1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)//右子树是新增
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 1;
		}

		else if (bf == 0)//subLR自身是新增的
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void Inorder()
	{
		_Inorder(_root);
	}
	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 lh = Height(root->_left);
		int rh = Height(root->_right);

		return lh > rh ? lh + 1 : rh + 1;
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		if (rightHeight - leftHeight != root->_bf)
		{
			cout << "平衡因子异常" << endl;
			return false;
		}

		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

private:
	Node* _root = nullptr;
};

//写入几个树进行验证
//void TestAVLTree()
//{
//	//int a[] = { 8, 3, 1,10,6,4,7,14,13 };
//	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
//	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
//	AVLTree<int, int> t;
//	for (auto e : a)
//	{
//		t.Insert(make_pair(e, e));
//	}
//	t.Inorder();
//	cout << t.IsBalance();
//}
// 
// 
//利用随机值进行验证
void TestAVLTree()
{
	srand(time(0));
	const size_t N = 10;
	AVLTree<int, int> t;
	for (size_t i = 0; i < N; i++)
	{
		size_t x = rand();
		t.Insert(make_pair(x,x));
	}
	t.Inorder();
	cout << t.IsBalance();
}

总结

关于AVL树，我们只是做一个了解。在以后的运用中很少使用AVL树，但是AVL树的旋转是一个重点，我们需要去了解每种情况的过程是怎么发生的。AVL树的优势在于查找效率，由于有优越的（平衡因子不大于1）性质，使得它的查找效率为logN。

袁百万
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构课程设计——基于Avl树的用户登陆系统.zip
09-29
1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合...
关于AVL（二叉平衡树）的插入讲解，很简单
ScreaM的备忘录！
12-12 6024
AVL又称二叉平衡树，是会自平衡的二叉搜索树，左孩子比自己小，右孩子比自己大，关键在于他的每一个节点左右孩子高度差绝对值不会超过1 实际上我上网查了好几次AVL的详解，关于里面怎么平衡，单左，单右，左右双旋，右左双旋，是知道怎么转的，但那唯一一点删除啃了好几次没啃动。这次天梯赛选拔赛练习题里面有一道AVL插入题，就先把插入这块给捋一捋吧。 插入这块实际上不难，都是几个简单的函数（左转右转之类的）合...
AVL树详解
nullcanon的博客
03-24 486
AVL树 AVL树是一个高度平衡的二叉搜索树，我们知道，二叉搜索树在最理想的情况下的时间复杂度为O(logN)，但在极度差的情况下(比如左右单只)，二叉搜索树会退化成一个单链表，时间复杂度退化为O(n)，为了保证二叉搜索树的效率控制在O(logN)，对二叉树做一些改变，是的它变为极度平衡的VAL树。 AVL树的定义 一棵AVL树或者是空树，或者是左右子树都是AVL树，其中左右子树的高度之差(...
C++数据结构 —— AVL树
weixin_59913110的博客
02-26 527
AVL树是map/set/multimap/multi/set等容器的一种底层结构，其本质就是一颗二叉搜索树。但因为二叉搜索树很容易退化成单支树，所以AVL树便是对二叉搜索树进行升级改造，使其平衡。向二叉搜索树插入节点，保证每个节点的左右子树高度差不超过1(可以包括1)，如果确实达不到这种要求，就需要通过特定的算法来达到这样的要求。一颗AVL树可以是空树，也可以是具有以下性质的二叉搜索树1.每个节点的左右子树都是AVL树2.每个节点的左右子树的高度差不超过1(可以包括1)
数据结构—— AVL树
qq_63976098的博客
10-13 274
AVL大全
数据结构与算法AVL树类的C++实现
01-20
关于AVL树的简介可以参考： 数据结构与算法——AVL树简介 　关于二叉搜索树（也称为二叉查找树）可以参考：数据结构与算法——二叉查找树类的C++实现 　AVL-tree是一个加上了额外平衡条件的二叉搜索树，其平衡条件...
斯坦福cs223-数据结构课件
04-28
数据结构通常与算法一起讨论，因为它们紧密相关——算法可以看作是对数据结构进行操作的方法。 常见的数据结构包括： 1. **数组（Array）**：一种基础的数据结构，用于存储一系列有序的元素。数组的特点是元素可以...
数据结构演示软件
06-02
 数据——设置算法演示的数据（数据结构）。  调用栈——察看当前函数（或过程）嵌套或递归的历程。  说明——察看算法说明。  暂停——中断演示过程。  执行——连续执行算法直至所设断点或至算法...
数据结构C++描述
03-15
数据结构C++描述 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 3 1.2.3 引用参数 3 1.2.4 常量引用参数 4 1.2.5 返回值 4 1.2.6 递归...
初阶数据结构之双向链表详解
2302_80837091的博客
05-18 1070
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表，因此，本节的双向链表也是双向循环链表。在List.h中定义链表结点，data的类型设为DataType,方便以后使用其他类型的数据。}ListNode;
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
最新发布
qq_50891451的博客
05-22 461
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
数据结构中时间复杂度的介绍
gygkhd的博客
05-17 815
在计算机科学领域，特别是在数据结构和算法的研究中，时间复杂度是一个非常关键的概念。它表示一个算法执行完成所需要的计算工作量。了解时间复杂度有助于预测程序运行的速度和效率，这对于优化程序和解决大规模数据处理问题尤为重要。时间复杂度通常用大O符号（O-notation）来表示，它描述了算法性能与输入数据之间的关系。大O符号忽略了常数和低阶项，只关注程序执行时间随输入数据规模增长的变化趋势。例如，时间复杂度为O(n)的算法表示执行时间与输入数据的规模成线性关系。
【数据结构】堆（Heep）
SWsunlight的博客
05-17 1122
堆、堆的实现
数据结构--栈和队列 源码
Mike的博客
05-18 625
数据结构——栈和队列的实现
【数据结构】——（二叉树）堆
2302_81257639的博客
05-18 658
1.树概念及结构树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。有一个特殊的结点，称为根结点，根结点没有前驱结点除根结点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1
Python的数据结构的方法和最佳实践
weixin_55100524的博客
05-18 758
Python 提供了丰富的数据结构，每种数据结构都有其独特的方法和最佳实践。了解并合理运用这些数据结构，对于编写高效、可维护的代码至关重要。在本文中，我们将详细探讨列表、元组、字典和集合的常用方法及其最佳实践。
P1【知识点】【数据结构】【链表LinkedList】C++版
qq_50891451的博客
05-17 1122
需要注意的是，在具体实现的时候，需要先暂存C结点的指针，先将其赋值给F结点指针，然后再将F结点的地址赋值给C结点的指针，否则会丢失D结点的地址，链表就会在此处断开。链表类list的声明如下，主要实现了以下操作。假如需要在C结点后面插入F结点，只需要使C结点的指针指向F，F结点的指针指向结点D即可，如图所示。删除操作需要注意的是，每个结点都是通过new在堆区申请的内存，因此删除节点需要手动释放其内存。假如需要删除D结点，则直接让C结点的指针指向E结点即可，如图所示。【203】移除链表元素。
P1【练习力扣203,206】【数据结构】【链表LinkedList】C++版
qq_50891451的博客
05-18 262
总结：应理解dummy_Node的含义，指向头结点的哑节点。
数据结构中avl树是什么意思
04-23
AVL树是一种自平衡二叉搜索树，它的每个节点都保存着一个平衡因子，用来描述它的左子树和右子树的高度差。AVL树在插入或删除一个节点时都会自动调整，使得整棵树保持平衡，从而具有较好的查找、插入和删除性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

袁百万

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

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

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

打赏作者

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

抵扣说明：

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

余额充值