顺序表和链表

最新推荐文章于 2024-09-20 14:26:28 发布
最新推荐文章于 2024-09-20 14:26:28 发布
阅读量56 收藏 1
点赞数 1
分类专栏： 数据结构初阶 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gtyyky/article/details/131017954
版权

一、线性表

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

二、顺序表

2.1概念及结构

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

  1. 静态顺序表：使用定长数组存储元素。
    在这里插入图片描述
  2. 动态顺序表：使用动态开辟的数组存储。
    在这里插入图片描述

2.2 接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
#define INIT_CAPACITY 4

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

// 基本增删查改接口
// 顺序表初始化
void SLInit(SL* ps);
// 顺序表销毁
void SLDestroy(SL* ps);
// 顺序表打印
void SLPrint(SL* ps);
// 检查空间，如果满了，进行增容
void SLCheckCapacity(SL* ps);

// 顺序表尾插
void SLPushBack(SL* ps, SLDataType x);
// 顺序表尾删
void SLPopBack(SL* ps);
// 顺序表头插
void SLPushFront(SL* ps, SLDataType x);
// 顺序表头删
void SLPopFront(SL* ps);
// 顺序表在pos位置插入x
void SLInsert(SL* ps, int pos, SLDataType x);
// 顺序表删除pos位置的值
void SLErase(SL* ps, int pos);
// 顺序表查找
int SLFind(SL* ps, SLDataType x);

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void SLInit(SL* ps)
{
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);
	if (ps->a==NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->capacity = INIT_CAPACITY;
	ps->size = 0;
}

void SLDestroy(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void SLCheckCapacity(SL* ps)
{
	assert(ps);

	//扩容
	if (ps->size == ps->capacity)
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}
}

void SLPushBack(SL* ps, SLDataType x)
{
	//assert(ps);

	扩容
	//SLCheckCapacity(ps);

	//ps->a[ps->size++] = x;
	SLInsert(ps, ps->size, x);
}

void SLPopBack(SL* ps)
{
	//assert(ps);

	 暴力检查
	//assert(ps->size > 0);

	 温柔的检查
	if (ps->size == 0)
	//	//return;

	//ps->size--;
	SLErase(ps, ps->size-1);
}

void SLPushFront(SL* ps, SLDataType x)
{
	//assert(ps);

	//SLCheckCapacity(ps);

	将数组元素向后移动一个位置
	//int end = ps->size - 1;
	注意循环条件，要把end=0位置腾出来放新插入的数字
	//while (end >= 0)
	//{
	//	ps->a[end + 1] = ps->a[end];
	//	--end;
	//}

	//ps->a[0] = x;
	//ps->size++;

	SLInsert(ps, 0, x);

}

void SLPopFront(SL* ps)
{
	//assert(ps);
	//assert(ps->size > 0);

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

	//ps->size--;
	SLErase(ps, 0);

}

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

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

	ps->a[pos] = x;
	ps->size++;
}
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

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

	ps->size--;
}
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}

2.3 顺序表的问题及思考

问题：

  1. 中间/头部的插入删除，时间复杂度为O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到
    200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
    思考：如何解决以上问题呢？下面给出了链表的结构来看看。

三、链表

3.1 链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
现实中 数据结构中
在这里插入图片描述

3.2 链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  1. 单向或者双向
    在这里插入图片描述

  2. 带头或者不带头
    在这里插入图片描述

  3. 循环或者非循环
    在这里插入图片描述
    虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
    在这里插入图片描述

  4. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

  5. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

3.3 单链表的实现

// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;
// 动态申请一个结点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？（因为在pos之前插入需要先找到pos的前一个节点，效率低下）
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？（因为在pos之前插入需要先找到pos的前一个节点，效率低下）
void SListEraseAfter(SListNode* pos);

#include"Slist.h"

void SLTPrint(SLTNode* phead)//打印不需要断言，因为phead为空也可以打印
{
	SLTNode* cur = phead;

	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//pphead指向phead的地址，而phead的地址不可能为空，所以需要加断言防止传参错误
	//* pphead指的是链表的头，为空时也可以尾插，所以不需要断言
	SLTNode* newnode = BuySLTNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//pphead指向phead的地址，而phead的地址不可能为空，所以需要加断言防止传参错误
	//* pphead指的是链表的头，为空时也可以头插，所以不需要断言

	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SLTPopBack(SLTNode** pphead)
{
	// 暴力检查
	assert(pphead);//这里顺序不要反，因为如果pphead为空说明传错了，就直接报错就可以
	assert(*pphead);//* pphead指的是链表的头，为空时不可以尾删，所以需要断言

	// 温柔的检查
	//if (*pphead == NULL)
	//	return;

	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//找尾
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;

	}
}
void SLTPopFront(SLTNode** pphead)
{
	// 暴力检查
	assert(pphead);//这里顺序不要反，因为如果pphead为空说明传错了，就直接报错就可以
	assert(*pphead);//* pphead指的是链表的头，为空时不可以头删，所以需要断言
	
	温柔的检查
	//if (*pphead == NULL)
	//	return;
	
	SLTNode* first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)//查找函数不需要断言，头指针为空的时候也可以查找
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

// pos之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(pphead);

	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		// 找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

// pos位置删除
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);//pos位置间接断了，也可以不断
	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		// 找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
	}
}

// pos后面插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

// pos位置后面删除
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);//如果pos是最后一个节点，就不能删除

	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

3.4 双向链表的实现

在这里插入图片描述
循环: 1、尾next指向哨兵位的头 2、哨兵位的头的prev指向尾

// 2、带头+双向+循环链表增删查改实现
#pragma once
#include<stdlib.h>
#include<assert.h>
#include<stdio.h>
#include<stdbool.h>

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;

	LTDataType data;
}LTNode;

//初始化节点
//void LTInit(LTNode** pphead);
LTNode* LTInit();
void LTDestroy(LTNode* phead);
//打印函数
void LTPrint(LTNode* phead);
//判断链表是否为空
bool LTEmpty(LTNode* phead);
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);

// 在pos位置之前插入一个值
void LTInsert(LTNode* pos, LTDataType x);
// 删除pos位置的值
void LTErase(LTNode* pos);

#include"List.h"


LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		//return NULL;
		exit(-1);
	}
	node->next = NULL;
	node->prev = NULL;
	node->data = x;

	return node;
}

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void LTDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur!=phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(phead);
}

void LTPrint(LTNode* phead)
{
	assert(phead);

	printf("<=head=>");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

bool LTEmpty(LTNode* phead)
{
	assert(phead);

	/*if (phead->next == phead)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return phead->next == phead;
}


void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* newnode = BuyListNode(x);
	//LTNode* tail = phead->prev;

	 phead            tail  newnode
	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;

	LTInsert(phead, x);
}

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	//LTNode* tail = phead->prev;
	//LTNode* tailPrev = tail->prev;

	//tailPrev->next = phead;
	//phead->prev = tailPrev;
	//free(tail);
	//tail = NULL;
	LTErase(phead->prev);
}

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* newnode = BuyListNode(x);
	//LTNode* first = phead->next;
	//phead->next = newnode;
	//newnode->prev = phead;

	//newnode->next = first;
	//first->prev = newnode;

	// 不能随便换顺序
	//newnode->next = phead->next;
	//phead->next->prev = newnode;

	//phead->next = newnode;
	//newnode->prev = phead;

	LTInsert(phead->next, x);
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	//....
	LTErase(phead->next);
}

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);
	// prev newnode pos

	prev->next = newnode;
	newnode->prev = prev;

	newnode->next = pos;
	pos->prev = newnode;
}

void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* p = pos->prev;
	LTNode* n = pos->next;

	p->next = n;
	n->prev = p;

	free(pos);
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;

	while (cur!=phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

单链表和双链表的区别在于：

  1. 指向不同：单向链表只有一个指向下一结点的指针，而双向链表除了有一个指向下一结点的指针外，还有一个指向前一结点的指针。
  2. 功能不同：单向链表只能next，而双向链表可以return。
  3. 单双向不同：单链表只能单向读取，而双向链表可以通过prev()快速找到前一结点。
  4. 增加和删除节点的难易程度：单链表相对容易，而双向链表相对复杂。
  5. 遍历时的复杂度：单链表为O(n)，而双向链表为O(1)。

综上所述，单链表和双链表的主要区别在于指针的方向和功能，以及遍历和增加、删除节点的难易程度。

四、顺序表和链表的区别

存储空间上：顺序表物理上一定连续；链表逻辑上连续，但物理上不一定连续
随机访问：顺序表支持O(1) ；链表不支持：O(N)
任意位置插入或者删除元素：顺序表可能需要搬移元素，效率低O(N)；链表只需修改指针指向
插入：动态顺序表，空间不够时需要扩容；链表没有容量的概念
应用场景：顺序表元素高效存储+频繁访问；链表任意位置插入和删除频繁
缓存利用率：顺序表高，链表低

sy'ty
关注
专栏目录
顺序表与链表
m0_56931704的博客
09-06 1471
顺序表与链表 一.顺序表 1.定义：将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中 顺序表可以分为静态顺序表和动态顺序表 2.结构定义： #define MAXSIZE 100 typedef int ElemType; typedef struct Seqlist {//静态顺序表 ElemType data[MAXSIZE]; size_t size
Java顺序表和链表
xinhang10的博客
11-14 1846
此文章对Java数据结构中的顺序表和链表进行了十分细致的讲解，并为大家演示了如何从0开始创建一个顺序表和链表，并将他们编写成一个完整的顺序表(链表)。在此基础上，作者还为大家贴心的准备了10个链表的练习题，并将他们详细的讲解了一遍，相信这对初入数据结构的同学们来说一定是一个好的练习。在练习题后面我们还为大家附上了力扣和牛客网的链表练习题链接，有需要的小伙伴可以自己点击。在文章的最后，我们为大家分析了链表和顺序表到底有什么区别……
顺序表和链表的比较
icbbm的博客
08-04 3479
综上所述，顺序表适用于数据元素较少、读取操作频繁的场景，而链表适用于数据元素较多、插入、删除操作频繁的场景。
顺序表和链表的优缺点
weixin_57023347的博客
06-21 3837
顺序表 定义：在内存中用地址连续的一块存储空间顺序存放线性表的各元素。在程序设计语言中，一维数组在内存中占用的存储空间是一维连续的存储空间，因此我们用一维数组存储数据来表示顺序表。 优点： 由于顺序表是用数组来存储数据，内存空间连续，当访问数据时可以达到使用数组下标的方式随机访问。 CPU高速缓存的命中率高。 解释： 数据保存在内存中，数据是在CPU里进行运算的(逻辑和算术)。但是CPU速度太快，内存的速度跟不上CPU的速度。于是在CPU和内存之间存在一些寄存器和缓存器，用来保存数据。当CPU要使用数
顺序表和链表的区别
Britney_dark的博客
04-25 3952
不同点 顺序表 链表 存储空间 物理上一定连续 逻辑上连续，但物理上不一定连续 随机访问 支持O(1) 不支持：O(N) 任意位置插入或者删除元素 可能需要搬移元素，效率低O(N) 只需修改指针指向 插入 动态顺序表，空间不够时需要扩容 没有容量的概念 应用场景 元素高效存储+频繁访问 任意位置插入和删除频繁 缓存利用率 高 低 由上表可总结出： 顺序表优点： 1. 物理空间是连续的，方便用
线性表——顺序表和链表
qq_65285898的博客
08-21 3431
顺序表和链表的解释与实现
【数据结构】顺序表和链表的优缺点
Eraser的博客
04-21 2363
经过这么多对比，可以发现顺序表和链表就是互补的存在，两个都有存在的意义和自己擅长的领域。
顺序表和链表的优点缺点
m0_62027222的博客
09-12 1785
链表的优点是便于结点的插入和删除(只需要修改指针域,不需要移动结点),表的容量扩充十分方便;缺点是不能进行随机访问,只能顺序访问,另外每个结点上增加指针域,导致存储密度较低。顺序表的优点是可以随机存取元素,存储密度高,结构简单;缺点是需要一片地址连续的存储空间,不便于插入和删除元素(需要移动大量的元素),表的容量难以确定。
顺序表 和链表的优缺点
rendaitong的博客
10-23 767
简单对于顺序表和链表的优缺点进行对比
顺序表和链表.pdf
04-24
本文档主要介绍顺序表和链表这两种基本的数据结构。在计算机科学中，数据结构是指在计算机中组织和存储数据的一种特殊方式，它允许高效地访问和修改数据。顺序表和链表作为线性表的两种实现方式，在实际应用中非常...
数据结构实验 顺序表和链表
10-08
顺序表和链表的基本实现 数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍...
数据结构顺序表和链表的相关操作
06-30
实现顺序表和链表的建立、取元素、修改元素、插入、删除等顺序表的基本操作。 设计要求: 首先设计一个含有多个菜单项的主菜单程序，然后再为这些菜单项配上相应的功能。 基本操作： 1.依次从键盘读入数据，建立...
C语言：定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表.zip
09-07
在本资源"C语言：定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表.zip"中，我们将探讨如何使用C语言实现两种常见的数据结构——顺序表和链表，用于存储和管理学生信息。 首先，我们来理解顺序表。顺序表是...
数据结构应试-1
最新发布
Nozomi9967的博客
09-20 707
Head(L)：返回广义表L的第一个元素。Tail(L)：返回除了第一个元素之外的剩余部分组成的广义表。
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】
Mao_c的博客
09-14 1047
leetcode b树
数据结构—栈
2301_80151359的博客
09-17 460
/定义栈的结构//栈的空间大小int top;//栈顶}ST;
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 627
数据结构之字典和哈希表
数据结构中线性表的定义和特点
2401_83201682的博客
09-15 427
数据结构中线性表的有关介绍，欢迎观看，欢迎点评。
线性表详解：顺序表与链表
链表又可以细分为单链表、双链表和循环链表等。 线性表的基本操作包括插入、删除、查找等。在顺序表上，这些操作的效率受到数组下标的限制；而在链表上，它们的效率受到指针操作的影响。例如，插入和删除操作在链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值