数据结构_线性表

最新推荐文章于 2022-04-16 13:18:15 发布
最新推荐文章于 2022-04-16 13:18:15 发布
阅读量248 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AMWICD/article/details/100938458
版权

这几周时间里，我学习到了线性表这一模块的知识。终于体会到了大一没学好指针的痛苦……线性表是十分重要的一块知识，不论如何都一定要学好！！
一、线性表的逻辑结构
1.线性表是0个或多个具有相同类型的数据元素的有限序列。
2.线性表中的数据元素具有相同类型，相邻元素具有前驱和后继关系。
二、线性表的顺序存储结构及实现
1.顺序表： 顺序存储是指用一组地址连续的存储单元依次存储线性表的各个元素。通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。
在这里插入图片描述
设顺序表的每个元素占用 c 个存储单元，则第 i 个元素的存储地址为：　LOC ( a i ) = LOC ( a1 ) ＋ ( i - 1 ) × c
2.顺序表的实现：

template <class T>
class SeqList{ 
　private: 
　　T data[100]; 					 	// 存放数据元素的数组 
　　int length; 						// 线性表的长度 
　public:
　　SeqList ( ) ;						// 无参构造函数   
　　SeqList ( T [ ], int n ) ; 			// 有参构造函数 
　　~SeqList( ) { }						 // 析构函数为空 
　　int Length ( ) {return length;} 	// 求线性表的长度 
　　T Get ( int i ); 					// 按位查找，取线性表的第 i 个元素 
　　int Locate ( T x ) ; 				// 按值查找，求线性表中值为 x 的元素序号 
　　void Insert ( int i, T x ) ;		 // 在线性表中第 i 个位置插入值为 x 的元素 
　　T Delete ( int i ) ;				 // 删除线性表的第 i 个元素 
　　void PrintList ( ) ; 				// 遍历线性表，按序号依次输出各元素 
};

1).构造函数

  • 无参构造函数（构造一个空的顺序表）
SeqList ( ) {length=0;}
  • 有参构造函数
SeqList ( T a[],int n ) ; // 有参构造函数

将长度为n的一维数组中的元素依次传入到data中。实现过程：

template <class T> 
SeqList<T>:: SeqList(T a[],int n)
{
  if (n>100) throw "参数非法";
  for (int i=0; i<n; i++)  
    data[i]=a[i];
  length=n;
}

2).插入操作
在表的第i (1≤i≤n+1)个位置，插入一个新元素e。
在这里插入图片描述

template <class T> 
void SeqList<T>::Insert(int i,T x){ 
    int j;
    if (length>=100) throw "上溢"; 			   //如果顺序表已满，抛出上溢异常
    if (i<1 || i>length+1) throw "位置";		//如果元素插入位置不存在，抛出位置异常
    for (j=length; j>=i; j--)
          data[j]=data[j-1]; 					//从后往前，将最后一个元素至第i个元素（i为插入位置）向后移动一个位置
    data[i-1]=x;								//将元素x插入到i位置
    length++;									//将顺序表的长度增加1
}

3).删除操作

template <class T>
T SeqList<T>::Delete(int i){ 
   int j; 
   T x;
  if (length==0) throw "下溢";					//如果顺序表已空，抛出下溢异常
  if (i<1 || i>length) throw "位置";			//如果元素删除位置不存在，抛出位置异常
  x=data[i-1];									//取出被删除的元素
  for (j=i; j<length; j++)
    data[j-1]=data[j]; 							//前移，将下标为i，i+1…n-1的元素依次移到i-1,i,…n-2的位置
  length--;
  return x;										//返回被删除的元素
}

4).查找操作

  • 按位置查找
template <class T> 
T SeqList<T>::Get(int i)
{
    if (i<1 && i>length) throw "查找位置非法";
    else return data[i-1];
}
  • 按值查找
template <class T>
int SeqList<T>::Locate(T x){     
	  for (int i=0; i<length; i++)
	   		if (data[i]==x) 
	    		 return i+1 ; 	 //下标为i的元素等于x，返回其序号i+1
	  return 0; 				 //退出循环，说明查找失败
}

三、线性表的链式存储结构及实现
1.链式存储结构的实现：单链表，双向链表，循环链表等
2.变量的三要素：
1).名字，内存地址，值
2).变量的左值，右值
左值指变量的内存地址
右值：值
在赋值表达式中，赋值号左边需要左值，右边需要右值；如a=a+100
3).指针变量
指针变量的右值本身又是一个左值。
在这里插入图片描述
4.在C++中，可以用结构类型来描述单链表的结点 ，由于结点的元素类型不确定，所以采用C++的模板机制。

template <typename T>
struct Node 
{ 
　　T data; 
　　Node<T> *next;     	 //此处<T>也可以省略
};

5.单链表的实现

template <class T>
class LinkList {  
　　	Node<T>  *first; // 单链表的头指针  , <T>可以省略。实例化
　public: 
　　LinkList ( ) {first=new Node<T>; first -> next= NULL ;}
　    LinkList ( T a[], int n ) ; 
　　~LinkList ( ) ; 
　　int Length ( ) ;
　　T Get ( int i ) ; 
　　int Locate ( T x ) ;
　　void Insert ( int i, T x ) ;
　　T Delete ( int i ) ; 
　　void PrintList ( ) ; 
};

1).单链表的构造

  • 头插法
    每个插入的结点都插在头结点之后，原来的首元结点之前。
    头结点不是首元结点！
    尾结点时刻不变。
template <class T>  
LinkList<T>:: LinkList(T a[], int n) {
	   first=new Node<T>;   //生成头结点
   first->next=NULL;
   Node<T> *s;
   for (int i=0; i<n; i++){ 
          s=new Node<T>; 		//①
	      s->data=a[i]; 		 //②赋值
          s->next=first->next;	//③先修改尾端
          first->next=s;		//④再修改近端
	}
}

在这里插入图片描述

  • 尾插法
    每个新结点都以尾结点的身份插入，尾结点时刻变化。
    插入之前要确认尾结点。从头找太慢，所以可以增加尾指针，指示尾结点位置。
    first头指针只能在开头！不能动。
    没有必要在刚开始的时候就把尾指针的指针域置空，因为在停止插入前，尾结点时刻变化。
template <class T>  
LinkList<T>:: LinkList(T a[], int n) {//若要通过构造函数重载两次分别写头插和尾插，此处可以(T a[], int n,int k)来区分头插与尾插。 
	first=new Node<T>;  	 //生成头结点 ，一定要写在 Node<T> *r=first,*s=NULL;前面！！！
    Node<T> *r=first,*s=NULL;     		 //r是尾指针，记录没有被插之前的地址;因为是尾插，所以s->next为空   
    for (int i=0; i<n; i++)	{ 
        s=new Node<T>; 		//①定义之后要申请内存
        s->data=a[i]; 		 //②为每个数组元素建立一个结点
        r->next=s; r=s;      //③插入到终端结点之后。r的下一个数是s。此处=s，不是s->next，因为s是尾插。把s赋给r之后，r就在s的位置了（修改尾指针）
	}
    r->next=NULL;  			 //④单链表建立完毕，将终端结点的指针域置空
 }

在这里插入图片描述
2).不带头结点的单链表的构造
考虑第一个节点与其他结点的插入是否相同。

  • 头插法 每个结点插入过程相同
{
    first=NULL;				//把first赋空
    for(int i=0;i<n;i++) { 
         s=new Node<T>;
         s->data=a[i];
         s->next=first;
         first=s;   
    }
}

尾插法
插入的第一个结点为头、尾结点且为首元结点。

    Node<T> *r;
    head=NULL;
    if(n<=0) return;
    s=new Node<T>;
    s->data=a[0];
    s->next=head;
    head=s;   
    r=head;
	for(int i=1;i<n;i++) { 
         s=new Node<T>;
         s->data=a[i];
         r->next=s;
         r=s;   
    }
  • 带头结点和不带头结点的单链表
    在这里插入图片描述
    3).单链表的遍历
    从首元结点出发开始遍历，首元结点地址：p=first->next。*p是结构体，p是Node类型，若想cout<<*p则要重载运算符，但是cout<<(*p).data对。
template <class T>  
LinkList<T>:: PrintList()
{
    Node<T> *p;
	p=first->next;          //工作指针p初始化
     while(p)					//p不为空时
	{
		cout<<p->data;
         p=p->next;			//后移，不能写作p++
	}
 }

4).单链表中按位置查找
顺序存储支持随机访问，而单链表不支持。因为内存不一定连续，所以只能从头结点开始顺序查找。

template <class T>
T LinkList<T>::Get(int i) {   
	  Node<T> *p; int j;
	  p=first->next;  j=1;   //或p=first;  j=0;工作指针初始化，计数器初始化
	  while (p && j<i) {
    		p=p->next;       //工作指针p后移
			j++;
  	 }
	  if (!p) throw "位置";	 //若p为空，则第j个元素不存在，抛出位置异常
	  else return p->data;
}

4).单链表插入

template <class T>  
void LinkList<T>::Insert(int i, T x){  
   Node<T> *p; int j; 
   p=first ; j=0;    			//工作指针p初始化，计数器初始化
   while (p && j<i-1)   {		//查找第i-1个节点，并使工作指针p指向该节点
     p=p->next;  				 //工作指针p后移
     j++;
   }
   if (!p) throw "位置";		//若查找不成功（P==NULL），说明位置错误，抛出位置异常
    else { 
	  Node<T> *s;
      s=new Node<T>; 
	  s->data=x;			  //向内存申请一个结点s，其数据域为x（生成一个元素值为x的新节点s）
      s->next=p->next;     	  //将结点s插入到结点p之后
      p->next=s;	
	}
 }
  • 不带头结点的单链表中插入结点
Insert(int i, T x){  
   Node<T> *p; int j;
   if（i<=0） throw “位置非法”；
   if （i==1 ）{ s=new Node<T>;s->next=head;head=s;return}
   p=first ; j=1;   	 //工作指针p初始化
   while (p && j<i-1){
     p=p->next; 		  //工作指针p后移
     j++;
   }
   if (!p) throw "位置";
    else { 
	  Node<T> *s;
      s=new Node<T>; 
	  s->data=x;  			//向内存申请一个结点s，其数据域为x
      s->next=p->next;       //将结点s插入到结点p之后
      p->next=s;	
	}
 }

5).单链表中结点的删除（删除编号是i的结点）
在这里插入图片描述

template <class T>  
T LinkList<T>::Delete(int i){ 
  Node<T> *p; int j;
  p=first ; j=0;  					//工作指针p初始化，累加器j清零（注意工作指针p要指向头结点）
  while (p && j<i-1) {				 //查找第i-1个结点，并使p指向该节点
    p=p->next; 
    j++;
  }
  if (!p || !p->next) throw "位置";  //结点p不存在或结点p的后继结点不存在，抛出异常
    else {
  	     Node<T> *q; T x;
          q=p->next; x=q->data; 	 //暂存被删结点和被删元素值
          p->next=q->next;			  //摘链，将结点p的后继结点从链表上摘下
          delete q; 						//释放被删结点
          return x;							//返回被删元素
	}
}

在这里插入图片描述
6).析构函数

template <class T>
LinkList<T>:: ~LinkList()
{					
   Node<T> *q;			//first：要处理的第一个结点的地址；q：first的后继
   while (first)
   {
       q=first->next;
       delete first;
       first=q;
    }
}

四、顺序表和单链表的比较
1.时间性能比较
若线性表的操作主要是进行查找，很少做插入和删除时，宜采用顺序表做存储结构；
对频繁进行插入和删除的线性表，宜采用链表做存储结构。
2.空间性能比较
当线性表的长度变化不大，易于事先确定其大小时，为了节约存储空间，宜采用顺序表。
五、线性表的其他存储方法
1.循环列表
将单链表或者双链表的头尾结点链接起来。特点：
①首尾相接的链表
②可以从任一节点出发，访问链表中的所有结点。
③判断循链表中尾结点的特点：q->next==first
1).循环链表的定义

template <class T>
struct Node
{
   T data;
   Node<T> *next;
};
template <class T>
class CycleLinkList{
  public:
    CycleLinkList( ); 
    CycleLinkList(T a[], int n);  
    CycleLinkList(T a[], int n,int i);
    ~CycleLinkList();           
    int Length();        
    T Get(int i);          
     void Insert(int i, T x);
    T Delete(int i);        
    void PrintList();    
 private:
   Node<T> *first;  
};

带头结点的循环链表：
2).空表的构造

template <class T>
CycleLinkList<T>:: CycleLinkList( )
{
         first=new Node<T>; first->next=first;
}

尾插法构造循环链表

template <class T>  
CycleLinkList<T>:: CycleLinkList(T a[ ], int n) {
    first=new Node<T>;   //生成头结点
	Node<T> *r,*s;
     r=first;          //尾指针初始化
    for (int i=0; i<n; i++)	{ 
        s=new Node<T>; 
        s->data=a[i];  
        r->next=s; 
         r=s;     
	}
    r->next=first;    //单链表建立完毕，将终端结点的指针域指向头结点
 }

头插法构造循环链表

template <class T>  
CycleLinkList<T>:: CycleLinkList(T a[ ], int n,int k)
 {
    first=new Node<T>;   //生成头结点
	first->next=first;
	Node<T> *s;
	for (int i=1; i<n; i++)
	{ 
      s=new Node<T>; 
	  s->data=a[i];		  //为每个数组元素建立一个结点
      s->next=first->next;//先修改s的指针域（s的后继为first）
	  first->next=s;		//（first的后继为s）
	}
}

将非循环的单链表改造成循环的单链表

p=first;
while(p->next)
{ 
       p=p->next;  
 }
p->next=first

3).非空表的构造
4).循环链表的遍历
不能轻易修改头指针，所以设置工作结点p，p->first指向头结点。首元结点是头结点的后继，p=first->next。而且只有p非空才可以count<<p ->data（但在循环列表中，p不为空）。后移：p=p->next。
5). 按位置查找结点
6).循环链表的析构

2.双向列表（双链表）
给单链表增加一个指向前驱的指针。
first：头指针
last：尾指针
每一个结点都是new来的，头结点的rlink和llink都为空。first（是DNode类型变量，自己始终占四个字节内存）有两个指针域，修改所指向的内存。
在这里插入图片描述
在这里插入图片描述
设指针p指向双链表中某一结点，则p->llink->rlink = p = p->rlink->llink
1).双向链表p之后插入结点（p存在后继结点）
把一个结点插入到两条单链表，插入顺序不唯一，但一定要正确插入到两条链里面。
在这里插入图片描述

q->rlink=p->rlink;	//p原来的下一个结点变为现在q的下一个结点（q的rlink要记录的地址是p的rlin）
q->llink=p;			//q前一个结点是p
p->rlink=q;			//p的下一个结点是q
q->rlink->llink=q; 	//b的前一个结点是q

处理原则：先处理每个方向的远端指针，再处理近端指针
在这里插入图片描述

q->rlink=p->rlink;	//p原来的下一个结点变为现在q的下一个结点
p->rlink=q;			//p的下一个结点是q
q->llink=p;			//q的前一个结点是p
q->rlink->llink=q	//b的前一个结点是q

处理原则：先在正向链表上插入，再在逆向链表上插入

  • 插入时应考虑的特殊情况
    若在空表的表尾插入一个结点：
    在这里插入图片描述
q->rlink=p->rlink;
p->rlink=q;
q->llink=p;
if(q->rlink)
	q->rlink->llink=q;

头插：Append(T data)

template <class T>
void DoubleLink<T>::Append(T data){
	      Node<T> *s;
     	s=new Node<T>;
	       s->data=data;
		s->rlink=head->rlink;
		head->rlink=s;
		s->llink=head;
		if (s->rlink)
			s->rlink->llink=s;
		return;
}

2).双向链表的删除操作
要同时修改两个指针，同时在两个链表中删除（可先正向删，再反向删）。但若是c不存在，则修改一个（前驱）即可。
在这里插入图片描述

p->llink->rlink=p->rlink;
p->rlink->llink=p->llink;
delete(p);
  • 删除造作应考虑的特殊情况
    在这里插入图片描述
p->llink->rlink=p->rlink;
 if(p->rlink)
        p->rlink->llink=p->rlink;
delete(p);

3).双向链表的实现

template <class T>
class DoubleLink {
private:
	Node<T> *head;
public:
	DoubleLink() ；
	~DoubleLink();
	void Append(T data);
	void Display();
	void Insert(int locate , T data);
	T Get(int locate);
	T Delete(int locate);
};

4).双向链表的构造

template <class T> 
DoubleLink <T>::DoubleLink(){
		head=new Node<T>;
		head->rlink=NULL;
		head->llink=NULL;
	}

5).析构

template <class T>
DoubleLink<T>::~DoubleLink(){
	Node<T>  *p,*q;
	p=head;
	while(p)
	{
		q=p->rlink;
		delete p;
		p=q;
		
	}
}

6).遍历

template <class T>
void DoubleLink<T>::Display(){
	Node <T> *p;
	p=head->rlink;
	while(p)	{
		cout<<p->data<<"   ";
		p=p->rlink;
	}
	cout<<endl;
	return;
}

练习：
远端：距离表尾远
近端：距离表尾近
注意正向链和反向链的表尾不同。
在这里插入图片描述
A.①若一开始就修改p->rlink（近端），则p原来的后继就找不到了。所以要先修改远端再修改近端。
B.①修改逆向链近端 √
②若此时修改正向链近端，p原来的后继就找不到了
C.①修改逆向链远端 √
②修改正向链远端 √
③修改正向链近端 √
④修改逆向链近端 X，表示错了
D.√
3.静态列表
六、线性表的应用举例

小金金金金鱼
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的创建，增加，插入，删除（代码）_数据结构学习记录（一）
我只知道的事
04-27 3538
//线性表的存储结构 #include<stdio.h> #include<iostream> #include<conio.h> #include<stdlib.h> using namespace std; #define LISTSIZE 100 //假设表容量100 typedef int DataType; typedef struct ...
线性表的增加和删除
gh6267的博客
09-29 635
#include <stdio.h> #include <stdlib.h>#define LIST_INIT_SIZE 100 #define LISTINSERT 10typedef struct{ int *elem; int length;//记录链表当前长度 int list_size;//记录链表的总容量 }SqList;SqList init_list(SqLi
大话数据结构(三)线性表相关概念——(顺序线性表插入和删除等)
苞米地里捉小鸡的博客
09-23 333
话不多说，我们这一部分的主要重点是线性表的相关概念的总结和回顾。 线性表主要有两种存储结构，一是顺序存储结构，二是链式存储结构。当然这两种结构各有各的优点。接下来我们就慢慢开始回顾。首先我们开始顺序存储结构的介绍。 线性表的顺序存储结构 顺序存储结构，指的是用一段连续的地址的存储单元一次存储数据元素。直白点说就是在一个班级里边，每个学生都有自己的学号，这个学号一般是从****0001开始，按...
数据结构与算法C++描述（1）---线性表的基本操作
Hello~~~
09-15 3144
本文将利用公式化描述的方法，借助于C++语言，建立线性表，实现线性表的创建、删除、元素插入、线性表的合并与拆分等操作。 文中所有代码皆上传至我的码云1、 线性表的定义在参考文献[1]中，对线性表有如下定义：线性表（linear list）是这样的数据对象，其实例形式为：(e1,e2,…,en)，其中n是有穷自然数。ei是表中的元素，n是表的长度。元素可以被视为原子，因为它们本身的结构与线性表的结构
线性表的增加C语言实现,数据结构（严蔚敏）C语言实现---线性表的顺序存储
weixin_27064205的博客
05-23 267
总觉得写的代码差点什么，所以回过头开始看数据结构，真正去实现一下。这次看的是线性表的顺序存储，代码如下：1、为了增加代码可读性，用了一些宏定义，文件名称为BaseDefine.h，内容如下：#ifndef BASE_DEFINE_H#define BASE_DEFINE_H#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define...
数据结构作业_线性表
落末的博客
05-03 516
数据结构第一次作业：线性表。 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 1024 typedef int elemtype; typedef struct sequlist { elemtype data[MAXSIZE]; int last; } SequenList; /...
数据结构_线性表的c语言实现.txt
10-19
用c/c++实现数据结构中的线性表结构
计算机软件基础：11第四章数据结构_线性表
05-08
在本章中，我们主要探讨的是线性表这一基本的数据结构。线性表是由n（n>=0）个相同类型元素构成的有限序列，这些元素在逻辑上是连续的，可以通过位置关系来表示它们之间的顺序。 首先，我们需要理解数据结构的基本...
数据结构_线性表总结
04-23
线性表 栈 队列 串
线性表的插入，生成新线性表
04-14
粗如数字，位置等新线性表，欢迎大家下载，不足之处多多指教
基于线性表的图书管理系统 源代码 顺序表&链表
05-31
基于线性表的图书管理系统，《数据结构（C语言版 第2版）》严蔚敏 实验一
数据结构_线性表的顺序表示与实现
09-06
线性表是数据结构中最基础且重要的概念之一，它是由n（n≥0）个相同类型元素构成的有限序列。在线性表中，每个元素都有一个前驱元素和一个后继元素，除了第一个元素没有前驱，最后一个元素没有后继。在实际应用中，...
llist2_线性表/数据结构_
10-02
线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。
线性表的顺序表示的增加和删除
wyyy2088511的博客
08-27 403
线性表包括顺序结构和链式结构，这里介绍的是顺序结构，为了方便就用数组表示，其操作包括增，删，改，查， 其中改和查用数组的下标可以很方便的操作，增加和删除需要一些代码实现。 其中增加的是在一个线性表插入一个元素，这个元素必须在1~N+1之间 其核心思想是先判断要插入的数据是否在1~N+1之间，然后把i~N之间的数据向后移动一位， 最后插入，长度增加1。 核心代码如下： for(int j=N+1; j>=i; j--) arry[j] = arry[j-1]...
【数据结构与算法】02：线性表
https://blog.csdn.net/m0_74834215
04-16 1493
第一章：线性表 一、线性表 1.线性表定义 注意：同一线性表中的元素必定具有相同的特性，数据元素之间的关系是线性关系。 2.线性表逻辑特征： 3.线性表类型定义 二、线性表的顺序表示与实现 1.顺序表定义： 注意：线性表顺序存储结构必须占用一片连续的存储空间，知道某个元素的存储位置就可以计算其他元素的存储位置。 2.顺序表存储表示： c动态内存分配： cpp动态存储分配： 3.顺序表操作实现： （1）基本操作： 基本操作 函数 初始化 InitList
数据结构——第二章 线性表
sunyanxian的博客
12-14 2279
目录线性表的定义和特点案例引入一元多项式的运算图书管理系统总结线性表的类型定义线性表的基本操作线性表的初始化线性表的销毁和重置判断线性表是否为空测量线性表的长度获取线性表中元素查找定位线性表中元素求线性表中元素前驱求线性表中元素前驱和后继在线性表中插入和删除元素遍历线性表的元素线性表的顺序表示和实现顺序存储结构顺序表中元素存储位置的计算顺序表的顺序存储表示一元多项式的顺序存储结构类型定义图书表的顺序存储结构类型定义顺序表基本操作的实现线性表的基本操作补充：操作算法中用到的预定义常量和类型※顺序表的初始化销毁
【数据结构】使用多态实现一个线性表
dai_wen的博客
08-08 356
/* 使用多态实现一个线性表（队列，串，堆栈） 要求： 具有线性表的基本操作：插入，删除，测长等。 思路： 队列，堆栈都以实现push，pop，测长等操作。 现在要求用多态实现，就要建立一个线性表的共性模板，来实现以上功能。 */ #include&lt;iostream&gt; using namespace std; template&lt;typename...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值