C++ “链链“不忘@必有回响之单链表

已于 2022-10-25 15:59:05 修改
阅读量474 收藏 2
点赞数 1
分类专栏： C++编程之美 文章标签： c++ 链表 数据结构
于 2022-09-16 09:49:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y6123236/article/details/126884519
版权

1. 前言

数组和链表是数据结构的基石，是逻辑上可描述、物理结构真实存在的具体数据结构。其它的数据结构往往在此基础上赋予不同的数据操作语义，如栈先进后出，队列先进先出……

数组中的所有数据存储在一片连续的内存区域；链表的数据以结点形式存储，结点分散在内存的不同位置，结点之间通过保存彼此的地址从而知道对方的存在。

因数组物理结构的连续特性，其查询速度较快。但因数组的空间大小是固定的，在添加、插入数据时，可能需要对空间进行扩容操作，删除时，需要对数据进行移位操作，其性能较差。

链表中的结点通过地址彼此联系，查询有点繁琐，查询过程有点像古时候通过烽火传递军情一样。而插入、删除操作则较快，只需要改变结点之间的地址信息就可以。

可认为链表是由结点组成的集合实体，根据结点中存储信息的不同，可把链表分成：

  • 单链表：结点中存储数据和其后驱结点的地址。
  • 循环链表：在单链表的基础上，其最后一个结点，也称尾结点中存储头结点的地址，形成一个闭环。
  • 双向链表：结点中存储数据和前、后驱结点的地址。
  • 双向循环链表：在双向链表的基础上，头结点保存尾结点地址，尾结点保存头结点地址。一般说双向链表都是指双向循环链表。

在链表的基本形式之上，可以根据需要在结点上添加更多信息，如十字链表等复杂形式。在链表基础认知之上，请不要拘泥于知识本身，而要善于根据实际需要进行变通。

本文聊聊基于单链表形式的数据查询、插入、删除操作。

2. 单链表

单链表的特点是结点中仅存储数据本身以及后驱结点的地址，所以单链表的结点只有 2 个域：

  • 存放数据信息，称为数据域。
  • 存放后驱结点的地址信息，称为指针域。

如下图描述了单链表结点的存储结构：

1.png

C++中可以使用结构体描述结点：

typedef int dataType;
//结点
struct LinkNode{
	//数据成员 
	dataType  data;
	//后驱结点的地址
	LinkNode *next;
    //构造函数
	LinkNode(dataType data) {
		this->data=data;
		this->next=NULL;
	}
};

当结点与结点之间手牵手后，就构成了链表：

2.png

链表有 2 个特殊结点：

  • 头结点：链表的第一个结点，头结点没有前驱结点。头结点可以存储数据，也可以不存储数据，不存储时，此结点为标识用的空白结点，可在链表操作时提供便利。关于第一结点的问题在后文会详细介绍。
  • 尾结点：链表中的最后一个结点，在单链表中其后驱结点的地址为NULL，也就是没有后驱结点。

链表需要一个LinkNode类型的变量（head）用来存储头结点地址，对于整个链表的操作往往都是从head保存的头结点开始。

链表还应该提供维护整个结点链路的基本操作算法（抽象数据结构）：

/*
* 链表类
*/
class LinkList {
	private:
		//头指针
		LinkNode *head;
		//链表的长度
		int length;
	public:
		//构造函数
		LinkList() {}
		//返回头指针
		LinkNode * getHead() {
			return this->head;
		}
		//初始化链表
		void  initLinkList() {}
		//按位置查询结点
		LinkNode * findNodeByIndex(int index) {}
		//从头创建链表
		void createFromHead(int n) {}
		//从尾建链表
		void createFromTail(int n) {}
		//按值查询结点
		LinkNode * findNodeByVal(dataType val) {}
		//后插入
		int instertAfter(dataType val,dataType data) {}
		//前插入
		int insertBefore(dataType val,dataType data) {}
		//按位置删除结点
		int delNode(dataType data) {}
		//删除所有结点
		void delAll() {}
		//显示所有
		void showSelf() {}
		//析构函数
		~LinkList() {
			this->delAll();
		}
};

2.1 初始化

链表由多个结点组成，因头结点没有前驱结点，所以需要一个变量存储其地址，此变量称为链表的head首地址。后续操作基本都是顺着首地址"顺滕摸瓜"。

当head为NULL时，说明此链表为空链表。一般会在初始化时，为head变量存储一个没有实际数据语义的标志性结点，也称为空白头结点。

所以初始化时，会有 2 种方案：

  • 设置 head为 NULL。建立一个空链表。

3.png

//初始化链表
void  initLinkList() {
	this->head=NULL;
}
  • 设置head指向一个没有实际数据语义的空白结点，此结点仅起到标志作用。

4.png

//初始化链表
void  initLinkList() {
	this->head=new LinkNode(0);
}

是否一定要提供一个标志性的空白头结点，这不是必须的，但是有了这个空白头结点后，会为链表的操作带来诸多的便利性。一般在描述链表时，都会提供空白头结点。

2.2 创建单链表

创建单链表有 2 种方案：

  • 创建过程中，新结点替换原来的头结点，成为新的头结点，也称为头部插入创建方案。如构建数据为{4,9,12,7}的单链表。

5.png

头部插入创建单链表后，数据在链表中的存储顺序和数据的逻辑顺序是相反的。如上图所示。

注：上述插入演示没有带空白结点。

代码实现：

//头部插入创建链表
void createFromHead(int n) {
	LinkNode *newNode,*p;
	p=this->head;
	for(int i=0; i<n; i++) {
		newNode=new LinkNode();
		//输入数据 
		cin>>newNode->data;
		//原头结点为新结点的后驱结点 
		newNode->next=p;
		//新结点成为新的头结点 
		p=newNode;
		}
}

添加 3 个结点，测试上述创建的正确性。

LinkList list;
list.createFromHead(3);
LinkNode * head= list.getHead();
cout<<"输出结点信息"<<endl; 
//显示第一个结点
cout<<head->data<<endl;
//显示第二个结点
cout<<head->next->data<<endl;
//显示第三个结点
cout<<head->next->next->data<<endl;

执行结果：

6.png

从结果可知，输入顺序和输出顺序是相反的。

  • 尾部插入创建单链表，创建时的新结点替换原来的尾结点。如构建数据为{4,9,12,7}的单链表。

7.png

尾部插入方案创建的单链表，数据在链表中的存储顺序和数据的逻辑顺序是一致，从而也能保证最终读出来顺序和输入顺序是一致的。

与头部插入创建算法不同，除了需要存储头结点的地址信息，尾部插入算法中还需要一个tail变量存储尾结点的地址。初始时，tail和head指向同一个位置。

代码实现：

//从尾建链表
void createFromTail(int n) {
	LinkNode *newNode,*p,*tail;
	//头结点地址
	p=this->head;
	//尾结点地址
	tail=this->head;
	for(int i=0; i<n; i++) {
		//构建一个新结点 
		newNode=new LinkNode(0);
		cout<<"请输入结点数据"<<endl;
		cin>>newNode->data;
		if(p==NULL) {
			//如果头结点为 NULL
			p=tail=newNode;
		} else {
			//原来的尾结点成为新结点的前驱结点
			tail->next=newNode;
			//新结点成为新的尾结点
			tail=newNode;
				}
			}
			this->head=p;
		}

测试尾部插入创建的正确性：

int main(){	
	LinkList list {};
	list.createFromTail(3);
	LinkNode * head= list.getHead();
	cout<<"输出结点信息"<<endl;
	//显示第一个结点
	cout<<head->data<<endl;
	//显示第二个结点
	cout<<head->next->data<<endl;
	//显示第三个结点
	cout<<head->next->next->data<<endl;
}

执行后的结果：

8.png

前文说过，初始化链表时，可以指定一个空白头结点作为链表的头结点。其意义在哪里？

可以在尾部创建插入算法中使用或不使用空白头结点了解一下代码的差异性 。上述尾部创建插入算法中，因链表是不带空白结点的，所以在创建新结点时，必须有如下一段代码：

if(p==NULL) {
	//如果头结点为 NULL
	p=tail=newNode;
}

因为刚开始时链表是空的，head和tail都是NULL，创建第一个新结点后，它即是头结点，也是尾结点，所以head和tail都需要指向此新结点。

9.png

后续再创建新结点后，head则不需修改，通用逻辑是：原来的尾结点成为新结点的前驱结点，新创建的结点成为新的尾结点。

10.png

如果在初始化链表时，已经指定了一个空白结点，则尾部创建插入算法中只需遵循通用逻辑便可。

//初始化链表时指定一个空白结点作为头结点
void  initLinkList() {
	this->head=new LinkNode(0);
}

尾部创建插入算法可修改为：

void createFromTail_(int n) {
	LinkNode *newNode,*p,*tail;
	//头结点地址
	p=this->head;
	//尾结点地址
	tail=p;
	for(int i=0; i<n; i++) {
		//构建一个新结点
		newNode=new LinkNode(0);
		cout<<"请输入结点数据"<<endl;
		cin>>newNode->data;		
		//原来的尾结点成为新结点的前驱结点
		tail->next=newNode;
		//新结点成为新的尾结点
		tail=newNode;
		}
	this->head=p;
}

初始链表时如果指定了空白头结点，就不需要考虑第一个结点的位置特殊性。

本文后续的算法都是基于带空白头结点的链表的操作。

2.3 查询链表

链表中的常用查询操作有 3 种方案：

  • 按结点所在位置查找。
  • 按结点的值查找。
  • 查询链表中的所有结点。
2.3.1 按结点位置查找

设链表的头结点为编号为 0的结点，当给定编号 i 后，从头结点一至向后报数似的进行查找，至到找到与给定i值相同的结点 。

//按位置查询结点
LinkNode * findNodeByIndex(int index) {
	int j=0;
	LinkNode *p=this->head;
	if(index==j)
		//如果 index 值为 0 ，返回头结点
		return p;
	p=p->next;
	while( p!=NULL && j<index) {
			p=p->next;
			j++;
	}
	if(j==index)return p;
	else return NULL;
}
2.3.2 按结点的值查找

扫描链表中的每一个结点，比较那一个结点的值和给定的参数值相同。

//按值查询结点
LinkNode * findNodeByVal(dataType val) {
	//如果不带空白结点，则从头结点开始查找
	LinkeNode *p=this->head;
	whil(p!=null && p->data!=val ) {
		p=p->next;
	}
	if(p!=NULL) {
		return p;
	} else {
		return NULL;
	}
}

如果链表带有空白头结点，可以从头结点的后驱结点开始查找。

LinkeNode *p=this->head->next;

因为是按值比较，所以，无论链表是否带有空白头结点，都可以从头结点开始进行查找，对结果没有影响。

2.3.3 查询所有

不带空白头结点遍历操作：

//显示所有
void showSelf() {
    if(this->head==NULL)return;
	LinkNode *p=this->head;
	while(p!=NULL) {
		cout<<p->data<<"\t";
		p=p->next;
	}
}

带空白头结点的遍历：

//显示所有
void showSelf() {
    if(this->head==NULL)return;
	LinkNode *p=this->head->next;
	while(p!=NULL) {
		cout<<p->data<<"\t";
		p=p->next;
	}
}

2.4 插入

链表创建好后，后续维护过程，难免时时需要插入新的结点。插入时可以如前文在创建链表时一样，在头部插入和尾部插入。这里的插入指在链表的某个中间位置插入新结点。

  • 后插入。
  • 前插入。
2.4.1 后插入

所谓后插入，指新结点插入到某个已知结点的后面。如下图所示：

11.png

如果把值为 10 的新结点插入到值为 9的结点之后，称为后插入。后插入的通用逻辑：

  • 查找到值为9的结点地址，称为 p结点。

  • 创建新结点。

  • 指定新结点n的后驱结点为p的后驱结点。

    n->next=p->next;

12.png

  • 指定p的后驱结点为新结点n。

    p->next=n;

13.png

代码实现：

//后插入
int instertAfter(dataType val,dataType data) {
	//按值查找到结点 
	LinkNode *p=this->findNodeByVal(val);
	if (p==NULL){
		return false;
	}
	LinkNode *n=new LinkNode(0);
	n->data=data;
	n->next=p->next;
	p->next=n;
	return true;
}

测试后插入操作：

int main(int argc, char** argv) {
	LinkList list {};
	//创建值为 1 ，2 ，3 的 3 个结点
	list.createFromTail(3);
	//在值为 2 的结点后面插入一个值为5 的新结点
	list.instertAfter(2,5);
	//在链表中查看是否存在值为 5 的结点
	list.showSelf();
	return 0;
}

执行后输出结果：

14.png

2.4.2 前插入

所谓前插入，指新结点插入到某个已知结点的前面。如下图所示：

15.png

如果把新结点n插入到已知结点p的前面，则称为前插入。前插入的通用逻辑：

  • 除了要查找到p结点在链表中的地址，还需要知道p结点的前驱结点p1的地址。

16.png

  • 创建新结点，然后指定新结点n的后驱结点为p结点。

17.png

  • 指定结点p1的后驱结点为新结点n。

18.png

代码实现：

/前插入
int insertBefore(dataType val,dataType data) {
	//按值查找到结点
	LinkNode *p=this->findNodeByVal(val);
	//查找前驱结点
	LinkNode *p1=this->head;
	while(p1->next!=p){
		p1=p1->next;
	} 
	//构建新结点
	LinkNode *n=new LinkeNode(0);
	n->data=data;
	//新结的点的后驱为 p 结点
	n->next=p;
	//重设 p1 的后驱为 n
	p1->next=n; 
}

测试前插入操作：

int main(int argc, char** argv) {
	LinkList list {};
	//创建值为 1 ，2 ，3 的 3 个结点
	list.createFromTail(3);
	//在值为 2 的结点前面插入一个值为5 的新结点
	list.insertBefore(2,5);
	//在链表中查看是否存在值为 5 的结点
	list.showSelf();
	return 0;
}

执行后输出结果：

19.png

如果仅仅是关心数据在链表中的逻辑关系，则可以先把新结点n插入到结点p的后面，然后交换 2 个结点中的数据。

2.5 删除

删除算法包括：

  • 删除某一个结点。
  • 删除所有结点，也称为清空链表。
2.5.1 删除结点

删除结点的基本思路：

  • 在链表中查找到要删除的结点p。

20.png

  • 找到p结点的前驱结点p1。

21.png

  • 指定 p1的后驱结点为 p的后驱结点。

    p1->next=p->next;

22.png

编码实现：

//按值删除结点
int delNode(dataType data) {
    //按值查找到要删除的结点
    LinkNode *p= this->findNodeByVal(data);
    if (p==NULL)return false;
    //查找前驱结点
    LinkNode *p1=this->head;
    while(p1->next!=p)p1=p1->next;
    //删除操作
    p1->next=p->next;
    p->next=NULL;
    delete p;
    return true; 
}

测试删除操作：

int main(int argc, char** argv) {
	LinkList list {};
	//创建值为 1 ，2 ，3 的 3 个结点
	list.createFromTail(3);
	//删除值为 2 的结点 
    list.delNode(2);
	list.showSelf();
	return 0;
}

输出结果：

23.png

2.5.2 清空链表

清空链表指删除所有结点。从头结点开始扫描，找到一个删除一个，真到没有结点为止。

void delAll() {
	LinkNode *p=this->head;
	//临时结点
	LinkNode *p1;
	while(p!=NULL) {
		//保留删除结点的后驱结点
		q=p->next;
		delete p;
		p=q;
	}
		this->head=NULL;
}

测试：

int main(int argc, char** argv) {
	LinkList list {};
	//创建值为 1 ，2 ，3 的 3 个结点
	list.createFromTail(3);
	//没删除之前
	cout<<"清除之前:"<<endl; 
	list.showSelf();
	//清除链表
	list.delAll();
	//显示 
	cout<<endl<<"清除之后："<<endl;
	list.showSelf();
	return 0;
}

输出结果：
24.png

2.6 时间复杂度分析

在链表中查询的时间复杂为 O(n)。

在链表中进行插入操作时，先要查找到结点，如果不计查找时间，仅从插入算法本身而言，后插入算法时间复杂度为O(1)。因前插入算法需要要查找前驱结点，时间复杂度为O(n)。

删除结点时同样需要查找到被删除结点的前驱结点，时间复杂度为O(n)，如果是删除某个结点的后驱结点，时间复杂度为O(1)。

通过上述的基本操作得知：

  • 单链表上插入、删除一个结点，需要知道其前驱结点的地址。
  • 单链表不具有按序号随机访问的特点，只能从头结点开始依次查询。

3. 总结

本文主要讲解单链表的概念以及基于单链表的基本操作算法，除了单链表，还有循环链表、双向链表，将在后继博文中再详细讨论。无论链表的结构如何变化，单链表都是这种变化的始端。

一枚大果壳
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表的遍历
2401_83430041的博客
04-13 268
链表的遍历
遍历链表
qq_43318548的博客
04-03 4560
对某一数据结构中所有元素按照某种次序注意访问，称为对该数据结构的“遍历”。 案例 分析 输出链表中每一个结点值的函数原型设计为： void print(Node *head); 其中，形式参数head表示获得要输出链表的头指针。 在实现这个函数式，需要黄色至一个指向当前节点的指针P，期初至就是链表的头指针head。当p不不为空（即P指向一个实际存在的结点）时，输出数据元素值p->data，然...
链表（四）遍历链表
m0_60977861的博客
03-17 7440
从链表头开始，涉及整个链表，在每个结点上操作的过程称为遍历链表 假设链表的链表头指针是namelist，要遍历链表，则需要另一个指针ptr指向链表的开头。 listnode* ptr = head; 然后可以使用表达式*ptr或者结构指针操作符->处理由ptr指向的结点。 需要打印节点上的值 cout << ptr->name << endl; 一旦该节点打印完毕，那么指针将会移动到下一个节点 ptr = ptr -> next1; 以上语句
C日志-链表
qq_41729472的博客
09-04 346
链表
单链表-C++数据结构之单链表实现.zip
最新发布
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
使用C++实现链表数据结构之单链表.zip
03-13
本主题将深入探讨如何使用C++语言实现单链表。单链表是链表的一种基本形式，每个节点包含数据和指向下一个节点的指针。 首先，我们需要定义链表节点的结构体。在C++中，这通常通过以下方式完成： ```cpp struct ...
c++设计模式-行为型模式-责任链模式
06-19
c++设计模式-行为型模式-责任链模式；qt工程；c++简单源码； 责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的...
C++实现单链表的构造
08-19
C++实现单链表的构造 在计算机科学中，链表是一种非常重要的数据结构，它能够动态地分配和释放内存，从而提高程序的效率和灵活性。今天，我们将详细介绍C++实现单链表的构造，包括链表的定义、常用函数的实现、链表...
C++使用模板实现单链表
08-26
C++使用模板实现单链表 C++语言提供了模板（template）机制，允许开发者定义通用的数据结构和算法，以满足不同的数据类型需求。在本文中，我们将展示如何使用模板实现一个单链表，具有一定的参考价值。 模板类的...
单链表的简单讲解
qq_60394113的博客
07-23 5908
这次分享的是数据结构中单链表的创建和基本操作，这一部分是属于比较基础的内容，越是基础的越要投入精力去学习，不能眼高手低。在编写这篇博客的时候也出现了许多错误，这也算是一篇查漏补缺的博客。希望对大家有帮助。常规定义下的单链表，一般会包含数据域和指针域。intdata;//数据域structnode*next;//指针域}node,*linklist;//structnode可以用node替换structnode*可以用linklist替换//例如node和。node。...
c++ 链表操作：添加、遍历、删除、查找
热门推荐
yes1cpp的专栏
02-09 1万+
链表是一种动态数据结构，因为在创建链表的时候，无需知道链表的长度。链表的每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 struct node { int value; node* next; }; 当插入一个结点的时候，我们只需要为新结点分配内存，然后调节结点的指针指向，新结点就被（逻辑上）链接到链表里。 /* 链表尾加入新元素*/
单向链表的创建与遍历
qq_38929433的博客
02-23 213
单向链表： 特点： 链表是以节点的方式存储的，每个节点包含data域和next域，而next指向下一个节点。 链表的各节点不一定是连续存储的 分为带头节点链表和不带头节点链表。 添加与遍历： 1、先创建一个head头节点，表示单链表的头。 2、之后每添加一个节点，就直接加入到链表的最后。 3、通过一个辅助变量temp，帮助遍历这个链表。 如图所示： 代码实现： ...
链表，遍历链表，结构体指针
X@IAS
03-17 1072
文章：http://blog.csdn.net/lionpku/article/details/44278803 的链表版本。 代码如下： #include using namespace std; //敌舰结构体 struct EnemySpaceShip { int x_coordinate; int y_coordinate; int weapon_power; EnemyS
C语言链表的创建和遍历
鹈鹕门将的博客
03-20 1万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它
单链表的创建、遍历、与增删改查
qq_43161124的博客
10-01 5409
前言：我先这篇文章的目的是为了分享自己所学的东西。 链表是一种很常见的数据结构，但是因为与指针的结合，使得它变得让人头疼，初学者往往会被其搞得晕头转向，好了废话不多说下面开始。 1、创建链表 首先是创建链表，这个大家应该都会 2、初始化链表 num所代表的是节点的个数。初始化链表是最让我头晕的一个部分了，不过理解了之后还是挺简单的。我们首先要做的就是先申请新节点，然后将新节点的指针域置为空，之后...
单链表的遍历和逆转
wisgood的专栏
02-23 985
public class Test { public static void main(String[] args) { LNode linklist = new LNode("a"); LNode b = new LNode("b"); LNode c = new LNode("c"); LNode d = new LNode("d"); LNode e = new
有头单链表怎么变成无头单链 表 详细举例 不适用C++
05-24
假设有一个头节点为 head，我们需要将它变成无头单链表。 1. 首先，我们定义一个指针变量 p，让它指向头节点。 2. 然后，我们将头节点的指针域赋值给头节点，即 head = head->next。 3. 最后，我们释放指针变量 p 的内存空间，即 free(p)。 以下是详细的代码实现： ```c // 定义单链表结构体 typedef struct Node { int data; struct Node *next; } Node; // 将头节点变为普通节点 void removeHeadNode(Node **head) { if (*head == NULL) { return; } Node *p = *head; *head = (*head)->next; free(p); } ``` 在上面的代码中，我们首先定义了一个单链表结构体 Node，其中包含了数据域 data 和指针域 next。 然后，我们定义了一个函数 removeHeadNode，这个函数接受一个指向头节点指针的指针，即指向指针的指针。这样做是因为我们需要修改头节点指针的值，而指针是传值调用的，不会对原指针进行修改。 在函数中，我们首先对头指针进行非空判断，然后定义一个指针变量 p 并让它指向头节点。接着，我们将头节点的指针域赋值给头节点，即 head = head->next，这样就把头节点变成了普通节点。最后，我们释放指针变量 p 的内存空间，即 free(p)。 这样，我们就将一个带头节点的单链表变成了一个不带头节点的单链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一枚大果壳

码文不易，晚上熬夜需要点咖啡钱

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

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

打赏作者

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

抵扣说明：

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

余额充值