线性表【数据结构】_Java

最新推荐文章于 2023-06-30 00:14:45 发布
最新推荐文章于 2023-06-30 00:14:45 发布
阅读量293 收藏 5
点赞数
分类专栏： 数据结构个人笔记 文章标签： 数据结构 java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/demiphea/article/details/125165529
版权

线性表

一、关系图

在这里插入图片描述

二、线性表的定义与实现

（1）.顺序表

在这里插入图片描述

顺序表由长度定义成Maxsize的数组来实现

1.【查找】

时间复杂度： O ( n ) O(n) O(n)

证：

顺序表的平均查找次数为：
1 + 2 + 3 + ⋅ ⋅ ⋅ + n n = n + 1 2 \frac{1+2+3+···+n}{n} = \frac{n+1}{2} n1+2+3+⋅⋅⋅+n​=2n+1​
∴时间复杂度： O ( n ) O(n) O(n) 略去常数项以及常数系数(下同)

P.S【ASL:平均查找长度】:
A S L = ∑ i = 1 n p i c i ASL = \sum_{i=1}^{n}p_ic_i ASL=i=1∑n​pi​ci​
其中 n n n为要查找的元素集的个数， p i p_i pi​为查找到元素 a i a_i ai​的概率， c i c_i ci​为查找到元素时需要比较的次数。

顺序表查找操作的ASL(显而易见 p i = 1 n p_i = \frac{1}{n} pi​=n1​ )：
A S L = ∑ i = 1 n p i c i = p i ∑ i = 1 n c i = 1 n ∑ i = 1 n c i = 1 n × ( 1 + 2 + ⋅ ⋅ ⋅ + n ) = n + 1 2 ASL = \sum_{i=1}^{n}p_ic_i = p_i\sum_{i=1}^{n}c_i = \frac{1}{n}\sum_{i=1}^{n}c_i = \frac{1}{n}\times(1+2+···+n) = \frac{n+1}{2} ASL=i=1∑n​pi​ci​=pi​i=1∑n​ci​=n1​i=1∑n​ci​=n1​×(1+2+⋅⋅⋅+n)=2n+1​
即平均查找次数 = 平均查找长度

2.【插入】

时间复杂度： O ( n ) O(n) O(n)

证：

顺序表插入时平均移动次数为：
n + ( n − 1 ) + ( n − 2 ) + ⋅ ⋅ ⋅ + 1 + 0 n + 1 = n 2 \frac{n+(n-1)+(n-2)+···+1+0}{n+1} = \frac{n}{2} n+1n+(n−1)+(n−2)+⋅⋅⋅+1+0​=2n​
∴时间复杂度： O ( n ) O(n) O(n)

3.【删除】

时间复杂度： O ( n ) O(n) O(n)

证：

顺序表插入时平均删除次数为：
( n − 1 ) + ( n − 2 ) + ⋅ ⋅ ⋅ + 1 + 0 n = n − 1 2 \frac{(n-1)+(n-2)+···+1+0}{n} = \frac{n-1}{2} n(n−1)+(n−2)+⋅⋅⋅+1+0​=2n−1​
∴时间复杂度： O ( n ) O(n) O(n)

（2）.链表

一、单链表
在这里插入图片描述

（带头节点:头结点不存放元素）

在这里插入图片描述

（不带头结点）

【实现代码】：

带头结点 
import java.util.*;

class Link {
    int data;
    Link next;
}
public class Main {
    public static void InitList(Link List_Head) {
        List_Head.next = null;
    }

    public static void InsertList(Link List_Head, int data) {
        Link ptr = List_Head;
        while (ptr.next != null) {
            ptr = ptr.next;
        }
        //Insert after ptr;
        Link List_new = new Link();
        List_new.data = data;
        List_new.next = null;
        ptr.next = List_new;
    }

    public static void TraverseList(Link List_Head) {
        Link ptr = List_Head;
        while (ptr.next != null) {
            System.out.println(ptr.next.data);
            ptr = ptr.next;
        }
    }

    public static void main(String[] argv) {
        Scanner cin = new Scanner(System.in);
        Link List_Head = new Link();
        InitList(List_Head);
        int n = cin.nextInt();
        for (int i = 0; i < n; i++) {
            int x = cin.nextInt();
            InsertList(List_Head, x);
        }
        TraverseList(List_Head);
    }
}
不带头结点 
import java.util.*;

class Link {
    int data;
    Link next;
    static Link List_Head;
}
public class Main {

    public static void InitList() {
        Link.List_Head = null;
    }
    public static void InsertList(int data) {
        if (Link.List_Head == null) {
            Link.List_Head = new Link();
            Link.List_Head.data = data;
            Link.List_Head.next = null;
        }
        else {
            Link ptr = Link.List_Head;
            while (ptr.next != null) {
                ptr = ptr.next;
            }
            //Insert after ptr;
            Link List_new = new Link();
            List_new.data = data;
            List_new.next = null;

            ptr.next = List_new;
        }
    }

    public static void TraverseList() {
        Link ptr = Link.List_Head;
        while (ptr != null) {
            System.out.println(ptr.data);
            ptr = ptr.next;
        }
    }

    public static void main(String[] argv) {
        Scanner cin = new Scanner(System.in);
        InitList();
        int n = cin.nextInt();
        for (int i = 0; i < n; i++) {
            int x = cin.nextInt();
            InsertList(x);
        }
        TraverseList();
    }
}
单链表操作时间复杂度均为:O(n)

二、循环链表
在这里插入图片描述

			tail.next = null -----------> tail.next = head

三、双向链表
在这里插入图片描述

class Link {
    Link prior;
    int data;
    Link next;
}

【C语言实现常用模板（带头结点的单链表）】：

#include<stdio.h>
#include<stdlib.h>

typedef struct Link {
	int data;
	struct Link* next;
}List;

void InitList(List* List_Head) {
	List_Head->next = NULL;
}

void InsertList(List* List_Head, int data) {
	List* ptr = List_Head;
	while (ptr->next != NULL) {
		ptr = ptr->next;
	}
	//Insert after ptr;
	List* List_new = (List*)malloc(sizeof(List));
	List_new->data = data;
	List_new->next = NULL;
	ptr->next = List_new;
}

void TraverseList(List* List_Head) {
	List* ptr = List_Head;
	while (ptr->next != NULL) {
		printf("%d\n", (ptr->next)->data);
		ptr = ptr->next;
	}
}

int main() {
	
	List List_Head;
	InitList(&List_Head);

	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		int x;
		scanf("%d", &x);
		InsertList(&List_Head, x);
	}
	TraverseList(&List_Head);
	return 0;
}

应用：一元多项式的运算、约瑟夫环问题

三、应用

1.【两个一元多项式求和】

A n ( x ) = a 0 + a 1 x + a 2 x 2 + ⋅ ⋅ ⋅ + a n x n A_n(x)=a_0+a_1x+a_2x^2+···+a_nx^n An​(x)=a0​+a1​x+a2​x2+⋅⋅⋅+an​xn

B m ( x ) = b 0 + b 1 x + b 2 x 2 + ⋅ ⋅ ⋅ + b m x m B_m(x)=b_0+b_1x+b_2x^2+···+b_mx^m Bm​(x)=b0​+b1​x+b2​x2+⋅⋅⋅+bm​xm

求：
C n ( x ) = A n ( x ) + B m ( x ) = ( a 0 + b 0 ) + ( a 1 + b 1 ) x + ⋅ ⋅ ⋅ + ( a n + b n ) x n C_n(x)=A_n(x)+B_m(x)=(a_0+b_0)+(a_1+b_1)x+···+(a_n+b_n)x^n Cn​(x)=An​(x)+Bm​(x)=(a0​+b0​)+(a1​+b1​)x+⋅⋅⋅+(an​+bn​)xn
【实现代码】：

class Link {
    double coef;	//系数
    int exp;	    //指数
    Link next;
}

完整代码（带头结点单链表实现）

public static void ListSum(Link List_1, Link List_2){
        Link ptr_1 = List_1, ptr_2 = List_2;    //ptr_1为主链表，合并到ptr_1链表
        while (ptr_1.next != null && ptr_2.next != null) {
            //0指数结点删去
            if ((ptr_1.next).coef == 0) ptr_1.next = (ptr_1.next).next;
            if ((ptr_2.next).coef == 0) ptr_2 = ptr_2.next;
            if (ptr_1.next == null || ptr_2.next == null) break;

            //按指数从小到大排列
            if ((ptr_1.next).exp < (ptr_2.next).exp) {
                // |ptr_1|->|ptr_1.next|->|(ptr_1.next).next|
                //               |------> ptr_1.next < ptr_2.next ?     ptr_1 = ptr_1.next;
                // |ptr_2|->|ptr_2.next|
                ptr_1 = ptr_1.next;
            }
            else if ((ptr_1.next).exp > (ptr_2.next).exp) {
                // |ptr_1|->|ptr_1.next|                              |ptr_1|->|ptr_2.next|(ptr)->|ptr_1.next|
                //        ↑-insert-↓                              =>
                // |ptr_2|->|ptr_2.next|(ptr)->|(ptr_2.next).next|    |ptr_2|->|(ptr_2.next).next|
                Link ptr = ptr_2.next;
                ptr_2.next = ptr.next;  //Delete ptr_2.next in List_2

                //Insert ptr(ptr_2.next) between ptr_1 and ptr_1.next
                ptr.next = ptr_1.next;
                ptr_1.next = ptr;
            }
            else {
                // |ptr_1|->|ptr_1.next|->|(ptr_1.next).next|
                //              |||
                // |ptr_2|->|ptr_2.next|->|(ptr_1.next).next|
                (ptr_1.next).coef += (ptr_2.next).coef;
                if ((ptr_1.next).coef == 0) ptr_1.next = (ptr_1.next).next;
                else ptr_1 = ptr_1.next;
                ptr_2 = ptr_2.next;
            }
        }
        if (ptr_1.next == null) ptr_1.next = ptr_2.next;
    }

无注释版本（建议画草稿图写）

public static void ListSum(Link List_1, Link List_2){
        Link ptr_1 = List_1, ptr_2 = List_2;
       
   		while (ptr_1.next != null && ptr_2.next != null) {
            
            if ((ptr_1.next).coef == 0) ptr_1.next = (ptr_1.next).next;
            if ((ptr_2.next).coef == 0) ptr_2 = ptr_2.next;
            if (ptr_1.next == null || ptr_2.next == null) break;

            if ((ptr_1.next).exp < (ptr_2.next).exp) ptr_1 = ptr_1.next;
            else if ((ptr_1.next).exp > (ptr_2.next).exp) {
                Link ptr = ptr_2.next;
                ptr_2.next = ptr.next;
                ptr.next = ptr_1.next;
                ptr_1.next = ptr;
            }
            else {
                (ptr_1.next).coef += (ptr_2.next).coef;
                if ((ptr_1.next).coef == 0) ptr_1.next = (ptr_1.next).next;
                else ptr_1 = ptr_1.next;
                ptr_2 = ptr_2.next;
            }
        }
    
        if (ptr_1.next == null) ptr_1.next = ptr_2.next;
    }
2.【约瑟夫(Josephus)环问题】

​ 有 n n n个人，编号分别为 1 , 2 , 3 , . . . , n 1,2,3,...,n 1,2,3,...,n,从编号为 1 1 1号的人开始报数，报到数字 m m m的人离开，下一个人重新开始从 1 1 1开始报数，依次类推，直至最终剩余 1 1 1人，求剩余的那个人的编号。

【实现代码】：

import java.util.*;

class Link {
    int num;
    Link next;
}

public class Main {

    public static void InitList(Link List_Head) {
        List_Head.next = List_Head;
    }

    public static void InsertList(Link List_Head, int num) {
        Link ptr = List_Head;
        while (ptr.next != List_Head) {
            ptr = ptr.next;
        }
        //Insert between ptr and List_Head
        Link List_new = new Link();
        List_new.num = num;
        List_new.next = List_Head;
        ptr.next = List_new;
    }

    public static void JosephusList(Link List_Head, int m) {
        Link ptr = List_Head;
        int count = 1;
        while ((List_Head.next).next != List_Head) {
            if (ptr.next == List_Head) ptr = ptr.next;
            if (count == m) {
                //Delete ptr.next
                System.out.println((ptr.next).num + " OUT");
                ptr.next = (ptr.next).next;

                count = 1;

            }
            else {
                count++;
                ptr = ptr.next;
            }
        }

        System.out.println("*" + (List_Head.next).num + "*");
    }

    public static void TraverseList(Link List_Head) {
        Link ptr = List_Head;
        while (ptr.next != List_Head) {
            System.out.println((ptr.next).num + " ");
            ptr = ptr.next;
        }
    }

    public static void main(String[] argv) {
        Scanner cin = new Scanner(System.in);
        Link List_Head = new Link();
        InitList(List_Head);
        System.out.println("请输入n:");
        int n = cin.nextInt();
        System.out.println("请输入m:");
        int m = cin.nextInt();
        for (int i = 1; i <= n; i++) {
            InsertList(List_Head, i);
        }
        JosephusList(List_Head, m);
    }
}

时间复杂度分析：

​ 每删去一个人需要将链表查找 m m m次，所以删去 n − 1 n-1 n−1个人需要的次数为：
m × ( n − 1 ) {m}\times{(n-1)} m×(n−1)
∴时间复杂度为： O ( m × n ) O({m}\times{n}) O(m×n)

附：约瑟夫环公式

1）.右移
在这里插入图片描述

推理：

设ptr、ptr’ 分别为移动前与移动后的位置,移动 t t t位

①、先求出ptr相对于起始位置（图中为 a 1 a_1 a1​）的相对位置：
p t r − h e a d ptr - head ptr−head
②、求出移动后超出 n n n的部分（即为相对起始位置（下个循环）的相对位置长度）：
( p t r − h e a d + t ) m o d n (ptr - head + t)\quad mod \quad n (ptr−head+t)modn
③、易得：
p t r ′ = ( p t r − h e a d + t ) m o d n + h e a d ptr'=(ptr-head+t)\quad mod\quad n + head ptr′=(ptr−head+t)modn+head
结论：ptr’ = (ptr - 起始位置 + t) mod n + 起始位置

2）.左移
在这里插入图片描述

推理：

设ptr、ptr’ 分别为移动前与移动后的位置,移动 t t t位

①、先求出ptr相对于起始位置（图中为 a 1 a_1 a1​）的相对位置：
p t r − h e a d ptr - head ptr−head
②、求出移动后超出 n n n的部分（为负值）：
( p t r − h e a d − t ) m o d n (ptr - head - t)\quad mod \quad n (ptr−head−t)modn
③、根据②式以及图像易得到ptr’相对于上个循环起始位置的相对位置长度：
p t r − h e a d − t + n ptr - head - t + n ptr−head−t+n
接下来，易得：
p t r ′ = ( p t r − h e a d − t + n ) m o d n + h e a d ptr'=(ptr-head-t+n)\quad mod\quad n + head ptr′=(ptr−head−t+n)modn+head
结论：ptr’ = (ptr - 起始位置 - t + n) mod n + 起始位置

demiphea
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java数据结构之线性表
08-31
线性表是其组成元素间具有线性关系的一种数据结构，对线性表的基本操作主要有，获取元素，设置元素值，遍历，插入，删除，查找，替换，排序等。而线性表可以采用顺序储存结构和链式储存结构，本节主要讲解顺序表、...
Java数据结构（线性表）详解
08-30
本文主要介绍了Java数据结构（线性表）的相关知识。具有很好的参考价值，下面跟着小编一起来看下吧
线性表的实现
Pengwill's Blog
09-29 343
线性表的实现最近一直在看数据结构方面的书,最先遇到的就是线性表,于是乎照猫画虎的写了一下线性表的代码.可能很多地方还有可以改进的地方,希望各位能在下面留言,非常期待各位高手宝贵的意见. 个人觉得比较难的几个地方是: 1.指针的使用.你会突然发现C学的简单的指针不够用了,需要学更多的关于指针的东西; 2.关于数组角标的计算.这种东西拿特殊情况带一下就能算出来啦. 下面还是PO出我的代码,供大家
线性表~线性表的基本操作--one
m0_73374328的博客
10-22 226
（3）int Find(ElementType A,List L):在线性表L中查找A第一次出现的位置。（2）ElementType FindKth(int K,List L):在表L中找位序为K的元素。（5）void Delete(int t,List L):删除指定位序t的元素。（6）int Length(List L):返回线性表L的长度n。在第i(i
第 4 章 文件管理
Oneby的博客
03-05 2385
第 4 章 文件管理 1、初识文件管理 1.1、前情回顾 操作系统所需提供的功能 操作系统作为最接近硬件的软件系统，向下需要与硬件打交道，向上需要为应用软件和用户提供相应接口 操作系统需要提供处理机管理、存储器管理、文件管理、设备管理等功能，我们日常编辑的 Word 文档、PPT 文档都需要存储在硬盘上，操作系统为我们提供了文件管理相关的接口 文件就是一组有意义的信息/数据集合 下面思考这一系列的问题： 计算机中存放了各种各样的文件，一个文件有哪些属性？ 文件内部的数据应该怎样组织起来？ 文件
线性查找与二分查找的平均查找次数的比较
热门推荐
picc_lu的博客
07-25 1万+
*不讨论查找不成功的情况 *设一数组arr，长度为n（下列例子中，n 取具体值100, 10000, 10000000） 线性查找（顺序查找） 在无序的数组中查找一指定值，必须遍历整个数组，直至查找成功，计算其平均查找次数也相当简单： avg线性 = (1 + n) / 2 因在数组中，各个元素被查找的概率相等，最好的情况是第1个就是目标元素；最坏的情况是最后一个才是目标元素，就不...
408——操作系统 第四章 文件管理
spercer97的博客
09-15 3246
文件管理1. 文件系统基础1.1 文件概念1.2 文件的逻辑结构1.2.1 顺序文件1.2.2 索引文件1.2.3 索引顺序文件1.3 目录结构1.3.1 文件控制块和索引节点1.3.2 单级目录结构和两级目录结构1.3.3 树形目录结构1.3.4 图形目录结构1.4 文件共享1.5 文件保护1.5.1 访问类型1.5.2 访问控制2. 文件系统实现2.1 文件系统层次结构2.2 目录实现2.3 文件实现3. 磁盘组织与管理3.1 磁盘的结构3.2 磁盘调度算法3.3 磁盘的管理 1. 文件系统基础 1
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验内容 （1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表...
数据结构实验2 线性表.doc
06-20
（1） 理解线性表的逻辑结构、两种存储结构和数据操作； （2） 应用顺序表的基本算法实现集合A=AUB算法，应用顺序表的基本算法实现两有序顺序表的归并算法； （3） 掌握单链表的遍历、插入和删除等操作算法，实现...
数据结构线性表的各种实现
04-22
用java实现了各种线性表（表，队列，栈等），包括顺序数组实现和链表实现
数据结构：笔记
世上再无张显宗
05-21 3103
1、顺序表的平均比较次数：（n+1）/ 2 解析】在顺序表中查找，最好情况下第一个元素就是要查找的元素，则比较次数为 1 ；在最坏情况下，最后一个元素才是要找的元素，则比较次数为 n 。两种情况平均即（ 1+n ） /2 。 2、顺序表的平均查找长度：(n+1) /2 第一个数的比较次数为1，第二个数的比较次数为2。。。以此类推第N个数的比较次数为N，所以总的比较次数为1+2+…+N=N(N+1)/2,平均比较次数为(N+1)/2,也即平均查找长度。 3、在ASC算法team日常开发中，常常面临一些数据结构
经典查找算法及其Python实现
Kaiyuan_sjtu的博客
05-10 4779
写在前面 上一篇介绍了几大排序算法，从基本原理解释到Python代码实现，平时有空的话还需要经常翻出来复习复习。今天就主要来看看另外一大类算法：经典查找算法。 参考资料： 《大话数据结构》、《算法第4版》（配套视频：Algorithms, Part I，Algorithms, Part II） 本篇相关python代码已上传至Github：使劲儿点！ 1.基本概念 查找就是根据给定的某...
数据结构与算法：查找、排序、动态规划、数学
最新发布
薛定谔的猫-前端领域
06-30 529
比如选择基准元素为左侧第一个元素，通过使用一个指针指向基准元素的下一个元素，同时遍历基准元素右侧元素，若元素小于基准元素，则交换当前遍历元素和指针指向元素，且移动该指针，最终指针所在位置就是大于等于基准元素的第一个元素位置。创建桶，数量等于原始数组的元素数量，这样，每个桶的长度为 （最大值- 最小值） / (桶数量 - 1），然后通过（元素值 - 最小值 ）/ 桶长度，将原始数组中的每个桶分布到不同的桶中，对每个桶中的元素执行某个排序算法使桶内有序，最后将所有桶合并成排序好后的结果数组。
平均访盘次数
weixin_44390844的博客
08-27 6621
一级目录的平均访盘次数： 按照数据结构的顺序查找效率来理解，目录有n项，要访问其中的某一项，最好的情况下是查找的第一项即为目标查找项，只需访盘一次，最差的情况下是访问到第n个才查找到目标项，需访问n次，故平均查找次数是（1+2…+n）/n。 【例1】（王道上面的题目）一个文件系统中，其FCB占64B，一个盘块大小为1KB，采用一级目录。假定文件目录中有3200个目录项，则查找一个文件平均需要（）次访问磁盘 【解析】 目录项占用盘块数=3200*64B/1KB=200个 一级目录平均访问盘块数带入上述公式得
哈希表查找——等概率情况下查找成功和查找不成功的平均查找长度的计算
ZJRUIII的博客
08-19 4533
H(18) = (18x3) MOD 7 = 5，地址是5，因此放到散列表的数组下表为5的位置，但这个位置上已经有关键字11，遇到了冲突，此时我们根据线性探测再散列法来处理这个冲突，探测下一个位置6，6这个位置上已经存在关键字30则继续增加1，因此现在的新地址应为7，位置7上没有关键字，放入即可，到此冲突已经解决；H(14) = (14x3) MOD 7 = 0，地址是0，因此放到散列表的数组下表为0的位置，但这个位置上已经有关键字7，遇到了冲突，探测下一个位置1，位置1上没有关键字，放入即可；
MySQL索引数据结构详解
weixin_45596022的博客
08-31 345
1.Hash散列表 hash表的结构就是一个数组每个节点都可以形成一个链表。 hash表的查找效率很高，但是hash表不适合范围查找。 2.二叉查找树 1）二叉树简介 二叉查找树也称为有序二叉查找树，二叉查找树的性质： 1、任意节点左子树不为空,则左子树的值均小于根节点的值； 2、任意节点右子树不为空,则右子树的值均大于于根节点的值； 3、任意节点的左右子树也分别是二叉查找树； 4、没有键值相等的节点； 中序遍历顺序：4 6 7 8 9 10 二叉查找树的平均查找次数为（3+3+3+2+2+1）/6=2.
查找——平均查找长度
karry_zzj的博客
06-19 1万+
查找有以下查找方式： 顺序表查找 二分查找 索引表查找 二叉排序树查找 哈希表查找 接下来整理一下上面每个方式的平均查找长度顺序表查找ASL如果每个关键字查找概率相同，则ASL = (n+1)/2。 一般都是概率相同。二分查找ASL举例说明：这是一个有序序列(下标和关键字相同)： 0 1 2 3 4 初始化：low = 0, high = 4第一次： mid = (0+4
java数据结构-线性表的设计与实现
06-28
数组实现线性表可以直接利用Java提供的数组数据类型。在这种实现方式中，线性表的元素存储在一个一维数组中，可以通过下标访问和操作元素。但是，由于数组长度固定，插入和删除元素时需要移动大量的数据，所以插入和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值