【C++数据结构】几种单链表的模类板实现及基本操作

最新推荐文章于 2020-01-18 09:51:40 发布
最新推荐文章于 2020-01-18 09:51:40 发布
阅读量1.2k 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 单循环链表 静态链表 单链表 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Irean_Lau/article/details/47907109
版权
本文探讨了C++中单链表的实现，包括循环单链表和静态链表。提供了相关代码，重点讲解了如何进行基本操作。
摘要由CSDN通过智能技术生成

提供代码如下：



循环单链表：

#pragma once

#include <iostream>
#include <assert.h>
using namespace std;

typedef enum { FALSE, TRUE }Status;

template <class _Ty>
class SCList;

template <class _Ty>
class Node
{
	friend class SCList<_Ty>;
public:
	Node() :data(_Ty()), next(NULL)
	{}
	Node(_Ty d, Node<_Ty>* n = NULL) :data(d), next(n)
	{}
private:
	_Ty data;
	Node<_Ty>* next;
};
template <class _Ty>
class SCList
{
public:
	typedef Node<_Ty>* _NodePtr;
public:
	SCList():Size(0)
	{
		First = Last = _BuyNode(0);
		Last->next = First;
	}
	~SCList()
	{
		FreeNode(First);
		//clear();
	}

public:
	Status IsEmpty() const
	{
		if (Size==0)
			return TRUE;
		return FALSE;
	}

	_NodePtr Insert(_NodePtr _P, const _Ty& x = _Ty())
	{
		_NodePtr s = _BuyNode(x, _P->next);
		if (s == NULL)
			return false;
		_P->next = s;

		if (0 == Size)
			Last = s;

		if (_P == First->next)
			Last = _P;

		Size++;
		return s;
	}

	Status push_back(const _Ty& v)
	{
		Last = Insert(Last, v);
		return TRUE;
	}

	Status push_front(const _Ty& v)
	{
		Insert(First, v);
		return TRUE;
	}

	void ShowList()
	{
		if (IsEmpty())
			return;
		_NodePtr p = First->next;
		while (p != First)
		{
			cout << p->data << "->";
			p = p->next;
		}
		cout << "null" << endl;
	}

	void erase(_NodePtr _P)
	{
		if (IsEmpty())
		{
			cout << "空，不能删除" << endl;
			return;
		}

		_NodePtr _Cur = _P->next;
		_P->next = _Cur->next;
		delete _Cur;
		_Cur = NULL;
		

		Size--;
	}

	Status pop_front()
	{
		if (Size == 1)
			Last = First;
		erase(First);
		return TRUE;
	}

	Status pop_back()
	{
		if (IsEmpty())
			return FALSE;
		_NodePtr _Cur = First;
		_NodePtr _P = _Cur->next;
		while (_P->next != First)
		{
			_Cur = _P;
			_P = _P->next;
		}
		Last = _Cur;
		erase(_Cur);
		return TRUE;
	}

	_NodePtr find(const _Ty& v) //返回前一个指针
	{
		_NodePtr pre = First;
		_NodePtr cur = pre->next;
		while (cur->next != First)
		{
			if (cur->data == v)
				return pre;
			pre = cur;
			cur = cur->next;
		}
		return NULL;
	}

	void delete_value(_Ty& _V)
	{
		_NodePtr p;
		while (p = find(_V),p)
		{
			if (p->next == Last)
			{
				Last = p;
				Last = First;
			}
			erase(p);
		}
	}

	void resver()
	{
		if (IsEmpty())
			return;
		_NodePtr p = First->next;
		_NodePtr q;
		Last = p;
		First->next = NULL;
		while (p != First)
		{
			q = p;
			p = p->next;
			q->next = First->next;
			First->next = q;
		}
		Last->next = First;
	}

	void Insert(_NodePtr _P, _NodePtr _S)
	{
		_S->next = _P->next;
		_P->next = _S;
		if (_P == Last)
			Last = _S;
		Last->next = First;
		Size++;
	}

	Status Insert_val(const _Ty& x)
	{
		_NodePtr _P = _BuyNode(x);
		Insert_val(_P);
		return TRUE;
	}

	void Insert_val(_NodePtr _Cur)
	{
		_NodePtr _P = First;
		while (_P->next != First  && _Cur->data > _P->next->data)
			_P = _P->next;
		Insert(_P, _Cur);
	}

	void sort()
	{
		if (Size == 0 || Size == 1)
			return;
		_NodePtr s = First->next;
		_NodePtr q = s->next;
		_NodePtr p = q->next;
		Last = s;
		Size = 1;
		s->next = NULL;
		while (q != First)
		{
			Insert_val(q);
			q = p;
			if (q != First)//error!
				p = p->next;
		}
		Last->next = First;
	}
	_Ty& findBypos(size_t pos)
	{
		if (pos > Size)
		{
			cout << "Array index error" << endl;
			return First->data;
		}
		_NodePtr p = First;
		while (p->next != First && pos)
		{
			p = p->next;
			pos--;
		}
		return p->data;
	}
	void clear()
	{
		while (!IsEmpty())
			pop_front();
	}
	_NodePtr prio(_NodePtr _P)const
	{
		if (_P->next != First)
			return find(_P->data);
		return NULL:
	}
	_NodePtr Next(_NodePtr _P)const
	{
		if (_P->next->next != First)
			return _P->next;
	}

protected:
	_NodePtr _BuyNode(const _Ty& x, _NodePtr _Narg = NULL)
	{
		_NodePtr s = new Node<_Ty>(x, _Narg);
		assert(s != NULL);
		return s;
	}

	void FreeNode(_NodePtr _P)
	{
		delete _P;
		_P = NULL;
	}
private:
	_NodePtr First;
	_NodePtr Last;
	size_t Size;
};

普通结构： 

#pragma once

#include <iostream>
using namespace std;
//无管理
template <class T>
class LinkList
{
protected:
	struct LinkNode;
	friend struct LinkNode;
	typedef T* _ptr;
	typedef LinkNode* _NodePtr;
	struct LinkNode
	{
		_NodePtr _Next;
		T value;
	};

private:
	size_t Size;
	_NodePtr Handle;

protected:
	_NodePtr _BuyNode(_NodePtr _Narg = NULL)
	{
		_NodePtr _S = new LinkNode;
		_S->_Next = _Narg != 0 ? _Narg :NULL;
		return (_S);
	}
	_NodePtr _FreeNode(_NodePtr _X)
	{
		delete _X;
		_X = NULL;
	}
public:
	LinkList():Size(0),Handle(_BuyNode())
	{}
	~LinkList()
	{
		delete Handle;
		Size = 0;
	}

	void Insert(_NodePtr _P, const T& x)
	{
		_NodePtr s = _BuyNode(_P->_Next);
		_P->_Next = s;
		s->value = x;
		Size++;
	}

	bool IsEmpty()
	{
		return Size == 0;
	}

	void push_back(const T& x)
	{
		_NodePtr p = Handle;
		while (p->_Next)
		{
			p = p->_Next;
		}
		Insert(p, x);
	}

	void push_front(const T& x)
	{
		Insert(Handle, x);
	}

	void ShowList()
	{
		if (IsEmpty())
			return;
		_NodePtr p = Handle->_Next;
		while (p)
		{
			cout << p->value << "->";
			p = p->_Next;
		}
		cout << "null" << endl;
	}

	_NodePtr find(const T& x)
	{

		_NodePtr pre = Handle;
		_NodePtr cur = pre->_Next;
		while (cur)
		{
			if (cur->value == x)
				return pre;
			pre = cur;
			cur = cur->_Next;
		}
		return NULL;
	}

	T& findBypos(size_t pos)
	{
		if (pos >= Size)
		{
			cout << "Array index error" << endl;
			return Handle->value;
		}
		_NodePtr p = Handle->_Next;
		while (p && pos)
		{
			p = p->_Next;
			pos--;
		}
		return p->value;
	}

	size_t Length()
	{
		return Size;
	}

	void deleteByPrev(_NodePtr _P)
	{
		if (IsEmpty())
		{
			cout << "空，不能删除" << endl;
			return;
		}

		_NodePtr _Cur = _P->_Next;
		_P->_Next = _Cur->_Next;
		delete _Cur;
		_Cur = NULL;
		Size--;
	}

	void delete_value(T& _V)
	{
		_NodePtr p;
		while (p = find(_V), p != NULL)
			deleteByPrev(p);
	}

	void pop_front()
	{
		deleteByPrev(Handle);
	}

	void pop_back()
	{
		if (IsEmpty())
			return;
		_NodePtr _Cur= Handle;
		_NodePtr _P = _Cur->_Next;
		while (_P->_Next)
		{
			_Cur = _P;
			_P = _P->_Next;
		}
		deleteByPrev(_Cur);
	}

	T getvalue(const _NodePtr _P)const
	{
		return _P->value;
	}

	void clear()
	{
		while (!IsEmpty())
		{
			deleteByPrev(Handle);
		}
	}

	void DestroyList()
	{
		clear();
		delete Handle;
		Handle = NULL;
	}

	void resver()
	{
		_NodePtr p, q;
		p = Handle->_Next;
		Handle->_Next = NULL;
		while (p != NULL)
		{
			q = p;
			p = p->_Next;
			q->_Next = Handle->_Next;
			Handle->_Next = q;
		}
	}

	void Sort()
	{
		if (!IsEmpty())
		{
			for (int i = Size - 1; i; i--)
			{
				for (int l = 0; l < i; l++)
				{
					if ((*this)[l]>(*this)[l + 1])
					{
						T tmp = (*this)[l];
						(*this)[l] = (*this)[l + 1];
						(*this)[l + 1] = tmp;
					}
				}
			}
		}
	}

	

	public:
		T& operator[](size_t index)
		{
			return findBypos(index);
		}

	
};

带管理节点： 

#pragma once
#include<iostream>
#include <assert.h>
using namespace std;
typedef enum { FALSE, TRUE }Status;

template <class _T>
class LinkList;
template <class _T>
class ListNode
{
	friend class LinkList<_T>;
public:
	ListNode() :data(_T()), next(NULL)
	{}
	ListNode(_T d, ListNode<_T>* n = NULL) :data(d), next(n)
	{}
private:
	_T data;
	ListNode<_T>* next;
};
template <class _T>
class LinkList
{
public:
	typedef ListNode<_T>* _NodePtr;
public:
	LinkList()
	{
		ListNode<_T>* s = _BuyNode(0);
		First = Last = s;
		Size = 0;
	}
	~LinkList()
	{}
protected:
	_NodePtr _BuyNode(const _T& x, _NodePtr _Narg = NULL)
	{
		_NodePtr s = new ListNode<_T>(x, _Narg);
		assert(s != NULL);
		return s;
	}
private:
	ListNode<_T>* First;
	ListNode<_T>* Last;
	size_t Size;
public:
	Status IsEmpty() const
	{
		if (Size == 0)
			return TRUE;
		return FALSE;
	}
	_NodePtr Insert(_NodePtr _P, const _T& x = _T())
	{
		_NodePtr s = _BuyNode(x, _P->next);
		if (s == NULL)
			return false;
		_P->next = s;

		if (0 == Size)
			Last = s;

		Size++;
		return s;
	}
	Status push_back(const _T& v)
	{
		Last = Insert(Last, v);
		return TRUE;
	}
	Status push_front(const _T& v)
	{
		Insert(First, v);
		return TRUE;
	}
	void ShowList()
	{
		if (IsEmpty())
			return;
		_NodePtr p = First->next;
		while (p)
		{
			cout << p->data << "->";
			p = p->next;
		}
		cout << "null" << endl;
	}
	void erase(_NodePtr _P)
	{
		if (IsEmpty())
		{
			cout << "空，不能删除" << endl;
			return;
		}

		_NodePtr _Cur = _P->next;
		_P->next = _Cur->next;
		delete _Cur;
		_Cur = NULL;
		Size--;
	}
	Status pop_front()
	{
		if (Size == 1)
			Last = First;
		erase(First);
		return TRUE;
	}
	Status pop_back()
	{
		if (IsEmpty())
			return FALSE;
		_NodePtr _Cur = First;
		_NodePtr _P = _Cur->next;
		while (_P->next)
		{
			_Cur = _P;
			_P = _P->next;
		}
		Last = _Cur;
		erase(_Cur);
		return TRUE;
	}
	_NodePtr find(const _T& v) //返回前一个指针
	{
		_NodePtr pre = First;
		_NodePtr cur = pre->next;
		while (cur)
		{
			if (cur->data == v)
				return pre;
			pre = cur;
			cur = cur->next;
		}
		return NULL;
	}
	void delete_value(_T& _V)
	{
		_NodePtr p;
		while (p = find(_V), p != NULL)
		{
			if (p->next == Last)
				Last = p;

			erase(p);
		}
	}
	void resver()
	{
		if (IsEmpty())
			return;
		_NodePtr p = First->next;
		_NodePtr q;
		Last=p;
		First->next = NULL;
		while (p != NULL)
		{
			q = p;
			p = p->next;
			q->next = First->next;
			First->next = q;
		}
		
	}
	void Insert(_NodePtr _P, _NodePtr _S)
	{
		_S->next = _P->next;
		_P->next = _S;
		if (_P == Last)
			Last = _S;
		Size++;
	}
	Status Insert_val(const _T& x)
	{
		_NodePtr _P = _BuyNode(x);
		Insert_val(_P);
		return TRUE;
	}
	void Insert_val(_NodePtr _Cur)
	{
		_NodePtr _P = First;
		while (_P->next  && _Cur->data > _P->next->data)
			_P = _P->next;
		Insert(_P, _Cur);
	}
	void sort()
	{
		if (Size == 0 || Size == 1)
			return;
		_NodePtr s = First->next;
		_NodePtr q = s->next;
		_NodePtr p = q->next;
		Last = s;
		Size = 1;
		s->next = NULL;
		while (q )
		{
			Insert_val(q);
			q = p;
			if(q)
				p = p->next;
		}
	}
	_T& findBypos(size_t pos)
	{
		if (pos > Size)
		{
			cout << "Array index error" << endl;
			return First->data;
		}
		_NodePtr p = First;
		while (p && pos)
		{
			p = p->next;
			pos--;
		}
		return p->data;
	}
	void clear()
	{
		while (!IsEmpty())
			pop_front();
	}
	_NodePtr prio(_NodePtr _P)const
	{
		if(_P != NULL)
			return find(_P->data);
		return NULL:
	}
	_NodePtr Next(_NodePtr _P)const
	{
		if (_P->next != NULL)
			return _P->next;
	}
};

C语言结构实现静态链表： 

#pragma once

#include <iostream>
using namespace std;

#define MAXSIZE 8
#define ElemType int

typedef struct Node
{
	ElemType data;
	int cur;
}SticNode;

typedef SticNode SticList[MAXSIZE];

void Init(SticList& list)
{
	list[0].cur = -1;
	list[0].data = 0;
	for (int i = 1; i < MAXSIZE-1; ++i)
	{
		list[i].cur = i + 1;
	}
	list[MAXSIZE - 1].cur = -1;
}

bool IsEmpty(SticList& list)
{
	if (list[0].cur == -1)
		return true;
	return false;
}

int MyFind(SticList& list, ElemType v)
{
	int j = list[0].cur;
	while (list[j].cur != -1 && list[j].data != v)
	{
		j = list[j].cur; //p=p->next
	}
	if (list[j].data == v)
		return j;
	cout << "查询无此数据" << endl;
	exit(-1);
}

int Malloc_SL(SticList& list)
{
	if(list[1].cur == -1)
		return -1;
	int index = list[1].cur;
	list[1].cur = list[index].cur;

	list[0].data += 1;
	return index;

}

void pop_back(SticList& list)
{
	int j = 0;
	while (list[(list[j].cur)].cur != -1)
	{
		j = list[j].cur; //p=p->next
	}
	list[(list[j].cur)].cur = list[1].cur;
	list[(list[j].cur)].data = -1;
	list[1].cur = list[j].cur;
	list[j].cur = -1;

	list[0].data -= 1;
}

void pop_front(SticList& list)
{
	int i = list[0].cur;
	list[0].cur = list[i].cur;
	list[i].cur = list[1].cur;
	list[1].cur = i;

	list[0].data -= 1;
}

void clear(SticList& list)
{
	while (!IsEmpty(list))
		pop_back(list);
}

void push_back(SticList& list, ElemType x)
{
	int i = Malloc_SL(list);
	if (i == -1)
		return;

	list[i].data = x;
	list[i].cur = -1;
	int j = 0;
	while (list[j].cur != -1)
	{
		j = list[j].cur; //p=p->next
	}
	list[j].cur = i;
}

void show(SticList& list)
{
	int i = list[0].cur;
	if (IsEmpty(list))
	{
		cout <<"null"<<endl <<"链表已空 >" << endl;
		return;
	}
	for (; list[i].cur != -1; i = list[i].cur)
	{
		cout << list[i].data<<"->";
	}
	cout <<list[i].data<<"->"<< "null" << endl;
}

void Delete(SticList& list,ElemType x )
{
	int index = MyFind(list, x);
	if (index == list[0].cur)
	{
		pop_front(list);
		return;
	}
	if (list[index].cur == -1)
	{
		pop_back(list);
		return;
	}
	int j = 0;
	while (list[j].cur != index)
	{
		j = list[j].cur; //p=p->next
	}
	list[j].cur = list[index].cur;
	list[index].cur = list[1].cur;
	list[1].cur = index;

	list[0].data -= 1;
}

void insert(SticList& list, ElemType x, ElemType v)	//x后插入v
{
	int index = MyFind(list, x);

	if (list[index].cur == -1)
	{
		push_back(list, v);
		return;
	}
	
	int tmp = list[1].cur;

	list[tmp].data = v;
	list[1].cur = list[tmp].cur;
	list[tmp].cur = list[index].cur;
	list[index].cur = tmp;

	list[0].data += 1;
}

int Length(SticList& list)
{
	return list[0].data;
}

静态链表，即通过一位数组描述链表结构，用游标模拟指针。






游标所指的位置即当前节点的后继。



Irean_Lau
关注
专栏目录
用c++类模板，实现的单链表基本操作
05-14
#include "stdafx.h" #include #include using namespace std; template struct LNode { T data; LNode *next; }; template class LinkList { public: LinkList(){L = 0;}//构造函数 ~LinkList();//析构函数，销毁单链表 void CreateList_L(int n);//构造单链表 bool IsEmpty() const{return L->next == 0;}//判断单链表是否为空 int GetElem_L(int i,T &e) const;//当第i个元素存在时，其值赋给e int ListInsert_L(int i,T &e);//在第i个位置插入元素e ……………………
引用计数派生类—_Ref_count、_Ref_count_del、_Ref_count_del_alloc(STL源码)
weixin_38850997的博客
01-24 1148
// TEMPLATE CLASS _Ref_count template<class _Ty> class _Ref_count : public _Ref_count_base { // handle reference counting for object without deleter public: _Ref_count(_Ty *_Px) : _Ref_cou...
类模板(class template)友元(friend) 的全部六种形式及代码
janeqi1987的专栏
07-14 1462
转自http://blog.csdn.net/caroline_wendy/article/details/16916441 类模板(class template)的友元(friend)和普通类的友元, 有很多区别, 主要原因是类模板包含模板参数(template parameter), 就会导致友元和类模板有很多匹配形式; 主要包含六种形式: 1. 类 - 友元(frie
enum与typedef enum的用法
H1017597898的专栏
07-09 2296
一，两者的用法        枚举类型定义用关键字enum标识，形式为：  enum 标识符  {       枚举数据表 }； 枚举数据(枚举常量)是一些特定的标识符，标识符代表什么含义，完全由程序员决定。数据枚举的顺序规定了枚举数据的序号，从0开始，依次递增。 enum status {      copy，      delete }； 枚举类型status仅有两个数
C++数据结构实现之Recursive.zip
最新发布
06-04
以下是几个可能包含在压缩包中的C++数据结构及其递归实现： 1. **链表**：链表是一种非连续的内存结构，节点之间通过指针连接。在C++中，可以使用递归遍历单链表，例如，实现逆序输出链表或者找到链表的中间节点。 ...
单向链表类模板（全）C++
01-22
在C++编程中，单向链表是一种基本的数据结构，用于存储动态集合。单向链表的特点是每个节点包含一个数据元素和一个指向下一个节点的指针，最后一个节点的指针为空。本压缩包文件提供了实现单向链表类模板的完整代码...
数据结构 实验2 单链表上的操作
09-28
单链表是数据结构中的一种基础且重要的结构，它在计算机科学中有着广泛的应用。本实验将深入探讨如何在单链表上进行各种操作。单链表由一系列节点组成，每个节点包含数据元素以及指向下一个节点的指针。在本实验中，...
集合的运算（C++单链表实现）.zip
04-10
在C++编程中，集合是数据结构的一种，用于存储不重复元素。本项目通过单链表实现集合的交、并、差运算，并支持从文件读取集合数据以及将运算结果保存回文件。以下是对这些知识点的详细说明： 1. **单链表**：单链表...
数据结构各种算法实现(C++模板).
02-05
下面我们将详细探讨标题和描述中提到的几种数据结构及其相关算法的C++实现。 1. **顺序表(Seqlist)** 顺序表是一种最基础的数据结构，它在内存中连续分配空间来存储元素。在C++中，可以使用数组来实现。`Seqlist.h...
数据结构---单链表（C++实现）
江城的博客
06-20 5157
单链表 线性表由于在内存上顺序存储，在插入和删除元素时效率很低。单链表通过链式存储，适用于插入和删除频繁，储存空间不定的情形。 单链表的一个存储结点（node）包括两个部分：数据域（data）和指针域（link） 数据域：存储线性表的一个数据元素 指针域：存储下一个节点的首地址 只能通过头指针(pHead)进行操作：链表的第一个结点的地址可以通过链表的头指针找到，但是其他结点的...
数据结构之单链表（C++实现）
complety的专栏
04-08 9056
很早前就想用C++来实现那些常用的数据结构。 今天就算是个开端把。还是那句话，看的再多不如自己动手写一遍。 按照自己的思路写。首先你得熟悉那种结构的特点，然后才能谈实现。  链表是一种很常用的数据结构。支持在任意地方对数据进行增删改查。 但是不支持随机访问。所以复杂度就有些高了。写的时候出了个问题。 最后把内存查看了几遍。并不是保存数据的结点出问题了。而是在链表转置 的时候用到的那个i
C++写的模板类链表基本操作
hadise的专栏
08-06 978
<br /><br />template <typename Type> <br />class SingleList <br />{ <br />public: <br />SingleList():head(new ListNode <Type>()){} <br />~SingleList(){ <br />MakeEmpty(); <br />delete head; <br />} <br />public: <br />void MakeEmpty();                 
数据结构之排序单链表（类模板实现）（C++）
碣石观海的博客
06-04 2048
1.实现了链表的顺序插入功能（可升序或降序），需实现元素结点的 int (* compare )(Elem *e1, Elem *e2);  比较接口；//文件名："SortedList.h" #pragma once #ifndef SORTEDLIST #define SORTEDLIST #include &lt;string&gt; using namespace std; /* . 排...
数据结构单链表的各种操作C++实现
huafeihuazyr的博客
06-26 1797
//该程序实现了线性表的链式存储结构之单链表和各项操作 #include<iostream> #include<tchar.h> using namespace std;//****线性表和一些基础的定义***** #define ElemType int /*表中数据元素类型*/ typedef struct Node{ ElemType data; Node* next
数据结构（C++）----单链表模板类
Gpwner的博客
11-27 983
所有的文件都在List.h文件下#ifndef LIST_H #define LIST_H #include<iostream> #include<stdlib.h>using namespace std;template<class Type> class List;template<class Type> class ListNode { public: friend class Lis
C++实现单链表基本操作
diviner_s的博客
01-18 5587
C++实现单链表基本操作 本博客按照上篇博客线性表单链表的基本操作而写出的完整代码，详情请看单链表基础概念 #include<iostream> using namespace std; //函数结果状态代码 #define OK 1 #define ERROR 0 typedef int Status; // Status 相当于 int typedef ...
C++实现：单链表操作综合实验
本资源是一份关于C++编程中单链表操作的实验文档，涉及的主要知识点包括单链表的数据结构实现、基本操作以及链表的高级操作。以下是详细内容： 1. **单链表基础**: - **节点定义**: 使用模板类`node`来定义单链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值