【初阶数据结构】二、C语言实现顺序表

已于 2022-08-24 01:34:18 修改
阅读量1.1k 收藏 29
点赞数 36
分类专栏： 数据结构 文章标签： 数据结构
于 2021-10-18 01:01:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58124165/article/details/120775573
版权

文章目录

一、线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

接下来，我们进入今天的主讲内容：顺序表

二、顺序表

1、概念及结构

何为顺序表？
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

简单理解：顺序表就是数组，但是在数组的基础上，还要求数据是从头开始存并且连续存储的，不能有跳跃间隔

顺序表一般可以分为：
1.静态顺序表：使用定长数组存储元素

 顺序表的静态存储
#define N 100
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType array[N]; // 定长数组
	size_t size; // 有效数据的个数
}SeqList;

图示：
在这里插入图片描述

2.动态顺序表：使用动态开辟的数组存储

顺序表的动态存储
typedef struct SeqList
{
	SLDataType* array;   // 指向动态开辟的数组
	size_t size ;        // 有效数据个数
	size_t capicity ;   // 容量空间的大小
}SeqList;

图示：
在这里插入图片描述
这两种哪个更好一点呢？

  • 静态顺序表

只适用于确定知道需要存多少数据的场景
局限：静态顺序表的定长数组，若N定大了，空间开多了浪费，若N定小了不够用。

  • 动态顺序表

现实使用时多采用动态顺序表
优势：需要多少用多少

2、顺序表接口的实现

我们以vs2019为环境搭建顺序表工程

  • 创建一个SeqList.h顺序表头文件
  • 创建一个SeqList.c顺序表实现文件
  • 创建一个test.c测试文件
    在这里插入图片描述
    说明：
  • SeqList.h头文件用来创建顺序表,和一些函数方法的声明
  • SeqList.c文件用来实现顺序表函数的定义
  • test.c文件用来测试每次实现一个函数后是否成功

2.1 顺序表的创建

我们以整型顺序表为例:

//静态版本的顺序表
#define N 1000 //方便以后修改大小
struct SeqList
{
	int a[N];
	int size;//表示数组中存储了多少个有效数据
};

//动态版本的顺序表
struct SeqList
{
    int* a;     	//动态开辟数组.
    int size;       //表示数组中已存储了多少个数据
    int capacity;   //数组实际能存数据的空间容量是多大
};

上面就是我们创建的两种形式的顺序表，我们会以实现动态顺序表为例（静态顺序表可以依法炮制~）。

看到上面定义的顺序表，其实还有一个小小的问题，就是当我们不再需要整型，而是要换成其他类型，那就需要去改int，要知道一个项目里，当用到结构体次数过多时，我们则需要一个个的去修改，这样太麻烦。

那有没有很好的办法解决呢? 有,那就是typedef.
修改如下：

typedef int SLDataType
//动态顺序表
typedef struct SeqList
{
	SLDataType* a;		//动态开辟数组.
	int size;			//表示数组中已存储了多少个数据
	int capacity;		//数组实际能存数据的空间容量是多大
}SL;//将结构体也重命名，后面定义结构体变量也方便。

这样的话,以后如果不需要int型,我们就可以直接修改typedef定义的int,非常便捷

定义好后,我们该将这段程序放在哪里呢?
上面已经讲解了：SeqList.h头文件用来创建顺序表,和一些函数方法的声明
所以我们将它放在SeqList.h头文件中.

2.2 顺序表的初始化SeqListInit

//顺序表的初始化
void SeqListInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

我们将其定义好后，怎么放呢？
SeqList.h中放程序初始化声明: void SeqListInit(SL* ps);
SeqList.c中放上面的函数定义.

2.3 顺序表的尾插SeqListPushBack

什么叫做尾插呢？请看下面一副动图：
在这里插入图片描述
顾名思义,尾插,即在最后面插入.接下来我们看看是如何实现的。

在SeqList.h文件中声明

//顺序表的尾插
void SeqListPushBack(SL* ps, SLDataType x);

在SeqList.c文件中定义

//顺序表的尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//如果没有空间或者空间不足，我们就扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);//结束程序--异常退出
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->size] = x;
	ps->size++;
}

2.4 顺序表的尾删SeqListPopBack

我们了解尾插是如何进行的之后，就可以了解尾删了，顾名思义,尾删,即从最后面开始删除数据.如图：
尾删

接下来我们看看是如何实现的。
在SeqList.h文件中声明

//顺序表的尾删
void SeqListPopBack(SL* ps, SLDataType x);

在SeqList.c文件中定义

//顺序表的尾删
void SeqListPopBack(SL* ps, SLDataType x)
{
	assert(ps);
	//温柔的方式
	//if (ps->size > 0)//防止越界，当数组中的数据全部删除之后，不可在删
	//{
	// 	//ps->a[ps->size - 1] = 0;//这一句可以不要
	//	ps->size--;
	//}

	//暴力的方式
	assert(ps->size > 0);//断言
	ps->size--;
}

2.5 顺序表的打印SeqListPrint

打印就非常简单了，如下:
在SeqList.h文件中声明

//顺序表的打印
void SeqListPrint(SL* ps);

在SeqList.c文件中定义

//顺序表的打印
void SeqListPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

2.6 顺序表的销毁SeqListDestory

我们都知道，当我们向内存申请了一块内存空间后，若我们不再使用，则需要归还系统，不然会造成内存泄漏等问题。
在SeqList.h中声明

//顺序表的销毁
void SeqListDestory(SL* ps);

在SeqList.c中定义

//顺序表的销毁
void SeqListDestory(SL* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

我们完成上面这些接口之后，就可以进行一下测试了，如下：
在这里插入图片描述

2.7 顺序表的头插SeqListPushFront

头插演示：
请添加图片描述

在SeqList.h中声明

//顺序表的头插
void SeqListPushFront(SL* ps, SLDataType x);

在SeqList.c中定义

//顺序表的头插
void SeqListPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	//如果没有空间或者空间不足，我们就扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);//结束程序--异常退出
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	//挪动数据
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

2.8 顺序表的增容SeqListCheckCapacity

由于我们无论是在进行尾插还是头插，都必须检查顺序表的容量是否足够，若不够，则需要进行增容，所以我们将顺序表的检查增容单独写成一个函数，我们只需在尾插和头插时调用它即可。如下：
在SeqList.h中声明

//顺序表检查增容
void SeqListCheckCapacity(SL* ps);

在SeqList.c中定义

//顺序表检查增容
void SeqListCheckCapacity(SL* ps)
{
	//如果没有空间或者空间不足，我们就扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);//结束程序--异常退出
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

2.9 顺序表的头删SeqListPopFront

头删演示：
请添加图片描述

在SeqList.h中声明

//顺序表的头删
void SeqListPopFront(SL* ps, SLDataType x);

在SeqList.c中定义

//顺序表的头删
void SeqListPopFront(SL* ps, SLDataType x)
{
	assert(ps);
	assert(ps->size > 0);
	int begin = 1;//把第二个元素的下标赋给begin,这样到了size的位置的时候就可停止
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

这里我们来测试一下头插与头删是否成功：
在这里插入图片描述

2.10 顺序表之查找元素SeqListFind

在SeqList.h中声明

// 顺序表查找
int SeqListFind(SL* ps, SLDataType x);

在SeqList.c中定义

//顺序表之查找元素,找到返回下标，没找到返回-1
int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

2.11 顺序表之在指定位置插入元素SeqListInsert

思路：

  1. 输入指定下标, 想要插入的元素,就在此下标位置插入
  2. 实现方法: 输入的下标位置及其后,所有数据都往后面挪
  3. 然后插入数据,size加1

在SeqList.h中声明

//在指定下标位置插入
void SeqListInsert(SL* ps, size_t pos, SLDataType x);

在SeqList.c中定义

//在指定下标位置插入
void SeqListInsert(SL* ps, size_t pos, SLDataType x)
{
	assert(ps);
	//在插入之前需判断pos的位置是否符合顺序表的特征(必须保持连续)

	//温柔处理方式
	//if (pos > ps->size || pos < 0)
	//{
	//	printf("pos invalid\n");
	//	return;
	//}
	
	//暴力处理方式
	assert(pos <= ps->size);
	//插入数据之前需要判断是否需要扩容
	SeqListCheckCapacity(ps);
	
	size_t end = ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end-1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

2.12 顺序表之删除指定位置的数据SeqListErase

在SeqList.h中声明

//删除指定位置的数据
void SeqListErase(SL* ps, size_t pos);

在SeqList.c中定义

//删除指定位置的数据
void SeqListErase(SL* ps, size_t pos)
{
	assert(ps);
	assert(pos < ps->size);

	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

三、综合

SeqList.h

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

//#define N 1000 //方便以后修改大小
//静态顺序表 
//struct SeqList
//{
//	int a[N];
//	int size;//表示数组中存储了多少个有效数据
//};

//动态顺序表
typedef int SLDataType;//方便后期修改数据类型

typedef struct SeqList
{
	SLDataType* a;		//动态开辟数组.
	int size;			//表示数组中已存储的数据个数
	int capacity;		//数组实际能存数据的空间容量
}SL;//将结构体也重命名，后面定义结构体变量也方便。


//顺序表的打印
void SeqListPrint(SL* ps);
//顺序表的初始化
void SeqListInit(SL* ps);
//顺序表的销毁
void SeqListDestory(SL* ps);
//顺序表检查增容
void SeqListCheckCapacity(SL* ps);
//顺序表的尾插
void SeqListPushBack(SL* ps, SLDataType x);
//顺序表的尾删
void SeqListPopBack(SL* ps, SLDataType x);
//顺序表的头插
void SeqListPushFront(SL* ps, SLDataType x);
//顺序表的头删
void SeqListPopFront(SL* ps, SLDataType x);

// 顺序表查找
int SeqListFind(SL* ps, SLDataType x);

//在指定下标位置插入
void SeqListInsert(SL* ps, size_t pos, SLDataType x);

//删除指定位置的数据
void SeqListErase(SL* ps, size_t pos);

SeqList.c

#include "SeqList.h"

//顺序表的初始化
void SeqListInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

//顺序表的销毁
void SeqListDestory(SL* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

//顺序表的打印
void SeqListPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

//顺序表检查增容
void SeqListCheckCapacity(SL* ps)
{
	//如果没有空间或者空间不足，我们就扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);//结束程序--异常退出
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

//顺序表的尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
	//assert(ps);
	//SeqListCheckCapacity(ps);
	//ps->a[ps->size] = x;
	//ps->size++;

	//代码复用
	SeqListInsert(ps, ps->size, x);
}

//顺序表的尾删
void SeqListPopBack(SL* ps, SLDataType x)
{
	//assert(ps);
	
	//温柔的方式
	//if (ps->size > 0)//防止越界，当数组中的数据全部删除之后，不可在删
	//{
	//	ps->size--;
	//}

	//暴力的方式
	//assert(ps->size > 0);
	//ps->size--;

	//代码复用
	SeqListErase(ps, ps->size-1);
}


//顺序表的头插
void SeqListPushFront(SL* ps, SLDataType x)
{
	//assert(ps);
	//SeqListCheckCapacity(ps);
	
	//挪动数据
	//int end = ps->size - 1;//将最后一个数的下标赋给end
	//while (end >= 0)
	//{
	//	ps->a[end + 1] = ps->a[end];
	//	end--;
	//}
	//ps->a[0] = x;
	//ps->size++;

	//代码复用
	SeqListInsert(ps, 0, x);
}

//顺序表的头删
void SeqListPopFront(SL* ps, SLDataType x)
{
	//assert(ps);
	//assert(ps->size > 0);
	//int begin = 1;
	//while (begin < ps->size)
	//{
	//	ps->a[begin - 1] = ps->a[begin];
	//	begin++;
	//}
	//ps->size--;

	//代码复用
	SeqListErase(ps, 0);
}



//顺序表之查找元素,找到返回下标，没找到返回-1
int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//在指定下标位置插入
void SeqListInsert(SL* ps, size_t pos, SLDataType x)
{
	assert(ps);
	//判断pos的位置是否符合顺序表的特征(必须保持连续)

	//温柔处理方式
	//if (pos > ps->size || pos < 0)
	//{
	//	printf("pos invalid\n");
	//	return;
	//}
	
	//暴力处理方式
	assert(pos <= ps->size);
	SeqListCheckCapacity(ps);
	size_t end = ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

//删除指定位置的数据
void SeqListErase(SL* ps, size_t pos)
{
	assert(ps);
	assert(pos < ps->size);

	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}
Clumsy、笨拙
关注
专栏目录
数据结构（初阶）—— C语言实现顺序表
M的博客
03-31 7599
顺序表各种接口实现
【数据结构初阶】C语言实现动态顺序表
green_tangerine的博客
07-12 1016
对哪块空间增加地址 增加多少字节的空间(realloc第二个参数是size_t类型)，应该申请4个整型大小(16字节)的空间。动态申请空间可能失败，可能成功，realloc如果申请空间失败 会返回NULL，导致顺序表里的所有数据都清空了，空间不够：先增容 (一般两倍) ，然后在size指向的位置插入一个数据，再size++数据是一块一块的，用指针链接起来（java中用引用来链接) - - 空间是不连续的。Seq：是sequnce的缩写，意思为流畅的，流利的。
『初阶数据结构 • C语言』⑦ - 静态顺序表详解（附完整源码）
花想云的博客
01-12 1536
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
数据结构初阶之顺序表（C语言）
Britney_dark的博客
04-03 5526
一. 顺序表分类 静态顺序表 动态顺序表 静态顺序表：使用定长数组存储元素 动态顺序表：使用动态开辟的数组存储 二. 接口实现 静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪 费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实 现动态顺序表。 将要实现的功能： 基本的增删查改，包括： 初始化，检查空间，尾插，头插，尾删，头插，头删，查找，在指定位置插入，删除指定位置的值，销毁，打印 //
4.2初阶数据结构(c语言)(顺序表)
m0_73345579的博客
02-06 478
代码+注释+练习题+简单分析
【数据结构初阶】二、 线性表里的顺序表（C语言实现顺序表）
正在努力学C呀！（要学好久呢......）
09-08 4499
线性表里的顺序表：1 . 线性表 ； 2 . 顺序表 ； 3 .接口实现(实现动态顺序表) ；4 . 对应代码
数据结构初阶之顺序表（C语言实现）
wszhj_的博客
12-28 1220
顺序表是数据结构里面很基础的一类，它是线性表的一种，其它线性表还有链表、栈和队列等，今天来和博主一起学习关于顺序表的知识吧。接下来将为大家带来一篇《不一样的C语言之easyx库的使用》，敬请期待吧。下面是本篇博客的思维导图希望对您有所帮助。
【初阶数据结构】深入解析顺序表:探索底层逻辑
大一在读，博客主要分享C/C++方向相关的内容，欢迎关注我的博主，希望可以跟各位大佬深入学习！
06-11 3650
本篇将深入解析顺序表:探索底层逻辑，理解底层是如何实现并了解该接口实现的优缺点，以便于我们在编写程序灵活地使用该数据结构。
『初阶数据结构 • C语言』⑧ - 动态顺序表详解（附完整源码）
花想云的博客
01-13 1498
上一章我们学习了静态顺序表的增删查改，并认识了静态顺序表的存储结构与静态顺序表的在不同场景下的优劣。静态顺序表与动态顺序表都叫做顺序表，只不过我们平时口头所提的顺序表指的是动态顺序表。
C语言实现数据结构算法初阶算法
06-15
C语言作为底层编程的首选语言，它提供了直接操作内存的灵活性，因此用C语言实现数据结构和算法可以深入理解这些概念的本质。下面将详细介绍标题和描述中提到的几个核心知识点。 1. **顺序表**：顺序表是一种基本的...
C语言初阶-(单向链表)
03-08
适用于数据结构初学者使用 线性表的单链表存储结构，整个链表的存取必须从头指针开始进行，头指针指示链表中第一个结点 (第一个数据元素的存储映像，也称首元结点)的存储位置。同时，由于最后一个数据元素没有 直接...
【数据结构】-- 线性表之顺序表
无蒽的博客
06-03 493
这节我们正式开始数据结构初阶的第一讲 ----线性表之顺序表
【数据结构初阶】顺序表
m0_60624580的博客
10-25 2306
前言前言线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表的数据在存储的时候是成一条线性相互紧邻存放的。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，是连续的一条直线。但是在物理结构上（内存）并不一定是连续的。线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是在物理上是线性连续的，链表是不连续的。
从入门到精通数据结构----栈与队列
2405_85784684的博客
10-30 691
本篇文章是对于我在学习栈与队列的时的思考与总结。数据结构知识定义了一些特定的用法，但是对于如何实现并没有确定的模板。本篇文章是展示站与队列的其中一种写法(以c++的STL库为参考)
数据结构与算法——树与二叉树
2301_80888963的博客
10-28 910
树与二叉树
【高阶数据结构】红黑树的插入
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
10-29 803
超多精美配图讲解红黑树的插入方法；红黑树的插入C++完整代码的实现。
数据结构+算法分析与设计［19-21年真题版］
mufengzhiyu666的博客
10-29 233
八、设有一组关键字{19，01，23，14，55，20，84，27，68，11，10，77}，采用哈希函数： H(Key)=Key MOD 13， 采用开放地址法的线性探测再散列方法解决冲突，试在0～18的散列地址空间中对该关键字序列构造哈希表。八、依次输入表（30，15，28，20，24，10，12，68，35，50，46，55）中的元素，生成一棵二叉树排序树。七、给出一组关键字（29，18，25，47，58，12，51，10），分别写出按下列各种排序方法进行排序时的变化过程： （15分）
Redis的数据结构
2302_81083129的博客
10-31 559
缓存穿透、缓存雪崩、缓存击穿、Redis的数据结构及常用命令
【数据结构与算法】第7课—数据结构之队列
最新发布
weixin_70620792的博客
10-31 227
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表栈只允许在栈顶进行插入数据删除数据的操作，称为入栈、出栈（或压栈）队列则是队尾进队头出，满足先进先出的原则，而栈则是后进先出。
掌握C/C++实现的初阶与高阶数据结构
在C语言中实现初阶数据结构，通常需要对内存管理有较为深入的理解，因为C语言本身不提供类和对象的概念，需要手动管理内存，如动态分配和释放内存空间。例如： - 数组的实现需要确定数组大小，并通过索引直接访问...
评论 27
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Clumsy、笨拙

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值