数据结构002 - 线性表（顺序表）

已于 2022-04-20 18:22:14 修改
阅读量1.1k 收藏
点赞数
分类专栏： 数据结构初阶（C语言实现） 文章标签： 数据结构 算法
于 2022-04-13 16:47:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44944301/article/details/124151269
版权

1. 线性表

线性表（linear list）是 n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串 …

线性表在逻辑上是线性结构，也就说是一条连续的直线。但在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
线性表

2. 顺序表

2.1 概念及结构

顺序表是用一段 物理地址连续 的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。
顺序表要求存储的数据从下标 0 开始，依次连续存储，中间不能用空位。

顺序表一般可以分为：
1、静态顺序表：使用定长数组存储。静态顺序表的缺点是存储空间大小被固定了，只适用于知道存储数据数量的情况下。而实际中，往往并不知道这个数目。因此一般使用的是动态顺序表，按照需求动态分配空间。

#define N 100
typedef int SLDataType;

// 顺序表的静态存储
typedef struct SeqList{
	SLDataType arr[N]; // 定长数组
	int size;          // 表示数组中存储了多少个有效数据
}SeqList;

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

typedef int SLDataType;

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

2.2 顺序表的实现

静态顺序表只适用于确定知道需要存多少数据的场景。在实际中基本使用动态顺序表，根据需要，动态地分配空间大小，所以下面我们来实现动态顺序表。

顺序表代码的实现将放在三个文件中，分别是 SeqList.h（用于声明）、SeqList.c（用于定义）、Test.c（用于测试）。

2.2.1 创建、初始化顺序表

SeqList.h 文件

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

// 确保储存其它数据类型时方便改动，本文以存放整型数据为例
typedef int SLDataType;

// 创建动态顺序表
typedef struct SeqList{
	SLDataType* a; // 指向动态开辟的数组
	int size;      // 有效数据的个数
	int capacity;  // 容量空间的个数
}SeqList;

// 初始化顺序表
void SeqListInit(SeqList* ps);

SeqList.c 文件

#include "SeqList.h"

// 初始化顺序表
void SeqListInit(SeqList* ps){
	// 进行断言，当 ps 为 NULL 时，下面的操作将无法进行，因为空指针是无法进行解引用操作的
    assert(ps);
    
    ps->a = NULL;
	ps->size =0;
	ps->capacity = 0;
};

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	SeqListInit(&sl);
}

int main(){
	TestSeqList1();
	return 0;
}

2.2.2 检查顺序表是否需要扩容

检查是否达到最大容量，检查最大容量是否为 0。如果为 0 则给一个整形空间，如果不为 0 则将原来空间乘 2，同时重新创立一个指针开辟新空间来存放重新开辟的空间，如果在原来的指针里开辟失败，原指针会丢失，所以重新建立一个指针，而且开辟失败结束进程。

SeqList.h 文件

// 检测顺序表是否需要扩容
void SeqListCheckCapacity(SeqList* ps);

SeqList.c 文件

#include "SeqList.h"

// 检测顺序表是否需要扩容
void SeqListCheckCapacity(SeqList* ps) {
	assert(ps);
    
    // size 和 capacity 都为 0 或 size 与 capacity 相等时需要扩容
	if (ps->size == ps->capacity){
		// capacity 的初始容量为 0，则赋值为 4；不为 0，则扩容为 2 倍。
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = realloc(ps->a, sizeof(SLDataType) * newCapacity);
		// 如果 ps->a 为空指针，此时 realloc 相当于 malloc
		if (tmp == NULL){
			printf("realloc fail\n");
			exit(-1);
		}else{
			ps->a = tmp;
			ps->capacity = (int)newCapacity;
		}
	}
}

realloc 扩容时有两种情况：

（1）如果该段内存空间后面的空余空间够用，则直接原地扩容。
（2）如果后面空余空间不够用，会在内存中重新开辟一段空间，原来位置的数据会被迁移到这段新开辟的内存中，且会将原来的空间释放掉。迁移的过程会有时间的消耗，带来效率上的降低。

2.2.3 尾插

SeqList.h 文件

// 尾插
void SeqListPushBack(SeqList* ps, SLDataType x);

SeqList.c 文件

#include "SeqList.h"

// 尾插
void SeqListPushBack(SeqList* ps, SLDataType x){
	assert(ps);
    
    // 检测是否需要扩容
	SeqListCheckCapacity(ps);
	
	ps->a[ps->size] = x;
	ps->size++;
}

2.2.4 打印

SeqList.h 文件

// 打印
void SeqListPrint(SeqList* ps);

SeqList.c 文件

#include "SeqList.h"

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

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
    SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	// 打印
	SeqListPrint(&sl);
}

int main(){
	TestSeqList1();
	return 0;
}

运行结果：

运行结果

2.2.5 销毁

SeqList.h 文件

// 销毁
void SeqListDestory(SeqList* ps);

SeqList.c 文件

#include "SeqList.h"

// 销毁
void SeqListDestory(SeqList* ps){
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
	SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	// 打印
	SeqListPrint(&sl);
	// 销毁
	SeqListDestory(&sl);
}

int main(){
	TestSeqList1();
    
	return 0;
}

2.2.6 尾删

SeqList.h 文件

// 尾删
void SeqListPopBack(SeqList* ps);

SeqList.c 文件

#include "SeqList.h"

// 尾删
void SeqListPopBack(SeqList* ps){
	assert(ps);
	
	if (ps->size > 0){
		ps->size--;
	}
}

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
	SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	// 打印
	SeqListPrint(&sl);
	
	// 尾删
	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	// 打印
	SeqListPrint(&sl);
	// 销毁
	SeqListDestory(&sl);
}

int main(){
	TestSeqList1();

	return 0;
}

运行结果：
运行结果

2.2.7 头插

思路： 头插就是在下标为 0 的位置插入一个元素，同时把原来的元素往后挪，将第一个位置空出来，同时也要确保空间足够，空间不足需要进行扩容。

SeqList.h 文件

// 头插
void SeqListPushFront(SeqList* ps, SLDataType x);

SeqList.c 文件

#include "SeqList.h"

// 头插
void SeqListPushFront(SeqList* ps, SLDataType x){
	assert(ps);
	
    // 检测是否需要扩容
	SeqListCheckCapacity(ps);

	// 挪动数据
	int end = ps->size - 1;
	while (end >= 0){
		ps->a[end+1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
	SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	// 打印
	SeqListPrint(&sl);
	
	// 头插
	SeqListPushFront(&sl, 10);
	SeqListPushFront(&sl, 20);
	SeqListPushFront(&sl, 30);
	SeqListPushFront(&sl, 40);
	SeqListPushFront(&sl, 50);
	// 打印
	SeqListPrint(&sl);
	// 销毁
	SeqListDestory(&sl);
}

int main(){
	TestSeqList1();

	return 0;
}

运行结果：
运行结果

2.2.8 头删

思路： 头删是删除下标为 0 的元素，需要将下标为 [1, size-1] 的元素都依次向前挪动一位，同时要确保size >= 0。

SeqList.h 文件

// 头删
void SeqListPopFront(SeqList* ps);

SeqList.c 文件

#include "SeqList.h"

// 头删
void SeqListPopFront(SeqList* ps){
	assert(ps->size > 0);

	// 挪动数据
	int begin = 1;
	while (begin < ps->size){
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
	SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	// 打印
	SeqListPrint(&sl);
	
	// 头删
	SeqListPopFront(&sl);
	SeqListPopFront(&sl);
	// 打印
	SeqListPrint(&sl);
	// 销毁
	SeqListDestory(&sl);
}

int main(){
	TestSeqList1();
	
	return 0;
}

运行结果：
运行结果

2.2.9 查找

找到了返回 X 位置的下标，没有找到返回 -1。

思路： 遍历数组即可。

SeqList.h 文件

// 查找
int SeqListFind(SeqList* ps, SLDataType x);

SeqList.c 文件

#include "SeqList.h"

// 查找
int SeqListFind(SeqList* ps, SLDataType x){
	assert(ps);

	for (int i = 0; i < ps->size; i++){
		if (ps->a[i] == x){
			return i;
		}
	}
	return -1;
}

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
	SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	// 打印
	SeqListPrint(&sl);
	
	// 查找
	int pos = SeqListFind(&sl, 2);
	if (pos != -1){
		printf("找到了，下标是：%d\n", pos);
	}
	else{
		printf("找不到\n");
	}
    // 销毁
	SeqListDestory(&sl);
}

int main(){
	TestSeqList1();
	
	return 0;
}

运行结果：
运行结果

2.2.10 指定 pos 位置插入 x

思路： 在有效数据 size 范围内，指定下标插入数据，并将该下标的元素及该元素之后的元素都依次向后挪动一位，同时检测是否需要扩容。

SeqList.h 文件

// 在 pos 位置插入 x
void SeqListInsert(SeqList* ps, int pos, SLDataType x);

SeqList.c 文件

#include "SeqList.h"

// 在 pos 位置插入 x
void SeqListInsert(SeqList* ps, int pos, SLDataType x){
	assert(ps);
    
    // 温柔的检查
	/*
	if (pos > ps->size || pos < 0){
		printf("pos invalid:%d\n", pos);
		// 不会结束程序
		return;
	}
	*/
	// 暴力的检查
	assert(pos >= 0 && pos <= ps->size);

	// 检测是否需要扩容
	SeqListCheckCapacity(ps);
	
	// 挪动数据
	int end = ps->size - 1;
	while (end >= pos){
		ps->a[end + 1] = ps->a[end];
		--end;
	}

	ps->a[pos] = x;
	ps->size++;
}

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
	SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	// 打印
	SeqListPrint(&sl);
	
	// 在 pos 位置插入 x
	SeqListInsert(&sl, 3, 80);
	// 打印
	SeqListPrint(&sl);
	
	// 销毁
	SeqListDestory(&sl);
}

int main(){
	TestSeqList1();
	
	return 0;
}

运行结果：
运行结果

2.2.11 删除指定 pos 位置的值

思路： 和头删的思路大致相同，同时确保指定的 pos < size，如果 pos = size，则是删除了一个无意义的数。

SeqList.h 文件

// 删除 pos 位置的值
void SeqListErase(SeqList* ps, int pos);

SeqList.c 文件

#include "SeqList.h"

// 删除 pos 位置的值
void SeqListErase(SeqList* ps, int pos){
	assert(ps);

	// 断言判断删除的数据必须在 [0, size-1] 的合法范围内
	assert(pos >= 0 && pos < ps->size);

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

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
	SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	// 打印
	SeqListPrint(&sl);
	
	// 删除 pos 位置的值
	SeqListErase(&sl, 2);
	// 打印
	SeqListPrint(&sl);
	
	// 销毁
	SeqListDestory(&sl);
}

int main(){
	TestSeqList1();
	
	return 0;
}

运行结果：
运行结果

2.2.12 修改

思路： 在有效数据范围内将指定下标的元素进行修改即可。

SeqList.h 文件

// 修改指定下标的值
void SeqListModify(SeqList* ps, int pos, SLDataType x);

SeqList.c 文件

#include "SeqList.h"

// 修改指定下标的值
void SeqListModify(SeqList* ps, int pos, SLDataType x){
	assert(ps);
	assert(pos < ps->size && pos >= 0);

	ps->a[pos] = x;
}

Test.c 文件

#include "SeqList.h"

void TestSeqList1(){
	SeqList sl;
	// 初始化顺序表
	SeqListInit(&sl);
	// 尾插数据
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	// 打印
	SeqListPrint(&sl);
	
	// 修改指定下标的值
	SeqListModify(&sl, 3, 80);
	// 打印
	SeqListPrint(&sl);
	
	// 销毁
	SeqListDestory(&sl);
}

int main(){
	TestSeqList1();
	
	return 0;
}

运行结果：
运行结果

2.3 顺序表的优缺点及思考

优点：
1、支持随机访问（即用下标直接访问第 i 个）。有些算法，需要结构支持随机访问，比如：二分查找、优化的快排等。

缺点：
1、顺序表要求数据从开始位置连续存储，那么在中间或头部位置插入及删除数据，需要挪动数据，效率不高，时间复杂度为O(N)。
2、扩容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3、为了避免频繁扩容，扩容一般是扩大为原来 2 倍的空间，势必会有一定的空间浪费。例如当前容量为 100，空间满了以后扩容到 200，继续插入 5 个数据，后面没有数据插入，那么就浪费了 95 个数据空间。

针对顺序表的缺陷，就设计出了链表。

疯狂的豆子2019
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——线性表（一）
u010629933的专栏
05-12 597
我们在学习C语言的时候都用过数组，再学深一点大概会学到结构体，链表之类的。正常情况下，对于这一类的数据结构，我们都能看到他们的共同点。每一个数据项之间都只跟另一个数据项链接，所以我们把这一类的数据结构叫做线性表。不考虑实际内存地址的分配，从逻辑意义上看，我们可以把数据项都连起来，形成一个像表一样的东西。         那么首先就让我们来看看线性表的第一种形式吧———顺序存储结构。
线性表--顺序表（数据结构）
CoIorful的博客
09-27 349
初学数据结构，便多作了些实践内容，将课本上的内容自己理解后写了一遍。希望付出值得。 0.前提准备 #define MAXSIZE 50 typedef int ElemType; 1.建立结构体 typedef struct { ElemType Data[MAXSIZE]; int len; }SqList;//建立结构体 2.创造线性表 void CreatList(SqList*& L, ElemType a[], int n) //创造线性表 { int i = 0; in.
【顺序表和链表的对比】
m0_56069910的博客
02-02 2211
顺序表和链表的对比
二.数据结构之顺序表
weixin_67401157的博客
02-24 951
详解线性表之顺序表
C语言线性表realloc增加空间,数据结构C语言实现系列——线性表
weixin_39830200的博客
05-25 312
#include#includetypedefintelemType;/************************************************************************//*以下是关于线性表顺序存储操作的16种算法*//******************************************************************...
数据结构（C语言）—顺序表
D卡戎的博客
12-26 213
一、基本概念 数据结构（Data Structure）概念： 数据结构是研究组成数据的数据元素的关系的学科。 数据结构研究目的 ： 通过研究数据元素的关系，帮助我们在开发软件的时候更好的组件数据模型，让数据在内存中的操作更加的流畅高效。 数据 ->信息的载体，是能够输入到计算机中并且能被计算机识别、存储和处理的符号总称。 数据元素->数据的基本单位，又称之为记录（Record）。 ...
数据结构——001线性表的顺序表示
Miracle呀的博客
05-09 159
//线性表的顺序表示 #include <iostream> using namespace std; //顺序表 //**顺序表是从1开始的，数组是从0开始的 typedef int ElemType; //数组静态分配 #define Size 5 typedef struct{ int length; ElemType data[Size]; }SqList; //数组动态分配 typedef struct { ElemType *data; int length; int s
数据结构学习--线性表及其应用--顺序表
06-25
通过这样的实验，学习者能够更好地理解顺序表的特性和基本操作，为后续学习更复杂的数据结构如树、图等打下坚实的基础。同时，对顺序存储结构的熟悉也有助于提升对数组、指针等基础知识的运用能力。在实际编程中，...
数据结构课件-线性表顺序表.ppt
09-28
线性表是一种基本的数据结构，它在计算机科学中扮演着重要的角色。线性表是由 n 个（n ≥ 0）数据元素构成的有限序列，每个元素可以有不同的含义，但同一线性表中的元素必须具有相同的特性。当 n=0 时，线性表为空。...
数据结构2-线性表之顺序储存（顺序表）C语言版
10-21
本主题将深入探讨“数据结构2-线性表之顺序储存（顺序表）C语言版”，这是一段用C语言实现的顺序表的数据结构。顺序表是线性表的一种基本存储方式，它将元素存储在一块连续的内存区域中，通过数组来实现。 顺序表的...
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
c/c++数据结构-线性表-顺序表
04-26
数据结构实验中线性表的顺序表代码，带有详细注释，小白也能看得懂
数据结构——顺序表的C语言代码实现
AZ10000000的博客
04-01 6681
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、基础知识1.顺序表的概念（Sepential List）2.常用的接口函数3.realloc（）函数使用细节4.assert( )函数二、代码实现1.SepList.h（1）引用函数库（2）定义动态顺序表（3）接口函数声明2.SepList.c（1）引用头文件（2）初始顺序表（3）检测顺序表容量是否足够（4）顺序表的尾插法（5）顺序表的尾删法<1>使用if判断的温和法<2>使用assert（）断言的.
educoder数据结构与算法 线性表 第1关：实现一个顺序存储的线性表
兴趣使然的编程菜鸟
01-02 2065
注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的三个操作函数时，在函数体内可调用其他操作。本关的测试文件是 step1/Main.cpp ，负责对实现的代码进行测试。返回被删除的数据元素的值。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。所指向的用于存储线性表数据元素的存储空间。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。个数据元素的顺序存储的线性表，并将其初始状态设置为。的数据元素，返回该数据元素的编号。获取线性表当前长度：获取并返回线性表的当前长度。
顺序表（数据结构）
outdated_socks的博客
04-07 5363
顺序表详解
数据结构---顺序表
blue_jun_的博客
04-22 911
1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1. 静态顺序表：使用定长数组存储元素 2. 动态顺序表：使用动态开辟的数组存储。 由于静态顺序表数组定长，所以存在数组过小不够用，数组过大空间浪费等问题。 所以我们一般使用动态顺序表，接下来我们就讲解一个动态顺序表的实现。 2.动态顺序表的实现 首先，创建一个项目，定义一个头文件“seqlist....
2022-02-09_顺序表
qq_43205256的博客
03-11 183
一、 作业标题 顺序表的增删查改 第一步、创建三个程序文件 第二步、实现程序 test.c部分 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> #include <time.h> #include <errno.h> #include &.
数据结构学习笔记（1）顺序表
weixin_52971492的博客
11-26 230
完整代码+2个测试函数 SeqList.h #pragma once #include<stdio.h> #include<stdlib.h> typedef int DataType; //定义结构体SeqList typedef struct { DataType list[MaxSize]; int size; }SeqList; //初始化 void ListInitiate(SeqList* L); //求当前数据元素个数 int ListLength(Seq
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
最新发布
铁匠匠匠的博客
07-18 286
可以参考以下视频。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值