【DS】单链表@线性表 —— 增删查改

已于 2022-06-24 20:03:02 修改
阅读量1.9k 收藏 20
点赞数 27
分类专栏： 初阶数据结构 文章标签： 链表 数据结构 算法
于 2022-01-06 21:23:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54851255/article/details/122352795
版权

目录

嘿嘿：上次实现单链表已经是两个月之前的事儿了，今儿拿出来再写，思路还是在，但确实忘掉了一些细节，一上午出现了各种小问题，全都是自己一个个调出来的，这种快感不是别的什么事情可以代替的。同时也发现，当初觉得想不到的东西，现在看也就是理所当然，这就是螺旋式上升吧🐏！

0. 引

上文说到顺序表缺陷 ——

❄️1. 空间不够需要增容，增容是要付出代价的。
❄️2. 为了避免频繁扩容，我们基本都是按倍数去扩（比如扩2倍），这又可能会造成一定的空间浪费。
❄️3. 顺序表要求数据从开始位置保持连续，那么中间和头部的插入和删除，都需要挪动数据，时间复杂度为O(N)，效率不高。

为此，我们引入了链表。

1. 链表的概念和结构

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

  • 逻辑图 —— 想象出来的形象方式表示

  • 物理图 —— 内存中的真实存储 —— 通过指针来存储下一个节点的地址，并不连续

2. 链表的分类

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

  • 单向或双向

  • 带头不带头

  • 循环非循环

在这里插入图片描述

当然我们最常用的还是这两种 ——

  1. 无头单向非循环链表

  • 结构简单，但缺陷还是很多（一会儿实现的时候你就知道啦），单纯单链表的增删查改意义不大。
  • 但是还是要写，可能正因为它的缺陷，很多oj题考察的都是单链表
  • 更多的是做更复杂数据结构的子结构，比如哈希桶、邻接表。
  1. 带头双向循环链表

  • 结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。
  • 另外这个结构虽然复杂，却也是无死角的结构，用代码实现时会发现结构会带来很多优势，非常爽，后面我们代码实现了就知道了。

3. 链表的实现

文末领取头文件大家自己写，自己写自己调时候思路是最清晰的，具体实现中每个思路和要注意的小点我都会写好（尤其是它第一次出现的时候）（这链表电脑画图老累了，主要是这个破箭头，ipad上写字还丑，我把我草纸的图弄进来了哦吼吼）红笔写的是边界，耦合色写的是变化过程哈哈。

3.1 打印、申请新节点、销毁

3.1.1 打印

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

3.1.2 申请新节点

//申请新节点
SLTNode* BuyListNode(SListDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc failed\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

3.1.3 销毁

  • 顺序表中申请的内存是连续的(realloc)，因此一次释放就行；而链表的空间申请时候就不连续，必须遍历回收。
  • free时，data和next都会被置成随机值，因此要记录next

void SListDestroy(SLTNode** pphead)
{
    assert(pphead);
    // 链表的空间必须遍历回收，因为申请时候就不连续
	SLTNode* cur = *pphead;
	SLTNode* next = cur->next;// 记录下一个节点的位置
	while (next)
	{
		free(cur);
		cur = next;
		next = cur->next;
	}
	*pphead = NULL;
}

3.2 尾插、尾删

3.2.1 尾插

  • 为什么要传二级指针？尾插、包括后面的尾删头插头删、前面的销毁都需要传二级指针，而打印、查找就不需要。

🍓实际上，二级指针就是为了处理首节点的改变（pList是链表的地址，类型为SLNode*），后面操纵的都是结构体就不需要。众所周知形参是实参的一份临时拷贝，形参的改变不会影响实参，因此必须传实参地址（在这里类型为SLNode**）以改变实参。

  • 解释一下assert(pphead);，像这种一定不为空的要断言一下，方便查错（传错）

void SListPushBack(SLTNode** pphead, SListDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	//1.空链表 - 尾插头结点的地址pList发生改变，因此需要传pList的地址
    //单拎出来处理
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}
	//2.找尾
	SLTNode* tail = *pphead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newnode;
}

3.2.2 尾删

  • 考虑链表为空 —— 断言结束（STL采取的就是这样粗暴的方式），毕竟，就是你用错了
  • 其余细节过程都在图中

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	//1.空链表
	assert(*pphead);
	//2.删的只剩一个节点时
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}

	//3.
	//找尾的上一个
	SLTNode* prevtail = *pphead;
	SLTNode* tail = prevtail->next;
	while (tail->next != NULL)
	{
		prevtail = tail;
		tail = tail->next;
	}
	free(tail);
	prevtail->next = NULL;
}

3.3 头插、头删

3.3.1 头插

void SListPushFront(SLTNode** pphead, SListDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

3.3.2 头删

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	//1.删空
	assert(*pphead);
	//2.
	SLTNode* headnext = (*pphead)->next;
	free(*pphead);
	*pphead = headnext;
}

3.4 查找、任意位置插入、任意位置删除

3.4.1 查找

SLTNode* SListFind(SLTNode* phead, SListDataType x)
{
	SLTNode* cur = phead;
	if (phead == NULL)
	{
		//处理空链表，不然后面解引用可是又错了
		return NULL;
	}
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;//走到这儿还没找到
}

3.4.2 任意位置插入

//在pos位置之前去插入一个节点--pos位置一般是find来的
void SListInsert(SLTNode** pphead, SLTNode* pos, SListDataType x)
{
	assert(pphead);
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	//1. 头插
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	//2.
	SLTNode* posPrev = *pphead;
	while (posPrev->next != pos)
	{
		posPrev = posPrev->next;
	}
	posPrev->next = newnode;
	newnode->next = pos;
}


//在pos后边插入--这个更适合也更简单高效
//STL- insert_after
void SListInsertAfter(SLTNode* pos, SListDataType x)
{
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	SLTNode* posNext = pos->next;
	pos->next = newnode;
	newnode->next = posNext;
}

3.4.3 任意位置删除

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	//删空
	assert(*pphead);
	//1.头删
	//带哨兵位的头的 -- 可以合并 头删与中间删 -- 逻辑结构一样，不会删完
	if (*pphead == pos)
	{
		*pphead = pos->next;
		free(pos);
		return;//自己调出来的
	}

	SLTNode* posPrev = *pphead;
	while (posPrev->next != pos)
	{
		posPrev = posPrev->next;
	}
	posPrev->next = pos->next;
	free(pos);//注意顺序，对于我很简单啦
	//pos不置空也无所谓，毕竟在函数中是形参，形参的改变不会影响实参，处于好习惯，还是置空比较好
}

当然也可以实现删除pos后面的节点，这个功能很奇葩哈哈给pos不删pos

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);//一个节点
	SLTNode* posNext = pos->next;
	pos->next = posNext->next;
	free(posNext);
	//next = NULL;//出作用域即销毁，是野指针，但别人拿不到
}

4. 关于单链表的思考

4.1 链表优点

链表弥补了顺序表的缺陷

  1. 按需申请空间，不用了就释放（更合理的使用了空间），不存在空间浪费
  2. 头部和中间插入删除数据，不需要挪动数据

4.1 链表缺点

  1. 每一个数据，都要存一个指针链接后面的数据结点
  2. 不支持随机访问（用下标直接访问第i个元素），而有些算法，需要随机访问，如：二分查找、优化的快排

附录

SingleList.h

#pragma once

//无头单向非循环链表
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SListDataType;

typedef struct SListNode
{
	SListDataType data;
	struct SListNode* next;
}SLTNode;

void SListPrint(SLTNode* phead);
//销毁
void SListDestroy(SLTNode** pphead);

//尾插
void SListPushBack(SLTNode** pphead, SListDataType x);
//尾删
void SListPopBack(SLTNode** pphead);
//头插
void SListPushFront(SLTNode** pphead, SListDataType x);
//头删
void SListPopFront(SLTNode** pphead);

//查找
SLTNode* SListFind(SLTNode* phead, SListDataType x);
//在pos位置之前去插入一个节点--pos位置一般是find来的
void SListInsert(SLTNode** pphead, SLTNode* pos, SListDataType x);
//任意位置删
void SListErase(SLTNode** pphead, SLTNode* pos);
//在pos后边插入--这个更适合也更简单高效
void SListInsertAfter(SLTNode* pos, SListDataType x);

void SListEraseAfter(SLTNode* pos);
//void SListInsert(SLTNode* phead, SLTNode* pos,SListDataType x);
//void SListErase(SLTNode* phead, int pos);

SingleList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void SListDestroy(SLTNode** pphead)
{
	// 这个链表是
	// 链表的空间必须遍历回收，因为申请时候就不连续
	SLTNode* cur = *pphead;
	SLTNode* next = cur->next;// 记录下一个节点的位置
	while (next)
	{
		free(cur);
		cur = next;
		next = cur->next;
	}
	*pphead = NULL;
}

//申请新节点
SLTNode* BuyListNode(SListDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc failed\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

void SListPushBack(SLTNode** pphead, SListDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	//1.空链表 - 尾插头结点的地址pList发生改变，因此需要传pList的地址
	// **pphead
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}
	//找尾
	SLTNode* tail = *pphead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newnode;
}

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	//1.空链表
	assert(*pphead);
	//2.删的只剩一个节点时
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}

	//3.普遍情况
	//找尾的上一个
	SLTNode* prevtail = *pphead;
	SLTNode* tail = prevtail->next;
	while (tail->next != NULL)
	{
		prevtail = tail;
		tail = tail->next;
	}
	free(tail);
	prevtail->next = NULL;
}


void SListPushFront(SLTNode** pphead, SListDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	//1.删空
	assert(*pphead);
	//2.
	SLTNode* headnext = (*pphead)->next;
	free(*pphead);
	*pphead = headnext;
}

SLTNode* SListFind(SLTNode* phead, SListDataType x)
{
	SLTNode* cur = phead;
	if (phead == NULL)
	{
		//处理空链表，不然后面解引用可是又错了
		return NULL;
	}
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;//走到这儿还没找到
}

//在pos位置之前去插入一个节点--pos位置一般是find来的
void SListInsert(SLTNode** pphead, SLTNode* pos, SListDataType x)
{
	assert(pphead);
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	//1. 头插
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	//2.
	SLTNode* posPrev = *pphead;
	while (posPrev->next != pos)
	{
		posPrev = posPrev->next;
	}
	posPrev->next = newnode;
	newnode->next = pos;
}

//在pos后边插入--这个更适合也更简单高效
//STL- insert_after
void SListInsertAfter(SLTNode* pos, SListDataType x)
{
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	SLTNode* posNext = pos->next;
	pos->next = newnode;
	newnode->next = posNext;
}


//任意位置删
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	//删空
	assert(*pphead);
	//1.头删
	//带哨兵位的头的 -- 可以合并 头删与中间删 -- 逻辑结构一样，不会删完
	if (*pphead == pos)
	{
		*pphead = pos->next;
		free(pos);
		return;//自己调出来的
	}

	SLTNode* posPrev = *pphead;
	while (posPrev->next != pos)
	{
		posPrev = posPrev->next;
	}
	posPrev->next = pos->next;
	free(pos);//注意顺序，对于我很简单啦
	//pos不置空也无所谓，毕竟在函数中是形参，形参的改变不会影响实参，处于好习惯，还是置空比较好

}

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);//一个节点
	SLTNode* posNext = pos->next;
	pos->next = posNext->next;
	free(posNext);
	//next = NULL;//出作用域即销毁，是野指针，但别人拿不到
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"

//测试尾插尾删
void testSingleList1()
{
	//指向单链表的指针 - 本质是存储这个单链表头结点的地址的指针变量
	SLTNode* pList;
	pList = NULL;//这个错是我调出来的
	SListPushBack(&pList, 1);
	SListPushBack(&pList, 2);
	SListPushBack(&pList, 3);
	SListPushBack(&pList, 4);
	SListPrint(pList);

	SListPopBack(&pList);
	SListPopBack(&pList);
	SListPopBack(&pList);
	/*SListPopBack(&pList);
	SListPopBack(&pList);*/

	SListPrint(pList);
	SListDestroy(&pList);
}

//测试头插头删
void testSingleList2()
{
	SLTNode* pList;
	pList = NULL;
	SListPushFront(&pList, 1);
	SListPushFront(&pList, 2);
	SListPushFront(&pList, 3);

	SListPrint(pList);

	SListPopFront(&pList);
	SListPopFront(&pList);
	/*SListPopFront(&pList);
	SListPopFront(&pList);*/

	SListPrint(pList);

	SListDestroy(&pList);
}

//测试任意位置的插入、查找
void testSingleList3()
{
	SLTNode* pList;
	pList = NULL;
	SListPushBack(&pList, 1);
	SListPushBack(&pList, 2);
	SListPushBack(&pList, 4);
	SListPushBack(&pList, 5);

	SLTNode* ret = SListFind(pList, 2);
	if (ret == NULL)
	{
		printf("not found\n");
	}
	else
	{
		printf("%d\n", ret->data);
	}
	//SListInsert(&pList, ret, 0);//测试头插
	//SListInsert(&pList, ret, 3);

	SListInsertAfter(ret, 3);
	SListPrint(pList);
	SListDestroy(&pList);

}

//测试任意位置删
void testSingleList4()
{
	SLTNode* pList;
	pList = NULL;
	SListPushBack(&pList, 1);
	SListPushBack(&pList, 2);
	SListPushBack(&pList, 4);
	SListPushBack(&pList, 5);
	SListPrint(pList);

	SLTNode* ret = SListFind(pList, 1);
	if (ret == NULL)
	{
		printf("not found\n");
	}
	else
	{
		printf("%d\n", ret->data);
	}
	//SListErase(&pList, ret);
	//SListErase(&pList, ret);

	SListEraseAfter(ret);
	SListPrint(pList);
	SListDestroy(&pList);

}

int main()
{
	//testSingleList1();
	//testSingleList2();
	//testSingleList3();
	testSingleList4();
	return 0;
}

下一篇来带头双向循环链表

本文完

浮光 掠影
关注
  • 27
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
线性表——单链表的增删改查（头插法，尾插法，按序号查找，按值查找，某个位置插入元素，某个位置删除元素）
weixin_46398446的博客
01-04 1632
目录一、链表的特点二、链表的特点三、代码实现结构体1.头插法打印链表完整代码 一、链表的特点 逻辑上相邻的两个元素在物理位置上不相邻。 二、链表的特点 两部分组成：数据域data和指针域next。最后一个为NULL。 三、代码实现 结构体 typedef int ElemType; // 定义结构体 typedef struct LNode { ElemType data; // 数据域 struct LNode* next; // 定义结构体指针，指向下一个结点。因为从上往下编译，所以不能
数据结构——线性表（单链表的增、删、查）
Duanqi1的博客
07-06 537
---------单链表--------- 逻辑上相邻的数据元素物理存储上不一定相邻，即数据元素离散的分布在存储空间中。元素之间的顺序关系通过指针链接。增删操作只用修改指针即可，不用每次都移动大量的数据元素。 使用链式存储，内存空间利用率大，存储密度低，但每次查找元素都需要从表头开始遍历，失去了随机存取的优点。 ★注：为了操作上的方便，通常在链表第一个结点前附加一个头结点，结点内通常不存储任何信息。 ...
线性链表的增删改查
ice_tomato的博客
08-30 201
今天面试时写的，应该注意时间，现在的代码不能支持删除第一个结点的，和在第一个结点之前插入，后面有空了的话要把加入头结点的方式的补上，让代码更完善。 ​ #include <iostream> using namespace std; /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; *
线性表的“增删改查”
Coder的博客
12-13 891
#include #define MAXSIZE 20 #define ERROR 0 #define OK 1 typedef int ElementType; typedef int Status; typedef struct {     ElementType data[MAXSIZE];     int length; }Sqlist; //清空数
线性表的增删改查
qq_59361025的博客
03-05 184
线性表的增删改查
数据结构 c语言 线性表 增删查改保存.txt
07-24
数据结构 c语言 线性表 增删查改保存 InitList(Linklist &L,int &k); PrintList(Linklist &L,int &k); ListInsert(Linklist &L,int &k); ListDelete(Linklist &L,int &k); void ListSave(Linklist &L); void cd();
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
文档中包含顺序表和单链表的增、删、改、查等基本操作，并且通过实际案例来展示这些操作的应用场景。 #### 二、顺序表 **定义**：顺序表是一种线性表的存储结构，它使用一段地址连续的存储单元依次存储线性表中的...
线性表增删查改的时间自由度
最新发布
04-04
线性表增删查改的时间自由度取决于具体的实现方式和数据结构。一般来说，不同的实现方式和数据结构会对增删查改的时间复杂度产生不同的影响。例如，使用数组作为存储结构的线性表，在插入或删除元素时需要移动其他...
php线性表顺序存储实现代码(增删查改)
10-28
PHP线性表顺序存储实现代码（增删查改） PHP实现线性表顺序存储的代码，需要的朋友可以参考下。线性表是一种基本的数据结构，它可以用来存储和操作一组数据。顺序存储是指将数据存储在一块连续的内存空间中，每个...
Java线性表之单链表的增删改查
CoVerMySoul
06-28 415
文章目录概述一、链式存储介绍二、单链表介绍三、单链表的创建1、头插法2、尾插法四、单链表的删除1、删除第i个节点2、删除指定元素的那个节点五、单链表的查询（及修改）六、小结 概述 我们都知道，线性表的存储结构分为两种，顺序存储结构和链式存储结构，线性表的分类可以参考下图来学习记忆。今天我们主要来学习一下链式存储结构。 一、链式存储介绍 “链式存储结构，地址可以连续也可以不连续的存储单元存储数据元素”——来自定义。 其实，你可以想象这样一个场景，你想找一个人（他的名字叫小谭）,于是你首先去问 A ， A
线性表中顺序表的增删改查
06-21
顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查
线性表的链表的增删查改等的操作
黑桃K
12-12 206
线性表的链表的增删查改等的操作 #include<stdio.h> //d定义类型 typedef int LDateType; //定义结构体类型 typedef struct listNode { LDateType _date; struct listNode* _next; }listNode; //定义头指针 typedef struct list { listNode* _head; }list; //初始化头指针 void InistList(list* lst) { if
【数据结构】线性表之单链表（增删查改等）
丨归凡的博客
07-31 182
数据结构之单链表
线性表的完善增删改查
Coder的博客
12-14 455
#include #include #include #define OK 1 #define ERROR 0 typedef int Status; typedef int ElementType; typedef struct {     ElementType *data;     int length; }Sqlist; int MAXSIZE = 20;
线性表——顺序表的增删改查
weixin_46398446的博客
01-03 2050
目录一、顺序表的特点二、顺序表的特点三、代码实现结构体1.增（插入）2.删（删除）3.改（修改）4.查（查找）完整代码注意 一、顺序表的特点 逻辑上相邻的两个元素在物理位置上也相邻。 二、顺序表的特点 优点 1.可随机存取，根据表头元素地址和元素序号表示表中任意一个元素。简单来说可以用公式到达任意元素。 2.存储密度高，每个结点只存储数据元素。 缺点 1.插入和删除操作需要移动大量元素。 2.线性表变化较大时，难以确定存储空间的容量。 3.村年初分配需要一整段连续的存储空间，不够灵活。 三、代码
线性表--链表增、删、查、改
身在边城 心在编程
03-22 528
线性表–链表增、删、查、改 链式结构的基本插入，删除，修改，改动结点的代码是最基本的 代码目录线性表--链表增、删、查、改0.包含头文件和结构体初始化/销毁链表1.头插、尾插、指定位置插2.头删、尾删、指定位置删除结点3.指定结点在链表里查找有没有4.修改链表--反转方法一：旧链表头删，新链表头插方法二：定义三个指针5.删除v所对应的点删除v对应的所有结点 0.包含头文件和结构体 #include...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浮光 掠影

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值