线性表(逻辑结构)--链表(存储结构)

最新推荐文章于 2023-03-09 23:19:22 发布
最新推荐文章于 2023-03-09 23:19:22 发布
阅读量808 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39280437/article/details/118735022
版权

链表

单链表

每个节点除去存放数据元素外，还需存储指向下一个节点的指针

定义

struct LNode{
	ElementType data;
	struct LNode *next;
};

//增加一个新的节点，在内存中申请新的节点所需要的空间，并用指针P指向这个节点
struct Lnode *p = (struct LNode *)malloc(sizeof(struct LNode));

//用typedef实现结构体的重命名，方便声明结构体类型的节点
typedef struct LNode LNode;
typedef struct Lnode *LinkList;
//后续声明只需要用LNode来代替struct LNode
LNode *p = (LNode *)malloc(sizeof(LNode));	

//上面两步也可以合并来完成
typedef struct LNode{
	EleType data;
	struct LNode *next;
}LNode,*LinkList;
//其中LNode是结构体类型，LinkList是指针类型
Lnode *p = (LNode *)malloc(sizeof(LNode));
LinkList q = (LinkList)malloc(sizeof(Lndoe));

LNode和LinkList本质上只是结构体类型和结构体的指针类型，但在使用时可以用LNode表示节点，用LinkList表示单链表更容易逻辑清晰。

例如在实现获取链表中第i个元素的函数中

//返回类型为LNode *突出返回的是一个节点
//入参类型LintList强调传入的是单链表
LNode *GetElementInLinkList(LinkList L,int i){
	if(i < 1)
		return NULL;
	else if(i = 1)
		return L;
	else
	{
		LNode *p = L;
		for(int j = 0;j < i&&p!=NULL;j++){
			p = p -> next;
		}
		return p;
	}
}

实现

不带头节点

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;

//初始化一个空的链表
bool InitList(LinkList &L){
	L = NULL;
	return true;
}

带头节点

带头结点可以用相同的代码逻辑处理第一个数据点和后续的数据点

typedef struct LNode{
	int data;
	struct LNode *next;
}Lnode, *LinkList;

//初始化一个单链表（带头节点）
bool InitList(LinkList &L){
	L = (LNode)malloc(sizeof(LNode));
	if(L == NULL)
		return false;//malloc分配内存空间失败
	L -> next = NULL;
	return ture; 
}

基本操作的实现

插入

按位序插入
  • 带头节点
  • 不带头节点

在第i个位置插入指定的元素e

//带头节点
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList &L,int i,int e){
	LNode *p;
	p = L;//p指向L指向的地址
	if(i < 1)
		return false;
	for(int j = 0;j < i - 1 && L != NULL;j++){
		p = p -> next;
	}
	if(p == NULL)
		return false;
	LNode *q =(LNode)malloc(sizeof(Lnode));
	q -> data = e;
	q -> next = p -> next;
	p -> next = q;
	return true;
}

上述代码没有改变L的指向，传入指针的地址看起来是危险且复杂的，做如下修改

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList p,int i,int e){
	if(i < 1)
		return false;
	for(int j = 0;j < i - 1 && L != NULL;j++){
		p = p -> next;
	} 
	if(p == NULL)
		return false;
	LNode *q =(LNode)malloc(sizeof(Lnode));
	q -> data = e;
	q -> next = p -> next;
	p -> next = q;
	return true;
}

这样做减少了用到的变量，且不用进行结构体指针的地址运算。
时间复杂度非常容易得出
最小O(1)
最大O(n)
平均O(n)
当不带头节点时，NodeList的指向是可能发生变化的，所以需要传入指针的地址改变其指向

//不带头节点
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList &L,int i,int e){
	if(i == 1){
		LNode *h = (LNode *)malloc(sizeof(LNode));
		if(h == NULL)
			return false;
		h -> data = e;
		h -> next = L;
		&L = &h;
		return true;
	}
	LNode *p;
	p = L;//p指向L指向的地址
	if(i < 1)
		return false;
	for(int j = 0;j < i - 1 && L != NULL;j++){
		p = p -> next;
	}
	if(p == NULL)
		return false;
	LNode *q =(LNode *)malloc(sizeof(Lnode));
	if(q ==NULL)
		return false;
	q -> data = e;
	q -> next = p -> next;
	p -> next = q;
	return true;
}
指定节点的后插操作
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
//在p节点后插入
bool InsertNextNode(LNode *p,int e){
	if(p == NULL)
		return false;
	LNode *s = (LNode *)(malloc(sizeof(LNode));
	s -> data = e;
	s -> next = p -> next;
	p -> next = s;
	return true;
}
//
指定节点的前插操作

如果用在节点的前驱节点后插入的想法去实现，就会使实现非常困难，在此用到一个非常巧妙的方法，值交换

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
//在p节点前插入(先后插再交换值)
bool InsertNextNode(LNode *p,int e){
	if(p == NULL)
		return false;
	LNode *s = (LNode *)(malloc(sizeof(LNode));
	s -> next = p ->next;
	p -> next = s;
	s -> value = p;
	p -> value = e;
	return true;
}

删除

按位序删除
//按位序删除（带头节点）
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
bool Delete(LinkList L,int i,int &e){
	if(i < 1)
		return false;
	for(int j = 0; j < i - 1 && L != NULL; j++){
		L = L->next;
	}
	if( L == NULL)
		return false;
	LNode p = (LNode *)malloc(sizeof(LNode));
	p = L -> next;
	if( p == NULL)
		return false;
	e = p -> data;
	L -> next = p -> next;
	free(p);
	return true;
}
指定节点的删除
typedef struct LNode{
	ElementType data;
	struct LNode;	
}LNode,*LinkList;
bool Delete(LNode *p){
	LNode *q = p -> next;
	if(*q == NULL){
		free(p);
		return true;
	}	
	p -> data = q -> data;
	p -> next = q -> next;
	free(q);
	return true;
}

查找

按位查找
typedef struct LNode{
	elementType data;
	struct LNode *next;
}LNode, *LinkList;
//按位查找，返回第i位元素（带头节点）
LNode *GetElem(LinkList L,int i){
	if( i < 1 )
		return NULL;
	for(int j = 0;j < i - 1 && L != NULL;j++){
		L = L -> next;
	}
	return  L;
}
按值查找
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
LNode *GetElem(LinkList L,int e){
	for(;L != NULL&& L -> data != e;L = L->next);
	return L;
}

求表长

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;

//带头节点
int Length(LinkList L){
	int len = 0;
	for(;L -> next != NULL;len ++);
	return len; 
}

建立

尾插法
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;

//带头节点，初始化
bool InitList(LinkList &L){
	L = (LNode *)malloc(sizeof(LNode));
	if(L == NULL)
		return false;
	L -> next = NULL;
	return true;
}

//后插法带头节点不初始化
LinkList ListTailInsert(LinkList L){
	LNode *head = L;
	LNode *p = (LNode *)malloc(sizeof(LNode));
	p -> next = NULL;
	int x;
	scanf("%d",&x);
	while(x!=9999){
		LNode *p = (LNode *)malloc(sizeof(LNode));
		p -> data = x;
	    L -> next = p;
	    L = p;
	    scanf("%d",&x);	
	}
	return head;
}
头插法
//头插法带头节点带初始化
LintList ListHeadInsert(){
	LNode *L = (LNode *)malloc(sizeof(LNode));
	L -> next = NULL;
	int x;
	scanf("%d",&x);
	while(x != 9999){
		LNode *p = (LNode *)malloc(sizeof(LNode));
		p -> data = x;
		p -> next = L -> next;
		L -> next = p;
		scanf("%d",&x);
	} 
	return L;
}
头插法的应用，列表的逆转
typedef truct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
LinkList reverOrder(LinkList oriList){ 
	LinkList L = (LinkList) malloc(sizeof(LNode));
	p -> value = 
	L -> next = null;
	oriList = oriList -> next;
	while(oriList != NULL){
		LNode *p = (LNode *)malloc(sizeof(LNode));
		p -> value = oriList -> value;
		p -> next = L -> next;
		L -> next = p;
		oriList = oriList -> next;
	}
	return L;
}

双链表

每个节点有前驱和后继

typedef struct DNode{
	ElemType data;
	struct LNode *prior,*next;
}DNode, *DLinkList;

初始化

//有头节点
typedef struct DNode{
	ElemType data;
	struct Lnode *prior,*next;
}DNode, *DLinkList;

bool InitDLL(DLinkList &L){
	L = (DNode *)malloc(sizeof(DNode));
	if(L == NULL)
		return false;
	h -> prior = NULL;
	h -> next = NULL;
	return ture;
}

//判空
bool Empty(DLinkList L){
	if(L -> next == NULL)
		return ture;
	return false;
}

插入

//在p节点后插入s节点
bool InsertNextDNode(DNode *p,DNode *s){
	if(p == NULL && s == NULL)	
	return false;
	if( p -> next != NULL)
		p -> next -> prior = s;
	s -> next = p -> next;
	s -> prior = p;
	p -> next = s;   
	return true;
}

删除

typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}DNode,DLinkList;
//删除p节点的后继节点
bool DeleteNextDNode(DNode *p){
	if( p == NULL )return false;
	if( p -> next == NULL)return false;
	DNode *d = p -> next;
	p -> next = d -> next;
	if( d -> next != NULL)
		d -> next -> prior = p;
	free(d);
	return true;
}
//销毁表
void Destroy(DLinkList &L){
	while(L -> next != NULL)
		DeleteNextDNode(L);
	free(L);
	L = NULL;
}

遍历

typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}DNode,DLinkList;
bool NextTraver(DNode *p){
	if( p == NULL|| p -> next == NUL)return false;
	while(p -> next != NULL){
		p = p-> next;
	}
	return true;
}
bool PriorTraver(DNode *p){
	if(p == NULL || p -> next == NULL || p -> next -> next == NULL)return false;
	while(p -> front -> front != NULL){
		p = p-> prior;
	}
	return true;
}

循环链表

循环单链表

typedef struct LNode{
	ElemType data;
	struct LNode *next;
} LNode,*LinkList;

//初始化一个循环单链表
bool InitList(LinkList &L){
	L = (LNode *)malloc(sizeof(LNode));
	if( L == NULL)return false;
	L -> next = L;
	return true;
}

//判断表尾
bool IsTail(LinkList L,LNode *p){
	if( p -> next == L)return true;
	return false;
}

循环双链表

typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}

//初始化循环双链表
bool InitDLL(DLinkList &L){
	L = (DNode *)malloc(sizeof(DNode));
	if(L == NULL)return false;
	L -> prior = L;
	L -> next =L;
	return true;
}

//判空
bool Empty(DLinkList L){
	if(L -> next == L)return true;
	return false;
}

//判断表尾
bool IsTail(DLinkList L,DNode *p){
	if(p -> next == L)return true;
	return false;
}

//在p后插入s
bool InsertCirDLL(DNode *p,DNode *s){
	if(p == NULL||s == NULL)return false;
	p -> next -> prior = s;
	
}

静态链表

单链表：各个节点在内存中星罗棋布，散落天涯。

静态链表：分配一整片连续的内存空间，各个节点集中安置（顺序表？）

静态链表的节点：

  • 数据项
  • 下一个元素的下标

定义及基本操作

#define MaxSize 10		//静态链表的最大长度
typedef struct {		//静态链表结构类型的定义
	Element data;		//存储数据元素
	int next;			//下一个元素的数组下标
}SLinkList[MaxSize];	
SLinkList L;
//初始化（head->next设为-1 el -> next设为-2）
bool Init(SLinkList L){
	if( L == NULL)return false;
	L[0] -> next = -1;
	for (int i = 1;i < MaxSize ;i++)
		L[i] -> next = -2;
	return ture;
}

顺序表和链表的比较

逻辑结构

都是线性表，都是线性结构

物理结构

  • 顺序表
    顺序存储
    优点：支持随机存取，存储密度高
    缺点：大片连续空间分配不方便，改变容量不方便
  • 链表
    链式存储
    优点：离散的小空间分配方便，改变容量方便
    缺点：不可随机存取，存储密度低

数据的运算/基本操作

创销、增删改查

创建

  • 顺序表
    需要分配一大片连续空间（数组）
  • 链表
    只需分配一个头节点，之后方便扩展

静态分配：静态数组（容量不可变）
动态分配：动态数组（malloc、free）容量可改变，但需要移动大量元素，时间成本高

销毁

  • 顺序表
    修改length = 0
    静态分配：系统自动回收
    动态分配：需要手动free
  • 链表
    依次删除各个节点（free）

增删

  • 顺序表
    时间复杂度O(n)，时间开销来自于移动每一项后续的数据元素，如果数据元素很大，则开销巨大
  • 链表
    时间复杂度O(N)，时间开销来自于查找前驱元素，查找后只需要修改指针即可。

改查

按位查找
  • 顺序表
    时间复杂度O(1)
  • 链表
    时间复杂度O(n)
按值查找
  • 顺序表
    遍历：时间复杂度O(n)
    若表内元素有序，可以二分查找
    二分查找：时间复杂度O(log(2,n))
  • 链表
    时间复杂度：O(n)

选择

  • 顺序表
    表长可预估，查询搜索操纵较多（增删操作较少）
  • 链表
    表长难以估计，经常增删元素

答题模板

问题：巴拉巴拉，用顺序表还是链表好？
顺序表和链表的逻辑结构都是线性结构，都属于线性表。
但是两者的存储结构不同，线性表采用顺序存储，支持随机存取，存储密度高，但大片连续内存空间分配不方便，扩容不方便；链表采用链式存储，离散的小空间分配方便，扩容方便，但不可随机存取，存储密度低。
由于采用不同的存储方式实现，因此基本操作的实现效率不同。当初始化时…，当插入数据元素时…，当删除一个数据元素时…，当查找一个数据元素时…。

西西阿西哥
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之线性表(顺序表与链表)--王道
weixin_64144469的博客
05-21 626
目录 2.1线性表的定义和基本操作 2.1.1线性表的定义 2.1.2线性表的基本操作 2.2线性表的顺序表示 2.2.1顺序表的定义 2.2.2顺序表上基本操作的实现 2.3线性表的链式表示 2.3.1单链表的定义 2.3.2单链表上基本操作的实现 1.用头插法建立单链表 2.用尾插法 3.按序号查找结点值 4.按值查找表结点 5.插入结点操作 6.删除结点操作 7.求表长操作 2.3.3双链表 1.双链表的插入 2.双链表的删除 2.3.4循环链表...
（数据结构）线性表三——链式存储结构（链表）
小黄TIMTIM仔的博客
08-12 1252
知识补充：顺序储存结构：也称为顺序表。顺序表在存储数据时，会提前找到一块足够存放这些数据的内存空间，然后将数据一个一个的存储进去。 链式存储结构：称为链表，也称为单链表。链表与顺序表不同，它可以把数据存储到不同的位置，不像顺序表只存放在一个位置上。 链式存储结构的特点：用一组任意的存储单元存储线性表的数据元素，其中这组存储单元可以是连续的，也可以是不连续的，所以这些数据元素可以存在内存未被占用的任意位置。 顺序存储结构与链式存储结构的区别：1、顺序存储结构中，每个数据元素在存储的时候只需要存储数据元素
链表-单链表内存结构、逻辑结构、特点、定义、遍历、尾插、按顺序插入、修改、删除；有效节点个数、倒数第k个元素、单链表反转、合并2个有序单链表。双向链表-定义、增删改查。单向环形链表-Joseph
qq_39497997的博客
11-14 1486
1. 单链表介绍 1.1 内存结构 从内存上看：链表的空间不连续（有别于数组） 1.2 逻辑结构 逻辑上来看：链表属于线性结构 1.3 链表特点 链表是以节点的方式来储存的，是链式结构 节点分为数据域（data）和地址域（next）；data域存放数据，next域指向下一个节点 链表分带头结点的链表和没有头结点的链表，根据实际需求确定 2. 链表定义与使用 2.1 链表节点定义 no：英雄编号 name：英雄名字 nickName：英雄昵称 next：指向下一个HeroNode节点 //
链表题目及逻辑
今天天气很好
03-09 80
刷题，leetcode
链式存储结构-链表的基本操作
mr_yuyou的博客
07-09 633
数据结构
2. 数据结构-逻辑结构-线性表
qq_52226384的博客
08-09 763
前提知识回顾和关联 有了数据结构基本知识，数据结构是数据对象的逻辑结构+存储结构+运算（增删改查）。逻辑结构有集合、线性结构、树结构、图或网状结构。 显然线性表是数据逻辑结构的线性结构。它按照循序存储和链式存储（仅仅是分类标准，别混淆之前物理存储的概念）分为顺序表和链式表，链式表主要有单链表、双链表、循环链表、静态链表。 顺序表 地址连续的存储单元存储元素的表。由一个一维数组和一个序列长度构成。 顺序表是一个数据结构，数据结构三元组是逻辑结构、存储结构、运算。它的逻辑结构就是线性结构，它的存储结构是顺序存
数据库的存储结构
王小明的专栏
10-24 7151
数据库的存储结构 数据库的存储结构是怎样的？ 记录是按照行存储的，但是数据库的读取不是以行为单位，否则一次读取只能处理一行，效率很低。因此数据库，无论是读一行，还是读取多行，都是将这些行所在的页进行加载。数据管理存储空间的基本单位是页（Page） 快速回顾一遍数据库存储结构：一页可以存储多个行记录（Row) ，先是表空间（Tablespace），表空间包含段（segement）,还存在区（Extent）,其关系如下图所示： 段（Segment）段里面有多个区，区在文件系统是一个连续的分片空间，不过在段
数据结构--线性表--思维导图.pdf
08-29
该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的关系。它具有有限的长度，元素之间...
线性表的实验--线性表的应用
11-07
链表存储结构中，每个节点包含系数、指数和指向下一个元素的指针。系统功能组成图包括多项式创建、插入、打印、比较、加减运算以及求值等功能模块。流程图则进一步详细描绘了这些操作的具体步骤。 4. 算法实现 代码...
数据结构-线性表-xmind思维导图
05-13
串、栈、队列的区分度在于数据的运算和逻辑结构，而他们的存储结构常用的都是顺序表和链表。 广义表和数组都是更抽象的线性表，数组对数据元素要求更严苛，广义表则是放开了数据元素的限定。他们都可以是递归定义，...
数据结构-链表.pdf
08-15
用顺序存储结构存储的线性表称为顺序表，用链式存储结构存储的线性表称为链表。 顺序表是一种数组式的存储结构，将线性表中的数据元素依次存放在某个存储区域中，所形成的表称为顺序表。顺序表的优点是存取速度快，...
04 2 线性表3-其它链表1
08-03
链表是线性表的链式存储表示，它的主要特点是逻辑相邻的元素在物理存储上不一定相邻。链表由一系列节点构成，每个节点包含两部分：数据域Data，用于存储元素，和指针Next，用于指向下一个节点。当链表为空时，头结点...
浅谈数据逻辑结构分类
倚树听风声的博客
05-13 1815
我们知道，数据是信息的载体，是描述客观事物属性的数、字符及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。 那么，数据元素又是数据的基本单位，通常作为一个整体进行考虑和处理。 由此，数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 一般来讲，数据结构包含三大要素：逻辑结构、存储结构、数据运算。 本文主要围绕数据结构的逻辑进行探讨，其他要素就不一一赘述。 数据逻辑结构的分类 常用的数据结构有：线性表，栈，队列，数组，串，树，图，堆八大类，如图所示： 1.线性表..
线性表的逻辑结构
bingXxx的博客
12-11 7726
线性表的定义:用数据元素的有限序列表示的表,我们称之为线性表 比如 a1,a2,a3,a4…an,其中a1就是线性表的起点,而a1中的下标1表示的就是元素的序号,它表示了这个元素在线性表中的位置,而相对a2来说它的直接前驱就是a1,而它的直接后继就是a3,而an中n表示的就是这个线性表的长度. 注意:同一个线性表具有相同的特性,相邻的数据元素之间是序偶关系(表示的就是有序成对的意思) 比如上面这...
数据结构--链表概念及常见链表结构
热门推荐
qq_35297945的博客
12-17 1万+
1 链表的概念 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表的结构由以下8种: 1、不带头单向循环结构 2、不带头单向非循环结构 3、不带头双向循环结构 4、不带头双向非循环结构 5、带头单向循环结构 6、带头单向非循环结构 7、带头双向循环结构 8、带头双向非循环结构 存储结构如下： 不带头单向循环结构 不带头单向非循环结构 不带头双向循环结构 不带头双向非循环结构 带头单向循环结构 带头单向非循环结构
数据结构：链表与逻辑问题
Kobe51920的博客
08-18 2712
优点 缺点 链表 1.用多少开多少，直接链上去，没有空间浪费 2.头尾插入效率高 O(1) 不支持随机访问，顺序访问 顺序表 1.支持随机访问,随机访问 1.增容时成倍增长，有空间浪费 2.中间或者头部插入数据时效率不高 O(N) ...
数据结构之逻辑结构
aipande143的博客
05-27 1706
1.逻辑结构 前面讲过数据结构可以分为存储结构和逻辑结构，一般情况下，我们讨论的最多的都是逻辑结构，下面介绍有哪些常用的逻辑结构。 1.1 线程结构 1.1.1数组 1.1.2
数据结构之——链表
xqx_999的博客
10-06 4195
链表的介绍，单链表和双向链表的接口实现。
线性表(逻辑结构)
weixin_39280437的博客
07-12 1534
线性表定义（逻辑结构）值得注意的特性重要术语基本运算创销、增删改查判空、判长、打印输出其它值得注意的点 定义（逻辑结构） 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L表示线性表，则一般表示为 几个概念： a_i表示线性表中第i个元素的位序；（程序中下标从零开始） a_0表示线性表的表头元素； a_n表示线性表的表尾元素； 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继 值得注意的特性 数据元素同类型、
线性表的顺序存储结构优于链表存储结构
最新发布
07-08
线性表的顺序存储结构和链表存储结构都有各自的优缺点，不能一概而论。 顺序存储结构的优点： 1. 存储密度高，每个元素都占用同样大小的存储空间，便于计算存储位置，随机访问元素非常快速。 2. 线性表长度固定，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值