C++ AVL树

原创 已于 2025-07-25 14:27:26 修改 · 820 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

于 2024-07-24 15:32:43 首次发布

1.概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查
找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii
和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树\的高度，从而减少平均搜索长度。
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
1. 它的左右子树都是AVL树
2. 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
如果一棵二叉搜索树是高度平衡，它就是AVL树。如果它有n个结点，其高度可保持在O(\log_{2}n)，搜索时间复杂度O(\log_{2}n)。
                                     

2.AVL树节点的定义

template <class K, class V>
	//结点
	struct AVLTreeNode
	{
		//构造函数
		AVLTreeNode(const pair<K,V>& kv)
			:_left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			, _bf(0)
			, _kv(kv)
		{}
		//成员变量
		AVLTreeNode* _left;
		AVLTreeNode* _right;
		AVLTreeNode* _parent;
		int _bf;//平衡因子
		pair<K, V> _kv;//节点数据
	};

3.AVL树的构造函数

//构造函数
		AVLTree()
			:_root(nullptr)
		{}
		//析构函数
		void _Destroy(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_Destroy(root->_left);
			_Destroy(root->_right);
			delete root;
		}
		~AVLTree()
		{
			_Destroy(_root);
			_root = nullptr;
		}

4. AVL树的插入

我们规定平衡因子_bf为右子树的高度减去左子树的高度，且平衡因子_bf的取值范围为-1到1，则一颗树有如下平衡因子为0，1，-1的三种情况。

旋转要保持的要求：
1.旋转后也是搜索二叉树。
2.变成平衡树并且降低树的高度。

右单旋

我们在subL节点的左子树插入了一个节点，导致parent失衡，接着我们就要尝试调整节点，让这棵树平衡。

由于subL的右子树subLR高度为h-1，而parent的右子树高度也为h-1，此时我们可以想办法把这两个h-1的等高子树凑到一起去，于是我们把parent的左子树断开，把subL的右子树拿去给parent做左子树，此时parent就得到了等高的两棵子树。也就是第二张图片的情况。随后，以parent为根的树，总高度为h，而subL的左子树刚好高度也是h-1+1 = h，所以我们可以把parent交给subL做子树，这样subL的两边也就平衡了。而刚刚我们把subL的右子树空出来了，此时可以直接转移，就得到了第三种图片的情况。

这个情况下，我们以subL为根的树是一颗平衡的树，而且平衡因子为0，插入节点前以parent为根的子树，高度为h+1，插入节点且旋转后高度仍为h+1。插入前后高度不变，不会影响父节点，直接跳出循环。

//右单旋
		void RotateR(Node* parent)
		{
			Node* subL = parent->_left;
			Node* subLR = subL->_right;
			Node* grandparent = parent->_parent;
			parent->_left = subLR;
			if (subLR)
			{
				subLR->_parent = parent;
			}
			subL->_right = parent;
			parent->_parent = subL;
			if (parent == _root)
			{
				_root = subL;
			}
			else
			{
				if (grandparent->_left == parent)
					grandparent->_left = subL;
				else
					grandparent->_right = subL;
			}
			subL->_parent = grandparent;
			//调整平衡因子
			parent->_bf = subL->_bf = 0;
		}

左单旋

左单旋与右单旋同理

//左单旋
		void RotateL(Node* parent)
		{
			Node* subR = parent->_right;
			Node* subRL = subR->_left;
			Node* grandparent = parent->_parent;
			parent->_right = subRL;
			if (subRL)
			{
				subRL->_parent = parent;
			}
			subR->_left = parent;
			parent->_parent = subR;
			if (parent == _root)
			{
				_root = subR;
			}
			else
			{
				if (grandparent->_left == parent)
					grandparent->_left = subR;
				else
					grandparent->_right = subR;
			}
			subR->_parent = grandparent;
			//调整平衡因子
			parent->_bf = subR->_bf = 0;
		}

左右双旋

当出现图一这种插入情况时，又要将该情况分为图二和图三两种情况，也就是对subLR进行了再细分，到底新节点插入了左子树还是右子树。

在subLR的左子树插入后旋转，调整后 parent的平衡因子：1，   subL 的平衡因子：0 ，  subLR的平衡因子：0
在这里插入图片描述

 在subLR的右子树插入后旋转，调整后 parent的平衡因子：0， subL 的平衡因子：-1，  subLR的平衡因子：0
在这里插入图片描述

//左右双旋
		void RotateLR(Node* parent)
		{
			Node* subL = parent->_left;
			Node* subLR = subL->_right;
			int bf = subLR->_bf;
			RotateL(subL);
			RotateR(parent);
			if (bf == 1)
			{
				subL->_bf = -1;
				subLR->_bf = 0;
				parent->_bf = 0;
			}
			else if (bf == -1)
			{
				subL->_bf = 0;
				subLR->_bf = 0;
				parent->_bf = 1;
			}
			else if (bf == 0)
			{
				subL->_bf = 0;
				subLR->_bf = 0;
				parent->_bf = 0;
			}
		}

右左双旋

在subRL的左子树插入后旋转，调整后 parent的平衡因子：0，   subR 的平衡因子：0 ，  subRL的平衡因子：1

在subRL的右子树插入后旋转，调整后 parent的平衡因子：-1，   subR 的平衡因子：0 ，  subRL的平衡因子：0

//右左双旋
		void RotateRL(Node* parent)
		{
			Node* subR = parent->_right;
			Node* subRL = parent->_left;
			int bf = subRL->_bf;
			RotateR(subR);
			RotateL(parent);
			if (bf == 1)
			{
				subR->_bf = 0;
				subRL->_bf = 0;
				parent->_bf = -1;
			}
			else if (bf == -1)
			{
				subR->_bf = 1;
				subRL->_bf = 0;
				parent->_bf = 0;
			}
			else if (bf == 0)
			{
				subR->_bf = 0;
				subRL->_bf = 0;
				parent->_bf = 0;
			}
		}

完整的插入代码

		//插入
		pair<Node*, bool> Insert(const pair<K, V>& kv)
		{
			//在第一个位置插入
			if (_root == nullptr)
			{
				_root = new Node(kv);
				return pair<Node*, bool>(_root, true);
			}
			Node* cur = _root, * parent = _root;
			while (cur)
			{
				if (kv.first < cur->_kv.first)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (kv.first > cur->_kv.first)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					//已经存在不插入
					return pair<Node*, bool>(cur, false);
				}
			}
			//创建新结点连接
			cur = new Node(kv);
			cur->_parent = parent;
			if (kv.first < parent->_kv.first)
				parent->_left = cur;
			else
				parent->_right = cur;

			Node* ret = cur;
			//更新平衡因子
			while (cur != _root)
			{
				if (cur == parent->_right)
					parent->_bf++;
				else
					parent->_bf--;
				if (parent->_bf == 0)
				{
					break;
				}
				else if (parent->_bf == 1 || parent->_bf == -1)
				{
					//继续往上更新平衡因子
					cur = parent;
					parent = parent->_parent;
				}
				else if (parent->_bf == 2 || parent->_bf == -2)
				{
					if (parent->_bf == 2)
					{
						//左单旋
						if (cur->_bf == 1)
							RotateL(parent);
						//右左双旋
						else if (cur->_bf == -1)
							RotateRL(parent);
					}
					else if (parent->_bf == -2)
					{
						//右单旋
						if (cur->_bf == -1)
							RotateR(parent);
						//左右双旋
						else if (cur->_bf == 1)
							RotateLR(parent);
					}
					break;
				}
			}
			return pair<Node*, bool>(ret, true);
		}

5. 重载AVL树的[ ]

		//重载[]
		V& operator[](const K& key)
		{
			pair<Node*, bool> ret = Insert(make_pair(key,V()));
			return ret.first->_kv.second;
		}

6. AVL树的判定

		//判断是否为AVLTree
		//要求左右子树的高度差小于等于1，且等于其平衡因子
		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;
		}
		bool _IsAVLTree(Node* root)
		{
			if (root == nullptr)
			{
				return true;
			}
			int LeftHeight = Height(root->_left);
			int RightHeight = Height(root->_right);
			if (RightHeight - LeftHeight!=root->_bf)
			{
				cout << root->_kv.first << "平衡因子异常" << endl;
				return false;
			}
			return abs(LeftHeight - RightHeight) < 2 &&
				_IsAVLTree(root->_left) && _IsAVLTree(root->_right);
		}
		bool IsAVLTree()
		{
			return _IsAVLTree(_root);
		}

7. AVL树的完整代码

#include <iostream>
#include <vector>
using namespace std;
namespace lbk
{
	template <class K, class V>
	//结点
	struct AVLTreeNode
	{
		//构造函数
		AVLTreeNode(const pair<K,V>& kv)
			:_left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			, _bf(0)
			, _kv(kv)
		{}
		//成员变量
		AVLTreeNode* _left;
		AVLTreeNode* _right;
		AVLTreeNode* _parent;
		int _bf;//平衡因子
		pair<K, V> _kv;//节点数据
	};

	template <class K, class V>
	class AVLTree
	{
		typedef AVLTreeNode<K, V> Node;
		//成员变量
		Node* _root;
	public:
		//构造函数
		AVLTree()
			:_root(nullptr)
		{}
		//析构函数
		void _Destroy(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_Destroy(root->_left);
			_Destroy(root->_right);
			delete root;
		}
		~AVLTree()
		{
			_Destroy(_root);
			_root = nullptr;
		}
		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (key < cur->_kv.first)
					cur = cur->_left;
				else if (key > cur->_kv.first)
					cur = cur->_right;
				else
					return cur;
			}
			return nullptr;
		}
		//重载[]
		V& operator[](const K& key)
		{
			pair<Node*, bool> ret = Insert(make_pair(key,V()));
			return ret.first->_kv.second;
		}
		//判断是否为AVLTree
		//要求左右子树的高度差小于等于1，且等于其平衡因子
		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;
		}
		bool _IsAVLTree(Node* root)
		{
			if (root == nullptr)
			{
				return true;
			}
			int LeftHeight = Height(root->_left);
			int RightHeight = Height(root->_right);
			if (RightHeight - LeftHeight!=root->_bf)
			{
				cout << root->_kv.first << "平衡因子异常" << endl;
				return false;
			}
			return abs(LeftHeight - RightHeight) < 2 &&
				_IsAVLTree(root->_left) && _IsAVLTree(root->_right);
		}
		bool IsAVLTree()
		{
			return _IsAVLTree(_root);
		}
		//中序遍历
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_kv.first << " ";
			_InOrder(root->_right);
		}
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
		//插入
		pair<Node*, bool> Insert(const pair<K, V>& kv)
		{
			//在第一个位置插入
			if (_root == nullptr)
			{
				_root = new Node(kv);
				return pair<Node*, bool>(_root, true);
			}
			Node* cur = _root, * parent = _root;
			while (cur)
			{
				if (kv.first < cur->_kv.first)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (kv.first > cur->_kv.first)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					//已经存在不插入
					return pair<Node*, bool>(cur, false);
				}
			}
			//创建新结点连接
			cur = new Node(kv);
			cur->_parent = parent;
			if (kv.first < parent->_kv.first)
				parent->_left = cur;
			else
				parent->_right = cur;

			Node* ret = cur;
			//更新平衡因子
			while (cur != _root)
			{
				if (cur == parent->_right)
					parent->_bf++;
				else
					parent->_bf--;
				if (parent->_bf == 0)
				{
					break;
				}
				else if (parent->_bf == 1 || parent->_bf == -1)
				{
					//继续往上更新平衡因子
					cur = parent;
					parent = parent->_parent;
				}
				else if (parent->_bf == 2 || parent->_bf == -2)
				{
					if (parent->_bf == 2)
					{
						//左单旋
						if (cur->_bf == 1)
							RotateL(parent);
						//右左双旋
						else if (cur->_bf == -1)
							RotateRL(parent);
					}
					else if (parent->_bf == -2)
					{
						//右单旋
						if (cur->_bf == -1)
							RotateR(parent);
						//左右双旋
						else if (cur->_bf == 1)
							RotateLR(parent);
					}
					break;
				}
			}
			return pair<Node*, bool>(ret, true);
		}
	private:
		//左单旋
		void RotateL(Node* parent)
		{
			Node* subR = parent->_right;
			Node* subRL = subR->_left;
			Node* grandparent = parent->_parent;
			parent->_right = subRL;
			if (subRL)
			{
				subRL->_parent = parent;
			}
			subR->_left = parent;
			parent->_parent = subR;
			if (parent == _root)
			{
				_root = subR;
			}
			else
			{
				if (grandparent->_left == parent)
					grandparent->_left = subR;
				else
					grandparent->_right = subR;
			}
			subR->_parent = grandparent;
			//调整平衡因子
			parent->_bf = subR->_bf = 0;
		}
		//右单旋
		void RotateR(Node* parent)
		{
			Node* subL = parent->_left;
			Node* subLR = subL->_right;
			Node* grandparent = parent->_parent;
			parent->_left = subLR;
			if (subLR)
			{
				subLR->_parent = parent;
			}
			subL->_right = parent;
			parent->_parent = subL;
			if (parent == _root)
			{
				_root = subL;
			}
			else
			{
				if (grandparent->_left == parent)
					grandparent->_left = subL;
				else
					grandparent->_right = subL;
			}
			subL->_parent = grandparent;
			//调整平衡因子
			parent->_bf = subL->_bf = 0;
		}
		//左右双旋
		void RotateLR(Node* parent)
		{
			Node* subL = parent->_left;
			Node* subLR = subL->_right;
			int bf = subLR->_bf;
			RotateL(subL);
			RotateR(parent);
			if (bf == 1)
			{
				subL->_bf = -1;
				subLR->_bf = 0;
				parent->_bf = 0;
			}
			else if (bf == -1)
			{
				subL->_bf = 0;
				subLR->_bf = 0;
				parent->_bf = 1;
			}
			else if (bf == 0)
			{
				subL->_bf = 0;
				subLR->_bf = 0;
				parent->_bf = 0;
			}
		}
		//右左双旋
		void RotateRL(Node* parent)
		{
			Node* subR = parent->_right;
			Node* subRL = parent->_left;
			int bf = subRL->_bf;
			RotateR(subR);
			RotateL(parent);
			if (bf == 1)
			{
				subR->_bf = 0;
				subRL->_bf = 0;
				parent->_bf = -1;
			}
			else if (bf == -1)
			{
				subR->_bf = 1;
				subRL->_bf = 0;
				parent->_bf = 0;
			}
			else if (bf == 0)
			{
				subR->_bf = 0;
				subRL->_bf = 0;
				parent->_bf = 0;
			}
		}

	};
}
c++ AVL树 插入 删除
CoderZhuuu
04-14 1280
AVL树的插入很简单，根据BST树的特性插入之后在回溯的过程中调整即可 AVL树的删除也不是很难，一共有三种情况 第一种是左子树为空（右子树为不为空无所谓） 第二种是右子树为空（此时左子树不为空） 这两种直接用另一半子树覆盖当前节点然后删除再回溯调整树即可 第三种是左右子数都不为空 这个情况首先找到要删除的节点，然后找到比该节点大的节点中最小的一个节点（右子树中最左边的节点），或者比该...
C++AVL树
qq_74319491的博客
10-09 1225
介绍了AVL树的概念和详细的具体实现
C++ AVL树(四种旋转,插入)
Wzs040810的博客
12-20 3387
C++ AVL树(四种旋转,插入)
C++ AVL树(详解 完整代码)
SikJ_2020_10_24的博客
03-07 787
{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
基于C++ AVL树的航空客运订票系统【100012693】
06-12
《基于C++ AVL树的航空客运订票系统详解》 航空客运订票系统是现代航空公司运营中的关键组成部分，它能够高效地处理航班信息、预订和退票等业务。本项目以C++编程语言为基础，利用AVL树这一自平衡二叉搜索树的数据...
c++AVL树四种旋转的详细图解
10-28
在计算机科学中，AVL树是一种自平衡二叉搜索树，它在插入、删除和查找操作中维持树的平衡，以确保最坏情况下这些操作的时间复杂度始终为O(log n)，其中n是树中元素的数量。AVL树的平衡通过一系列旋转操作来实现，...
C++ AVL树的实现
07-10
在C++中实现AVL树，通常会涉及以下几个关键部分： 1. **基础结构**：首先，我们需要定义一个表示AVL树节点的结构体或类，它至少包含三个成员：键（key）、高度（height）以及指向左子树和右子树的指针。例如： ```...
计数组合学7.20（平面分拆与RSK算法)
weixin_74905422的博客
08-22 581
实际上，一个反半标准杨表（reverse SSYT）就是一种特殊的平面分拆（移除了无关的0），事实上，在我们定义反半标准杨表时，我们提到了另一个术语“列严格平面分拆”。本节和接下来的两节将致力于讨论整数分拆的一个引人入胜的推广，称为“平面分拆”。我们将基于 RSK 算法以及一种将一对同形状的反半标准杨表合并成单个平面分拆的简单方法，给出一个优雅的双射证明。当我们考虑 RSK 算法的对称性结果定理 7.13.1 时，定理 7.20.1 的一个很好的变体就出现了。的每一列都是互异奇数部分的分拆。
力扣（在排序数组中查找元素的第一个和最后一个位置）
最新发布
weixin_52811458的博客
08-22 687
本文解析了LeetCode 34题，探讨如何在有序数组中高效查找目标值的起始和结束位置。通过分析原始代码的复杂度问题，提出优化方案：采用两次独立的二分查找，分别定位左边界（第一个等于目标值的位置）和右边界（最后一个等于目标值的位置）。优化后的代码逻辑更清晰，时间复杂度保持O(log n)，空间复杂度为O(1)。关键点在于正确处理二分查找的边界条件，先验证左边界有效性，再推导右边界，确保结果准确。
【冒泡排序】
由己
08-19 876
冒泡排序
SHA 系列算法教程
m0_71071763的博客
08-22 101
SHA（Secure Hash Algorithm）是一组密码学哈希函数，由美国国家安全局（NSA）设计，美国国家标准与技术研究院（NIST）发布。
数据结构与算法-算法-283移动零
weixin_69759588的博客
08-22 177
该题目要求原地将数组中的零移动到末尾，保持非零元素顺序。解题关键在于双指针技巧：指针i标记已处理非零元素边界，指针j遍历数组寻找非零元素。当nums[j]非零时，与nums[i]交换并使i前进。该方法仅需一次遍历（O(n)时间复杂度），无额外空间消耗（O(1)空间复杂度），高效实现零元素后移。示例代码展示了双指针交换的核心逻辑，通过逐步扩大非零区间完成排序。
算法114. 二叉树展开为链表
hahaha_1112的博客
08-21 177
本文介绍了两种将二叉树展开为右单链表的算法，要求链表节点顺序与二叉树先序遍历一致。解法一采用后序遍历结合头插法，从右向左处理节点，通过清空左指针并反向连接构建链表。解法二使用分治策略，递归处理左右子树后拼接三部分：根节点、左子树链表和右子树链表，确保左子树尾指向右子树头，并更新指针关系。两种方法均满足题目要求的原地修改条件，适用于节点数在2000以内的二叉树。关键步骤包括正确处理指针重定向和清空左子节点。
【GNSS基带算法】Chapter.2 相干积分与非相干积分
齐花的博客
08-21 531
本文介绍了相干积分与非相干积分在GNSS信号处理中的应用。相干积分通过精确对齐信号相位实现线性信噪比提升，适合多普勒稳定的弱信号场景，但时间受限（10-20ms）。非相干积分忽略相位信息，通过幅度累积实现平方根级信噪比提升，适用于多普勒变化大或极弱信号环境（可达数百ms），但效率较低。二者共同服务于增强弱信号检测能力，其中相干积分侧重精确捕获，非相干积分侧重抗干扰鲁棒性，实际应用中常组合使用以平衡性能与复杂度。
Day12--滑动窗口与双指针--2762. 不间断子数组，LCP 68. 美观的花束，2743. 计算没有重复字符的子字符串数量
m0_60740070的博客
08-20 493
Day12--滑动窗口与双指针--2762. 不间断子数组，LCP 68. 美观的花束，2743. 计算没有重复字符的子字符串数量。 滑动窗口相当于在维护一个**队列**。右指针的移动可以视作**入队**，左指针的移动可以视作**出队**。 不定长滑动窗口主要分为三类：求最长子数组，求最短子数组，求子数组个数。 今天的题目类型是：求子数组个数——求最长（越短越合法） 今天要训练的题目类型是：【不定长滑动窗口】，题单来自@[灵艾山茶府]
算法 ----- 链式
shsbyshdbdhjsk的博客
08-20 298
解题思路一：我们可以设一个优先级队列，将各个链表头入列，在创建一个链表最小链入链表中。解题思路一：我们可以首先算出来有我们需要反转几次，然后我们就可以将他看作为几个逆置。解法思路二：归并我们可以通过归并将链表分为两个，在将两个链表进行排序。我们也可通过定义四个指针,改变她们的next值来交换结点。2、逆序后半段的指针（断开两端的指针）
leetcode1004 最大连续1的个数
2301_80296866的博客
08-21 201
定义变量countzero来记录窗口内0的数量，当countzero大于k时，窗口收缩，left移动到窗口内第一个0的后面一个位置，将这个弹出来的“翻转机会”让给right指向的数，直到right出界，即循环结束。的方法来解决这个问题。
河南萌新联赛2025第（六）场：郑州大学
2402_88147924的博客
08-21 778
解题涉及多个算法：L题使用二分查找满足条件的最大整数；E题通过字符串比较构造字典序最大数；I题模拟外卖订单处理；K题将问题转化为九进制处理；D题运用滑动窗口统计满足条件的区间；J题学习凸包算法并应用于凹多边形判断。整体展现了从基础到进阶的算法应用能力，也反映了备赛过程中的状态波动与成长。
c++ avl树构建
09-09
AVL树是一种自平衡的二叉搜索树，用于高效地插入、删除和查询数据。构建AVL树的基本步骤如下： 1. 首先，创建一个空的AVL树。 2. 从根节点开始，插入第一个元素作为根节点。 3. 对每个新插入的节点，更新它的平衡...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我要满血复活

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

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

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

打赏作者

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

抵扣说明：

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

余额充值