C语言数据结构[线性表]

已于 2022-06-03 11:15:50 修改
阅读量183 收藏 1
点赞数
分类专栏： # C语言数据结构 文章标签： 数据结构 c语言 链表
于 2022-06-03 08:58:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46765649/article/details/125015807
版权

在这里插入图片描述

一、顺序表

优点：查询操作比较快
缺点：数据存放必须是连续的；添加删除操作移动次数过多

A:动态分配

1.1 初始化

// 结构体存放初始数据
typedef struct student
{
    int* p;
    int len;
} STUDENT;

// 全局变量表创建时使用
int max_size=10;

// 初始化创建，用一个结构体存放动态创建内容的首地址
void arr_init(STUDENT* p){
    p->p = (int*)malloc(sizeof(int)*max_size);
    p->len=0;// 表写入数据的长度
}

1.2 插入

void arr_insert(STUDENT *p,int positon,int data){
    int i;
    if(positon>max_size){
        printf("超出允许的范围");
    }
    for(i=p->len;i>positon-1;i--){
        *(p->p+i)=*(p->p+i-1);
    }// 0 1 2
    *(p->p+i)=data;
    p->len++;
}

1.3 删除

void arr_remove(STUDENT* p,int positon){
    int i;
    if(positon>max_size){
        printf("超出允许的范围");
        return;
    }// 1 2 3
    for(i=positon-1;i<p->len-1;i++){
        *(p->p+i)=*(p->p+i+1);
    }
    p->len--;
}

1.4 释放

free(stu.p);

1.5 打印

void arr_printf(STUDENT p){
    int i;
    for(i=0;i<p.len;i++){
        printf("%d\n",*(p.p+i));
    }
}

1.6 示例程序

void main(){
    STUDENT stu;
    arr_init(&stu);
    arr_insert(&stu,1,151);
    arr_insert(&stu,2,15);
    arr_insert(&stu,3,1);
    arr_insert(&stu,4,15111);
    arr_remove(&stu,4);
    arr_printf(stu);
    free(stu.p);
}

B:静态分配

解释：单纯的把结构体中的指针换为数组

区别：分配位置大小固定

二.单链表

A:单链表

优点：相比于顺序表，添加删除操作比较快，比较方便
缺点：相比于顺序表，查询比较慢；只能单向按顺序访问

2.1 有头节点

注意：用有头节点写程序会很方便，本程序的头结构体与数据结构体不一致，造成程序更杂乱，普通使用头结构体与数据结构体相同即可
图解：
在这里插入图片描述

2.1.1 初始化
typedef struct student
{
    int data;
    int next;
} NODE;
// 初始化
NODE* list_init()
{
    NODE* p =(NODE*)malloc(sizeof(NODE));
    p->data=0;
    p->next=NULL;
    return p;
}
2.1.2 插入
// 按位置插入
void list_insert(NODE* head,int data,int position)
{
    int i;
    NODE* node = (NODE*)malloc(sizeof(NODE));// head 1 2 3
    for(i=1;i<position;i++){
        head=head->next;
    }
    if(head){
        node->data=data;
        node->next=head->next;
        head->next=node;
    }

}
2.1.3 删除
// 删除指定位置的内容
void list_remove(NODE* head,int position)
{
    int i;
    for(i=1;i<position;i++){
        head=head->next;
    }
    NODE* temporary=head->next;
    head->next=temporary->next;
    free(temporary);
}
2.1.4 打印
// 打印内容
void list_printf(NODE* p)
{
    p=p->next;
    while(p){
        printf("%d\n",p->data);
        p=p->next;
    }
}
2.1.5 主程序
void main()
{
    NODE*p = list_init();
    list_insert(p,5,1);
    list_insert(p,69,2);
    list_insert(p,6555,3);
    list_remove(p,2);
    list_printf(p);

    return 0;
}

2.2 无头节点

注意：无头节点，在涉及到第一位元素的操作时会变得很麻烦，代码同时更杂乱

// 初始化
typedef struct student
{
  	int a;
    int b;
    struct student* next;
} NODE;

NODE* list_init(int a,int b)
{
    NODE* node=(NODE*)malloc(sizeof(NODE));
    node->a=a;
    node->b=b;
    node->next=NULL;
    return node;
}
// 插入
NODE* list_insert(NODE* p,int a,int b,int position)// 带返回值主要是为了头插法，改变p的指向
{
    int i;
    NODE* node=(NODE*)malloc(sizeof(NODE));
    node->a=a;
    node->b=b;
    NODE* pos=p;// 1 2 ox12  ,5 5 ox19  ,66 6 ox35
    if(position==1)
    {
        node->next=p;
        p=node;// 此时不用返回值，p在main里面并不会和此一样
        return p;
    }
    else
    {
        for(i=1; i<position-1; i++)
        {
            pos=pos->next;
        }
        node->next=pos->next;
        pos->next=node;
        return p;
    }
}
// 删除
void list_remove(NODE* p,int position)
{
    int i;
    NODE* pos=p;
    NODE* pos_one;// 1 2 ox12  ,5 5 ox19  ,66 6 ox35
    if(position==1) //不能直接简单交换指针，可以换数据
    {
        pos_one=p->next; // 准备删除第二个，此作为中介
        p->a=p->next->a;
        p->b=p->next->b;
        p->next=p->next->next;
        free(pos_one);
    }
    else
    {
        for(i=1; i<position-1; i++)
        {
            pos=pos->next;// 即将删除位置前的一个
        }
        pos_one=pos->next;//post_one指针是要删除的内容
        pos->next=pos_one->next;// 把删除位置前的一个的指针，指向被删除指针指向的地址
        free(pos_one);
    }
}
// 释放
void list_del(NODE* p)
{
    NODE* node_one;
    NODE* node_two=p;
    while(node_two)
    {
        node_one=node_two;
        node_two=node_one->next;
        free(node_one);
    }
}
// 打印
void list_printf(NODE* p)
{
    NODE* pos=p;
    while(pos)
    {
        printf("%d %d\n",pos->a,pos->b);
        pos=pos->next;
    }
}
void main()
{
    int a=1200,b=1500;
    NODE* p = list_init(a,b);
    p=list_insert(p,1,2,2);
    p=list_insert(p,1115,212112,1);
    p=list_insert(p,15,212,1);
    list_remove(p,1);
    list_printf(p);
    list_del(p);
}

B:单循环链表

区别：可以从任意位置按照顺序去查询数据

代码细节：①初始化放置的头节点放置不是NULL而是指向自己②循环结束条件改为pos!=p

// 单循环链表
#include <stdio.h>
#include <stdlib.h>
typedef struct student
{
    int a;
    int b;
    struct student* next;
} NODE;
// 带头指针的初始化
NODE* list_init()
{
    NODE* node=(NODE*)malloc(sizeof(NODE));
    node->a=0;
    node->b=0;
    node->next=node;
    return node;
}
// 按位置插入
void list_insert(NODE* p,int a,int b,int position)
{
    int i;
    NODE* node=(NODE*)malloc(sizeof(NODE));
    node->a=a;
    node->b=b;// 1 2 ox12  ,5 5 ox19  ,66 6 ox35
    for(i=1; i<position; i++)
    {
        p=p->next;
    }
    node->next=p->next;
    p->next=node;
}
// 打印内容
void list_printf(NODE* p)
{
    NODE* pos=p->next;
    while(pos!=p)
    {
        printf("%d %d\n",pos->a,pos->b);
        pos=pos->next;
    }
}
// 清空
void list_del(NODE* p)
{
    NODE* node_one;
    NODE* node_two=p->next;
    while(node_two!=p)
    {
        node_one=node_two;
        node_two=node_one->next;
        free(node_one);
    }
}
// 删除指定位置的内容
void list_remove(NODE* p,int position)
{
    int i;
    NODE* pos_one;// 1 2 ox12  ,5 5 ox19  ,66 6 ox35
    for(i=1; i<position; i++)
    {
        p=p->next;// 即将删除位置前的一个
    }
    pos_one=p->next;//post_one指针是要删除的内容
    p->next=pos_one->next;// 把删除位置前的一个的指针，指向被删除指针指向的地址
    free(pos_one);
//    }
}
void main()
{
    NODE* p = list_init();
    list_insert(p,1,2,1);
    list_insert(p,1115,212112,2);
    list_insert(p,1115,2121,3);
    list_remove(p,1);
    list_printf(p);
    list_del(p);
}

三.双链表

A:双链表

优点：增加删除还是比顺序表方便，查询效率有提高，双向按顺序访问
缺点：使用的内存空间增大

代码细节：如果把移动指针指向目标上（而不是它前一个节点），注意null的处理

// 双链表
#include <stdio.h>
#include <stdlib.h>
typedef struct student
{
    int a;
    int b;
    struct student* pre;
    struct student* next;
} NODE;
// 带头指针的初始化
NODE* list_init()
{
    NODE* node=(NODE*)malloc(sizeof(NODE));
    node->a=0;
    node->b=0;
    node->pre=NULL;
    node->next=NULL;
    return node;
}
// 按位置插入
void list_insert(NODE* p,int a,int b,int position)
{
    int i;
    NODE* node=(NODE*)malloc(sizeof(NODE));
    node->a=a;
    node->b=b;// 1 2 ox12  ,5 5 ox19  ,66 6 ox35
    for(i=1; i<position; i++)
    {
        p=p->next;
    }
    node->next=p->next;
    node->pre=p;
    p->next=node;
}
// 打印内容
void list_printf(NODE* p)
{
    NODE* pos=p->next;
    while(pos)
    {
        printf("%d %d\n",pos->a,pos->b);
        pos=pos->next;
    }
}
// 清空
void list_del(NODE* p)
{
    NODE* node=p->next;
    NODE* node_tem;
    while(node)// 1 2 3
    {
        node_tem=node;
        node=node->next;
        free(node_tem);
    }
    free(p);
}
// 删除指定位置的内容
void list_remove(NODE* p,int position)
{
    int i;
    NODE* pos_one=p->next;// 1 2 ox12  ,5 5 ox19  ,66 6 ox35
    for(i=1; i<position; i++)
    {
        pos_one=pos_one->next;// 即将删除位置前的一个
    }
    pos_one->pre->next=pos_one->next; //这里引用的要删除的当前元素
    if(pos_one->next){ // 此种定位到要变动元素的方法，要防止末尾出现null的情况
        pos_one->next->pre=pos_one->pre;
    }
    free(pos_one);
}
void main()
{
    NODE* p = list_init();
    list_insert(p,1,2,1);
    list_insert(p,1115,212112,2);
    list_insert(p,1115,2121,3);
//    list_remove(p,3);
    list_printf(p);
    list_del(p);
}

B:双链表循环

代码细节：无需再注意NULL；注意循环条件的改变；尾插法时头节点的pre变化；插入其它位置时pre的变化；初始化时pre和next都指向头节点

// 双循环链表
#include <stdio.h>
#include <stdlib.h>
typedef struct student
{
    int a;
    int b;
    struct student* pre;
    struct student* next;
} NODE;
// 带头指针的初始化
NODE* list_init()
{
    NODE* node=(NODE*)malloc(sizeof(NODE));
    node->a=0;
    node->b=0;
    node->pre=node;
    node->next=node;
    return node;
}
// 按位置插入
void list_insert(NODE* p,int a,int b,int position)
{
    int i;
    NODE* node=(NODE*)malloc(sizeof(NODE));
    NODE* p2=p;
    node->a=a;
    node->b=b;// 1 2 ox12  ,  5 5 ox19, 66 6 ox35  ,  99 9 ox356
    for(i=1; i<position; i++)
    {
        p=p->next;
    }
    node->next=p->next;
    node->pre=p;
    p->next=node;
    if(node->next==p2){// 应对尾插法，头节点pre的处理
        p2->pre=node;
    }
    if(node->next->pre!=node){// 判断非尾插法插入
        node->next->pre=node;
    }


}
// 打印内容
void list_printf(NODE* p)
{
    NODE* pos=p->next;
    while(pos!=p)
    {
        printf("%d %d\n",pos->a,pos->b);
        pos=pos->next;
    }
}
// 清空
void list_del(NODE* p)
{
    NODE* node=p->next;
    NODE* node_tem;
    while(node!=p)// 1 2 3
    {
        node_tem=node;
        node=node->next;
        free(node_tem);
    }
    free(p);
}
// 删除指定位置的内容
void list_remove(NODE* p,int position)
{
    int i;
    NODE* pos_one=p->next;// 1 2 ox12  ,5 5 ox19  ,66 6 ox35
    for(i=1; i<position; i++)
    {
        pos_one=pos_one->next;// 即将删除位置前的一个
    }
    pos_one->pre->next=pos_one->next; //这里引用的要删除的当前元素
    pos_one->next->pre=pos_one->pre;
    free(pos_one);
}
void main()
{
    NODE* p = list_init();
    list_insert(p,1,2,1);
    list_insert(p,1115,212112,1);
    list_insert(p,1115,2121,1);
    list_remove(p,3);
    list_printf(p);
    list_del(p);
    return 0;
}

四.静态链表

优点：移动数据时只需要移动游标即可
缺点：表长固定不能变

思路：两条链路；一条是已分配路线，一条是未分配路线；其中第一位置和最后一个位置是不填充数据，第一个位置表示未分配线路起始下标，最后一个位置表示已分配路线的起始下标

1.初始化

在这里插入图片描述

// 初始化
NODE* list_init(NODE* p)// 初始时都是属于未分配这条链表
{
    int i=0;
    for(i=0;i<MAX;i++){
        (p+i)->next=i+1;
        (p+i)->data=0;
    }
    (p+MAX-1)->next=0;// 表示开始着开头元素的下标
    (p+MAX-2)->next=0;// 表示结束
}

2.插入

图解：假设已经填充了三条数据，现在已分配链是1->2，未分配链是3->4
在这里插入图片描述

图解：在第二位插入data，现在已分配链是1->3->2，未分配链是4->

在这里插入图片描述

// 按位置插入
void list_insert(NODE* head,int data,int position)// 开始增加数据形成已分配表
{


    // 初期建立的未分配表，下标0的next一直指向未分配数据
    int last = MAX-1;
    int newplace = head->next;//4
    int i;
    if(head->next) // 防止到最后一个数据为空的情况
    {
        head->next=(head+newplace)->next;
    }
    // 上面的代码是找到新空闲可分配位置
    if(newplace)
    {
        (head+newplace)->data=data;
        for(i=1; i<position; i++) //head 1 2 3
        {
            last=(head+last)->next;
        }
        (head+newplace)->next=(head+last)->next;
        (head+last)->next=newplace;
    }

}

3.删除

思路：找到被删除内容的前一个节点，想办法让其和被删除节点的下一个节点接起来；然后想办法让被删除节点连入未分配链路

// 删除指定位置的内容
void list_remove(NODE* head,int position)
{
    int i;
    int last = MAX-1;
    int old;
    for(i=1; i<position; i++) //head 1 2 3
    {
        last=(head+last)->next;
    }
    old=(head+last)->next;
    (head+last)->next=(head+old)->next;
    // 上面的代码成功断开联系，下面的代码负责刚刚释放的接入到未分配链表中去
    (head+old)->data=0;
    (head+old)->next=head->next;
    head->next=old;
}

4.打印

// 打印内容
void list_printf(NODE* p)
{
    int i;
    NODE* p1=p;
    int firstplace = (p+MAX-1)->next;
    p = p+firstplace;
    do
    {
        printf("%d\n",p->data);
        i = p->next;
        p=p1;// 让p回到起始位置
        p=p+i;
    }
    while(p->next);
    printf("%d",p->data);// 最后一位专门打印
// 下面注释的是检测数组的代码
//for(i=0;i<MAX;i++){
//    printf("%d-%d\n",p->data,p->next);
//    p++;
//}
}

5.主程序

void main()
{
    NODE p[MAX];
    list_init(p);
    list_insert(p,5,1);
    list_insert(p,69,1);
    list_insert(p,6555,1);
    list_remove(p,3);
    list_printf(p);

    return 0;
}
黑日里不灭的light
关注
专栏目录
c语言数据结构线性表创建删除插入
06-30
在IT领域，C语言是一种广泛使用的...理解并熟练掌握线性表的创建、插入和删除操作是学习C语言数据结构的重要步骤，这将有助于进一步学习更复杂的算法和数据结构。通过实践，你可以更好地理解这些概念，并提升编程能力。
（数据结构&C语言）对链表的认识
XY_Mckevince的博客
11-27 595
线性表的链式存储结构-单链表
C语言——数据结构（线性，树形，图形结构等）
qq_45844792的博客
04-19 7011
数据结构 在学习数据结构之前我想先有一个大体的概念，所以在网上查了一些资料记录如下 常见的数据结构 1.线性结构 2.树形结构 3.图形结构 4.集合 一、线性结构（线性结构是一个有序数据元素的集合） 常用的线性结构有：线性表，栈，队列，双队列，串。 关于广义表、数组，是一种非线性的数据结构。 常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图 特征： 1．集合中必存在唯一的一个"...
线性结构（C语言）
DreamEmbrace的博客
02-01 323
数据结构C语言学习笔记，以浙大视频课程为参考
c语言里的线性结构,考研笔记数据结构线性结构之C语言
weixin_39593460的博客
05-22 199
一千个教程又一千种说法。数据结构的教材上都是伪代码。那么我认为写汉语也行咯。干脆全部用标准代码敲下来。到时候背一下。专业课其实就是在考背诵。手头没有编译器希望大家能够提出意见。约定Code:#defineTRUE1#defineFALSE0#defineERROR0#defineINFEASIBLE-1#defineOVERFLOW-2#defineOK1线性表静态线性表书...
C语言最常见的线性结构---数组
Nwk0000000001的博客
07-11 991
C语言最常见的线性结构—数组 数组详解 数组定义:有序数据的集合,用数组名作为标识 数组性质:数组是由一些列相同数据类型组成的线性集合 数组组成：标识符、类型名、维数。其中，维数指定数组中的元素个数。 数组优缺点: 1）与vector类型相比，数组缺陷在于：数组的长度是固定的，不能知晓数组的长度。同时没有size和push_back操作。如果要更改长度，则要创建更大的新数组，再复制原数组的所有元素。 注:vector是C++中的STL容器的一个容器分支,属于动态数组内容 2）数组是被严格限制
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
c语言数据结构线性表实验（包括顺序表和链表）
11-28
在这个"C语言数据结构线性表实验"中，我们将深入探讨两种实现线性表的方法：顺序表和链表。 1. **顺序表**： - **定义**：顺序表是将数据元素存储在一块连续的内存区域中，每个元素都有一个固定的索引位置。 - **...
C语言数据结构线性表的基本操作实验报告.doc
10-10
C语言数据结构线性表的基本操作实验报告 一、实验目的与基本要求 本实验的目的是掌握数据结构中的一些基本概念，了解数据的逻辑结构和数据的存储结构之间的区别与联系，掌握顺序表和链表的基本操作，并掌握运用 C ...
数据结构：线性结构（C语言）
过客的博客
08-23 2546
文章目录线性结构线性表什么是线性表线性表的抽象类型描述线性表的实现广义表广义表定义多重链表堆栈什么是堆栈堆栈的抽象数据类型描述堆栈的顺序存储实现堆栈的链式存储实现堆栈的应用队列什么是队列队列的抽象数据类型描述队列的顺序存储实现队列的链式存储实现 线性结构 线性表 什么是线性表 线性表(Linear List):由同类型数据元素构成有序序列的线性结构。 表中元素个数称为线性表的长度。 线性...
数据结构——线性结构（线性表）
热门推荐
巧克力布丁的博客
10-24 1万+
定义把所有的结点用一根直线穿起来详细定义线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，n=0是一个空表。用L表示线性表a1是唯一的第一个数据元素，又称表头元素；an是唯一的最后一个元素，又叫表尾元素。除了第一个元素之外，每个元素有且仅有一个直接前驱。除了最后一个元素外，每个元素有且仅有一个直接后继。n个节点离散分配彼此通过指针相连每个节点只有一个前驱节点，每个节点只有一个后续节点首节点没有前驱节点，尾节点没有后续节点从某种角度而言。............
C语言·结构体(线性表入门）
weixin_48060069的博客
07-23 1215
结构体 结构体的多种定义方式 结构体别名（typedef）与结构体变量的区别 对结构体变量进行初始化 结构体细节​​​​​​​ 数据结构课本里的实例——单链表 结构体的scanf读取和输出 结构体指针 C++的引用​​​​​​​ .........
C语言|数据结构——线性结构（线性表及其实现）
冰小九的博客
11-02 566
线性表（Linear List）主要操作的实现 初始化广义表实际上就是多重链表 多重链表中的结点可能同时隶属多个链 指针域会有多个，例如上面代码行中的Next和SubList两个指针域 但双向链表中包含两个指针域，并不是多重链表基本上树、图这样相对复杂的数据结构都可以采用多重链表方式实现存储。 矩阵 采用典型的多重链表——十字链表来代替二维数组来存储稀疏矩阵 （二维数组存储稀疏矩阵缺点：1.会造成大量空间浪费
C语言线性数据结构
weixin_44230855的博客
07-24 424
C语言线性数据结构 最近在学习数据结构 写博客记录一下，很久没写过c语言了，也是现学现用。 线性表的顺序存储结构 *顺序表的三个属性： 1.存储空间的起始位置（数组名data） 2.顺序表最大存储容量（MaxSize） 3.顺序表当前的长度（length） 编译器为vc6 // 头文件 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include "windows.h" #define M
C语言-数据结构(线性结构)-链式存储(链表)
weixin_42947972的博客
09-06 796
一.简介 我还是在哔哩哔哩学的,hhhh…赫斌老师数据结构入门的内容-b站搜索:av6159200(P24-P29),通过学习之后,自己写出链表的内容,并在原有的基础上进行修改与增加. 链表过程还不理解可以看一下第三部分的图解. 二.修改与增加的内容 赫斌老师定义的函数 我定义的函数 可以看出和我上一篇C语言-数据结构(线性结构)-顺序存储(数组),我把他用的c++,bool的语法返回,进行了...
C语言数据结构——线性表
C.
10-04 3114
顺序存储定义线性表是顺序存储结构，他是用一段地址连续的存储单元依次存储线性表的数据元素线性表的顺序存储结构//线性表顺序存储结构 #define MAXSIZE 20 //存储空间初始分配最大的size typedef int ElemType; //假定ElemType的类型为inttypedef struct { ElemType data[MAXSIZE]; //数组来存储线性表
数据结构笔记-线性表
Don2100的博客
08-25 674
线性表 线性表结构 线性表定义 typedef int T; // 数据元素的数据类型。 struct SeqList{ T* data; // 数据元素的开始地址。 int len; // 当前长度。 int max; // 线性表的最大长度。 }; 线性表操作 SeqList* SL_Create(int maxlen){// 创建一个顺序表，与SqLst_Free()配对。 S...
第二讲 线性结构
lingdoudoulingling的博客
10-07 2422
2.1 线性表及其实现 45分钟的课时，大概学习了90分钟。 1.多项式的线性表表示 方法一：顺序存储结构，数组直接表示 二：顺序存储结构，数组只表示非零项 三：链式存储结构，链表表示 ===========================================================================================
基于c语言线性结构—栈和队列
venus321的博客
02-22 694
栈定义 栈(Stack)是限定只能在表的一端(表尾)进行插人或刪除操作的线性表。允许进行插人或删除的这一端称为栈顶(Top);另一端则称栈底(Bottom),不能进行插人或删除。 当栈中没有包含数据元素时，称为空栈。栈非空时，处于栈顶位置的元素称为栈顶元素。向一个栈插人新的元素称为人栈或进栈(Push)，此时，插人的元素成为新的栈顶元素;从找中删除一个元素时，只能删除当前的栈顶元素，称为出栈或...
C语言数据结构线性表的排序代码
最新发布
09-24
C语言中，线性表（如数组或链表）的排序通常是通过各种排序算法实现的。这里我会给你展示如何使用简单的冒泡排序算法对整型数组进行排序，这是一个基础的例子： ```c #include // 冒泡排序函数 void bubble_sort...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值