【数据结构】线性表

最新推荐文章于 2024-07-14 21:31:19 发布
最新推荐文章于 2024-07-14 21:31:19 发布
阅读量26 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 学习 笔记 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61501223/article/details/132201893
版权

一、逻辑结构与存储结构

1.逻辑结构（对人友好）
  • 集合结构-无关系
  • 线性结构-一对一
  • 树形结构-一对多
  • 图形结构-多对多
2.存储结构（对计算机友好）
  • 顺序存储
  • 链式存储
  • 索引存储
  • 散列存储
2.1优缺点
2.1.1.顺序存储

优点：

  • 可以实现随机存取
  • 每个元素占用最少的空间

缺点：

  • 只能使用整块的存储单元，会产生较多的碎片
2.1.2链式存储

优点：

  • 充分利用所有的存储单元，不会出现碎片现象

缺点：

  • 需要额外的存储空间用来存放下一结点的指针
  • 只能实现顺序存取

二、顺序表的初始化及插入操作

代码

#include<stdio.h>

//顺序表的初始化及插入实战

#define MaxSize 50
typedef int ElemType;//让顺序表存储其他类型元素时，可以快速完成修改
typedef struct{
    ElemType data[MaxSize];
    int length;//顺序表长度
}SqList;
//顺序表的插入，因为L会改变，因此我们这里要用引用，i是插入的位置
bool ListInsert(SqList &L,int i, ElemType element)
{
    //判断i是否合法
    if(i<1 || i>L.length+1)
    {
        return false;
    }
    //如果存储空间满了，不能插入
    if(L.length==MaxSize)
    {
        return false;//没有插入成功
    }
    //把后面的元素依次往后移动，空出位置，用来放入要插入的元素
    for(int j=L.length;j>=i;j--)
    {
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=element;//放入要插入的元素
    L.length++;//顺序表长度加一
    return true;//插入成功
}

//打印顺序表
void PrintList(SqList L)
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        printf("%3d",L.data[i]);//为了打印到同一行
    }
    printf("\n");
}

int main()
{
    SqList L;//定义一个顺序表，顺序表名称L
    bool ret;//ret用来装入查看返回值

    //手动在顺序表中赋值
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//总计三个元素
    ret=ListInsert(L,2,60);
    if(ret)
    {
        printf("insert sqlist success\n");
        PrintList(L);
    }
    else
    {
        printf("insert sqlist failed\n");
    }

    return 0;
}

输出结果

insert sqlist success
  1 60  2  3

三、顺序表的删除及查询操作

在顺序表的初始化及插入操作的基础上完成删除和查询操作

代码

#include<stdio.h>

//顺序表的初始化及插入实战

#define MaxSize 50
typedef int ElemType;//让顺序表存储其他类型元素时，可以快速完成修改
typedef struct{
    ElemType data[MaxSize];
    int length;//顺序表长度
}SqList;
//顺序表的插入，因为L会改变，因此我们这里要用引用，i是插入的位置
bool ListInsert(SqList &L,int i, ElemType element)
{
    //判断i是否合法
    if(i<1 || i>L.length+1)
    {
        return false;
    }
    //如果存储空间满了，不能插入
    if(L.length==MaxSize)
    {
        return false;//没有插入成功
    }
    //把后面的元素依次往后移动，空出位置，用来放入要插入的元素
    for(int j=L.length;j>=i;j--)
    {
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=element;//放入要插入的元素
    L.length++;//顺序表长度加一
    return true;//插入成功
}

//打印顺序表
void PrintList(SqList L)
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        printf("%3d",L.data[i]);//为了打印到同一行
    }
    printf("\n");
}


//删除顺序表中的元素，i是要删除的元素的位置，e是为了获取被删除的元素的值
bool ListDelete(SqList &L,int i, ElemType &e)
{
    //判断删除的元素的位置是否合法
    if(i<1 || i>L.length)
    {
        return false;//一旦走到return函数就提前结束
    }
    e=L.data[i-1];//保存要删除的值
    int j;
    /*方法一：
    for(j=i-1;j<L.length-1;j++)
    {
        L.data[j]=L.data[j+1];
    }*/
    //方法二：
    for(j=i;j<L.length;j++)//往前移动元素
    {
        L.data[j-1]=L.data[j];
    }
    L.length--;//顺序表长度减一
    return true;
}


//查找某个元素的位置，找到了就会对应位置，没找到就返回0
int LocateElem(SqList L,ElemType element)
{
    int i;
    for(i=0;i<L.length;i++)
    {
        if(element==L.data[i])
        {
            return i+1;//因为i是数组的下标，加一才是顺序表的位置下标
        }//若相同元素有多个，修改代码继续查找，本代码只找第一个
    }
    return 0;//循环结束没找到
}


int main()
{
    SqList L;//定义一个顺序表，顺序表名称L
    bool ret;//ret用来装入查看返回值

    //手动在顺序表中赋值
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//总计三个元素
    ret=ListInsert(L,2,60);
    if(ret)
    {
        printf("insert sqlist success\n");
        PrintList(L);
    }
    else
    {
        printf("insert sqlist failed\n");
    }
    printf("----------------------------\n");

    ElemType del;//删除的元素存入del中
    ret=ListDelete(L, 1, del);
    if(ret)
    {
        printf("delete sqlist success\n");
        printf("del element=%d\n",del);
        PrintList(L);//顺序表打印
    }
    else
    {
        printf("delete sqlist failed\n");
    }
    printf("----------------------------\n");


    int pos;//存储元素位置
    pos=LocateElem(L,60);
    if(pos)
    {
        printf("find this element\n");
        printf("element pos=%d\n",pos);
    }
    else
    {
        printf("don't find this element\n");
    }

    return 0;
}

输出结果

insert sqlist success
  1 60  2  3
----------------------------
delete sqlist success
del element=1
 60  2  3
----------------------------
find this element
element pos=1

四、新建链表

1. 头插法新建链表代码实战流程图
定义链表头指针
头节点申请空间
scanf读取第一个元素值
开启while循环建立链表
打印链表

根据流程图来写代码

  • 头插法
#include <stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

//LNode*是结构体指针，和LinkList完全等价的
void list_head_insert(LNode* &L)
{
    L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s;//用来指向申请的新结点
    while(x != 9999)
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;//s的next指向原本链表的第一个结点
        L->next=s;//头结点的next，指向新结点
        scanf("%d",&x);
    }
}

void print_list(LinkList L)
{
    L=L->next;
    while(L !=NULL )
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}

//头插法新建链表
int main() {
    LinkList L;//链表头指针，是结构体指针类型
    list_head_insert(L);//输入数据可以为3 4 5 7 9999，头插法新建链表
    print_list(L);

    return 0;
}

测试结果

3 4 5 6 7 9999
  7  6  5  4  3
2. 尾插法新建链表代码实战流程图
定义链表头指针
头节点申请空间
定义尾指针r执行头结点L
scanf读取第一个元素值
开启while循环建立链表
打印链表

根据流程图写代码

​ 尾插法特点是我们始终让尾指针r指向链表的尾部。

  • 尾插法
#include <stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
    L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾结点的next指针
        r=s;//r要指向新的尾部
        scanf("%d",&x);
    }
    r->next=NULL;//让尾结点的next为null

}

void print_list(LinkList L)
{
    L=L->next;
    while(L !=NULL )
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}

//尾插法新建链表
int main() {
    LinkList L;//链表头指针，是结构体指针类型
    //list_head_insert(L);//输入数据可以为3 4 5 7 9999，头插法新建链表
    list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
    print_list(L);

    return 0;
}

测试结果

3 4 5 6 7 9999
  3  4  5  6  7

五、链表查找

流程图
定义头指针
尾插法新建链表
查找某元素位置
判断某元素位置是否合法
L是位置0
遍历链表查找值
1. 基于尾插法的按位置查找
#include <stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
    L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾结点的next指针
        r=s;//r要指向新的尾部
        scanf("%d",&x);
    }
    r->next=NULL;//让尾结点的next为null

}


void print_list(LinkList L)
{
    L=L->next;
    while(L !=NULL )
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}

//按照位置查找
LinkList GetElem(LinkList L,int search_pos)
{
    int i=0;//从0开始遍历
    if(search_pos<0)
    {
        return NULL;
    }
    while(L&&i<search_pos)
    {
        L=L->next;
        i++;
    }
    return L;
}

//尾插法新建链表
int main() {
    LinkList L,search;//链表头指针，是结构体指针类型
    list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
    print_list(L);//链表打印

    //按照位置查找
    search=GetElem(L,2);
    if(search != NULL)
    {
        printf("succeeded in searching by serial number\n");
        printf("%d\n",search->data);
    }


    return 0;
}

测试结果

3 4 5 6 7 9999
  3  4  5  6  7
succeeded in searching by serial number
4
2. 基于尾插法的按值查找
#include <stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
    L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾结点的next指针
        r=s;//r要指向新的尾部
        scanf("%d",&x);
    }
    r->next=NULL;//让尾结点的next为null

}


void print_list(LinkList L)
{
    L=L->next;
    while(L !=NULL )
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}


//按值查找
LinkList LocateElem(LinkList L,ElemType search_value)
{
    while(L)
    {
        if (L->data==search_value)//如果找到对应的值，就返回那个结点的地址
        {
            return L;
        }
        L=L->next;
    }
    return NULL;//遍历到最后没有找到就返回null
}


//尾插法新建链表
int main() {
    LinkList L,search;//链表头指针，是结构体指针类型
    list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
    print_list(L);//链表打印

    //按值查找
    search=LocateElem(L,6);
    if(search != NULL)
    {
        printf("search by value succeeded\n");
        printf("%d\n",search->data);
    }


    return 0;
}

测试结果

3 4 5 6 7 9999
  3  4  5  6  7
search by value succeeded
6

六、插入操作

把新结点插入到第i个位置，策略是调用GetElem函数，拿到i-1元素位置地址

流程图
定义头指针
尾插法新建链表
要插入第i个位置
通过GetElem按位置查找
拿到第i-1个元素位置地址
把新结点放在i-1元素后面

插入位置

​ 创建新结点代码

q=(LNode*)malloc(sizeof(LNode));
q->data=x;
  • 表头插入元素
  • 中间插入元素

表头、中间插入元素代码

q->next=p->next;
p->next=q;
  • 表尾插入元素

表尾插入元素代码

p->next=q;
q->next=NULL;
往第i个位置插入元素
#include <stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
    L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾结点的next指针
        r=s;//r要指向新的尾部
        scanf("%d",&x);
    }
    r->next=NULL;//让尾结点的next为null

}


void print_list(LinkList L)
{
    L=L->next;
    while(L !=NULL )
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}

//按照位置查找
LinkList GetElem(LinkList L,int search_pos)
{
    int i=0;//从0开始遍历
    if(search_pos<0)
    {
        return NULL;
    }
    while(L&&i<search_pos)
    {
        L=L->next;
        i++;
    }
    return L;
}

//插入函数
bool list_front_insert(LinkList L,int insert_pos,ElemType insert_value)
{
    LinkList p= GetElem(L,insert_pos-1);
    if(p==NULL)
    {
        return false;
    }
    LinkList q;
    q=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
    q->data=insert_value;
    q->next=p->next;
    p->next=q;
    //表头、中、尾插入这个均适用
    return true;

}

//尾插法新建链表
int main() {
    LinkList L,search;//链表头指针，是结构体指针类型
    list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
    print_list(L);//链表打印

    list_front_insert(L,2,99);//新结点插入第i个位置
    print_list(L);//链表打印

    return 0;
}

测试结果

3 4 5 6 7 9999
  3  4  5  6  7
  3 99  4  5  6  7

七、单链表的删除操作

删除链表的第i个结点
定义头指针
尾插法新建链表
要删除第i个位置
通过GetElem按位置查找
拿到第i-1个元素位置地址
删除i结点并释放空间

删除结点代码

p->next=q->next;//p指向i-1，q指向要删除的结点i
free(q);//释放删除的结点i的空间
删除第i个结点
#include <stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

//LNode*是结构体指针，和LinkList完全等价的
//尾插法新建链表
void list_tail_insert(LNode* &L)
{
    L= (LinkList)malloc(sizeof(LNode));//申请头节点空间,头指针指向头节点
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾结点的next指针
        r=s;//r要指向新的尾部
        scanf("%d",&x);
    }
    r->next=NULL;//让尾结点的next为null

}


void print_list(LinkList L)
{
    L=L->next;
    while(L !=NULL )
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}

//按照位置查找
LinkList GetElem(LinkList L,int search_pos)
{
    int i=0;//从0开始遍历
    if(search_pos<0)
    {
        return NULL;
    }
    while(L&&i<search_pos)
    {
        L=L->next;
        i++;
    }
    return L;
}


//删除第i个位置的元素
//删除时L是不会变的，所以不需要加引用
bool list_delete(LinkList L,int i)
{
    LinkList p= GetElem(L,i-1);
    if(p==NULL)
    {
        return false;
    }
    LinkList q=p->next;//拿到要删除的结点指针
    p->next=q->next;//断链
    free(q);//释放被删除结点的空间
    return true;
}

//尾插法新建链表
int main() {
    LinkList L,search;//链表头指针，是结构体指针类型
    list_tail_insert(L);//输入数据可以为3 4 5 7 9999，尾插法新建链表
    print_list(L);//链表打印
    printf("set up succeeded!\n");

    list_delete(L,4);//删除第4个元素
    print_list(L);//链表打印
    printf("delete succeeded!\n");

    return 0;
}

测试结果

3 4 5 6 7 9999
  3  4  5  6  7
set up succeeded!
  3  4  5  7
delete succeeded!
克里斯提李
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构线性表
m0_67012811的博客
07-14 380
本文主要介绍了线性表，线性表有哪几种，线性表的实现方法，线性表的应用场景有哪些
数据结构线性表基本操作
热门推荐
lizhi20210729的博客
11-20 1万+
数据结构线性表基本操作基本内容线性表的顺序表示和实现线性表的顺序存储表示顺序表中基本操作的实现 基本内容 因为第一次数据结构阶段考写代码又想规范写又写不出规范的可读性强的代码，让我第一次意识到自己应该在这方面下一些功夫。这篇文章是记录自己把书上写的算法打到电脑上遇到的问题。 线性表的顺序表示和实现 线性表的顺序存储表示 将书中代码复刻如下： #define MAXSIZE 100//顺序表可能达到的最大长度 typedef struct { ElemType *elem;//储存空间的基地址
数据结构 线性表
qq_52847866的博客
06-14 1469
其中，数组实现的线性表具有随机访问的优势，可以通过索引直接访问元素，而链表实现的线性表具有动态插入和删除的优势。哈希表：哈希表是一种基于数组的线性表，通过哈希函数将关键字映射到数组的索引位置，用于高效地查找、插入和删除元素。链表：链表是一种链式存储的线性表，适用于频繁插入和删除元素的场景。这些只是线性表在各个领域中的一些应用示例，实际上线性表作为一种基础数据结构，几乎在所有计算机科学和软件开发的领域中都有广泛的应用。，并实现了初始化、获取长度、判断是否为空、获取元素、插入元素、删除元素和输出线性表的函数。
c语言数据结构线性表创建删除插入
06-30
本主题聚焦于C语言中的数据结构——线性表，这是数据结构的基础概念之一，适用于初学者学习。线性表是一种逻辑上一维、元素之间具有线性关系的数据结构。下面将详细阐述线性表的创建、删除和插入操作。 1. **线性表...
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 491
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构——复杂度
2401_82924480的博客
07-14 724
数据结构——复杂度
数据结构之顺序表
m0_73634434的博客
07-10 430
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 619
递归算法，爬楼梯等解法
数据结构初阶(C语言）-复杂度的介绍
xiuwoaiailixiya的博客
07-14 756
在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运行时间。时 间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运行时间呢？1. 因为程序运行时间和编译环境和运行机器的配置都有关系，比如同⼀个算法程序，用⼀个老编译 器进行编译和新编译器编译，在同样机器下运行时间不同。2. 同⼀个算法程序，用⼀个老低配置机器和新高配置机器，运行时间也不同。3. 并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。
【排序 - 堆排序】
2302_80393814的博客
07-10 473
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 237
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
【数据结构】手写快速排序
qq_59143106的博客
07-14 155
什么是快速排序？首先确立pivot，比如下图位于末尾然后i遍历3到6在3的时候，j指向i前面一位如果3
代码随想录第十二天|226.翻转二叉树、 101.对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度
semirc9的博客
07-09 782
二叉树
【Java--数据结构】栈的应用
最新发布
2301_80898480的博客
07-14 382
如有错误，欢迎指出~
（9）Python 数据结构：构建高效算法与金融应用的基石
架构筑梦的Cherry Yang的博客
07-14 417
当我们谈论数据结构时，我们实际上是在探讨一种组织、存储和管理数据的系统方法。在编程中，数据结构的选择对程序的性能、可读性和可维护性都有着深远的影响。Python，作为一种功能强大且易于学习的编程语言，提供了丰富的数据结构供我们使用。
数据结构线性表完成版示例
05-16
数据结构线性表完成版示例

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值