无头节点--单链表

已于 2022-04-01 17:51:00 修改
阅读量2k 收藏 14
点赞数 13
分类专栏： 【数据结构学习】 文章标签： 数据结构
于 2022-04-01 17:39:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53010164/article/details/123893321
版权

目录

一、单链表打印：

 二、增容

三、单链表尾插

四、单链表头插

五、单链表尾删

六、单链表头删

七、单链表的查找

八、单链表在pos之后插入X

九、单链表在pos之前插入X

十、删除pos位置

十一、删除pos之后的位置

十二、销毁链表

总代码：

Slistexe.h

Slistexe.c

test.c

 部分运行结果：​

一、单链表打印：

//打印
void SListprint(SL* phead)
{
	SL* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

 二、增容

//增容
struct SListNode* SListBuyNode(DataType x)
{
	//创建一个节点
	struct SListNode* newnode = (struct SListNode*)malloc(sizeof(struct SListNode));
	if (newnode == NULL)
	{
		printf("malloc failed\n");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->data = x;
}

三、单链表尾插

//单链表尾插
void SListPushBack(SL** phead,DataType x)
{
	assert(phead);//检查头指针的地址是否为空
	//如果头指针为空，那么就新建一个节点
	struct SListNode* newnode = SListBuyNode(x);
	//如果头指针指向NULL的情况
	if(*phead == NULL)
	{
		//进行增容
		*phead = newnode;
	}
	//如果头指针不指向NULL的情况
	else
	{
		//寻找到尾部,再尾部将值插入
		SL* cur = *phead;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		//将新建节点链接到尾节点后面
		cur->next = SListBuyNode(x);
	}
}

四、单链表头插

//单链表头插
void SListPushFront(SL** phead, DataType x)
{
	assert(phead);
	//如果头指针指向NULL或者不为NULL都可以
	struct SListNode* cur = *phead;
	//创建一个节点
	struct SListNode* newnode = SListBuyNode(x);
	newnode->next = cur;
	*phead = newnode;
}

五、单链表尾删

分为三种情况：头指针指向NULL,只有一个节点，有多个多个节点

//单链表尾删
void SListPopBack(SL** phead)
{
	//如果头指针指向NULL
	assert(*phead);

	//如果只有一个节点的问题,尾删
	if ((*phead)->next == NULL)
	{
		free(*phead);
		*phead = NULL;
	}
	else//多个节点的情况
	{
		//寻找尾的前一个和尾
		struct SListNode* tail = *phead;
		struct SListNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		prev->next = tail->next;
		free(tail);
		tail = NULL;
	}
}

六、单链表头删

//单链表头删
void SListPopFront(SL** phead)
{
	assert(phead);
	//如果头指针指向NULL
	assert(*phead);
	//如果只有一个节点和多个节点的情况
	SL* cur = *phead;
	*phead = cur->next;
	free(cur);
	cur = NULL;
}

七、单链表的查找

//单链表的查找
SL* SListFind(SL* phead,DataType x)
{
	SL* tail = phead;
	//从头找到尾
	while (tail)
	{
		if (tail->data == x)
		{
			return tail;
		}
		tail = tail->next;
	}
	//没找到
	return NULL;
}

八、单链表在pos之后插入X

//单链表在pos之后插入X
void SListPosAfter(SL* pos,DataType x)
{
	//创建一个新节点
	struct SListNode* newnode = SListBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

九、单链表在pos之前插入X
 

void SListPosPrev(SL** phead,SL* pos,DataType x)
{
	assert(phead);
	//pos的位置不能NULL
	assert(pos);
	//创建一个新节点
	struct SListNode* newnode = SListBuyNode(x);
	
	//如果pos指向NULL的情况,也就是pos == *phead
	if (pos == *phead)
	{
		*phead = newnode;
		(*phead)->next = pos;
	}
	else//多个节点的情况
	{
		SL* cur = *phead;
		SL* prev = NULL;
		//要找到pos前一个位置
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

十、删除pos位置

//删除pos位置
void SListErase(SL** phead,SL* pos)
{
	assert(pos);
	assert(phead);
	//如果只有一个节点pos == *phead
	if (pos == *phead)
	{
		*phead = pos->next;
		free(pos);
		pos = NULL;
	}
	else
	{
		//多个节点的情况
		SL* cur = *phead;
		SL* prev = NULL;
		//要找到pos前一个位置
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

十一、删除pos之后的位置

//删除pos之后的位置
void SListEraseAfter(SL* pos)
{
	assert(pos && pos->next);//pos位置不为NULL,并且pos后面的位置不为NULL，才能删除pos后面的位置
	SL* PosAfter = pos->next;
	pos->next = PosAfter->next;
	free(PosAfter);
	PosAfter = NULL;
}

十二、销毁链表

//销毁链表
void SListDestory(SL** phead)
{
	SL* tail = *phead;
	while (tail)
	{
		tail = tail->next;
		free(*phead);
		*phead = tail;
	}
}

总代码：

Slistexe.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;
typedef struct SListNode
{
	DataType data;
	struct SListNode* next;
}SL;

//单链表打印
void SListprint(SL* ps);
//单链表尾插
void SListPushBack(SL** ps,int x);
//单链表头插
void SListPushFront(SL** phead, int x);
//单链表头删
void SListPopFront(SL** phead);
//单链表头删
void SListPopFront(SL** phead);
//单链表的查找
SL* SListFind(SL* phead, DataType x);
//单链表在pos之后插入X
void SListPosAfter(SL* pos, DataType x);
//单链表在pos之前插入X
void SListPosPrev(SL** phead, SL* pos, DataType x);
//删除pos位置
void SListErase(SL** phead, SL* pos);
//删除pos之后的位置
void SListEraseAfter(SL* pos);
//销毁链表
void SListDestory(SL** phead);

Slistexe.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SListexe.h"
//增容
struct SListNode* SListBuyNode(DataType x)
{
	//创建一个节点
	struct SListNode* newnode = (struct SListNode*)malloc(sizeof(struct SListNode));
	if (newnode == NULL)
	{
		printf("malloc failed\n");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->data = x;
}

//打印
void SListprint(SL* phead)
{
	SL* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

//单链表尾插
void SListPushBack(SL** phead,DataType x)
{
	assert(phead);//检查头指针的地址是否为空
	//如果头指针为空，那么就新建一个节点
	struct SListNode* newnode = SListBuyNode(x);
	//如果头指针指向NULL的情况
	if(*phead == NULL)
	{
		//进行增容
		*phead = newnode;
	}
	//如果头指针不指向NULL的情况
	else
	{
		//寻找到尾部,再尾部将值插入
		SL* cur = *phead;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		//将新建节点链接到尾节点后面
		cur->next = SListBuyNode(x);
	}
}
//单链表头插
void SListPushFront(SL** phead, DataType x)
{
	assert(phead);
	//如果头指针指向NULL或者不为NULL都可以
	struct SListNode* cur = *phead;
	//创建一个节点
	struct SListNode* newnode = SListBuyNode(x);
	newnode->next = cur;
	*phead = newnode;
}
//单链表尾删
void SListPopBack(SL** phead)
{
	//如果头指针指向NULL
	assert(*phead);

	//如果只有一个节点的问题,尾删
	if ((*phead)->next == NULL)
	{
		free(*phead);
		*phead = NULL;
	}
	else//多个节点的情况
	{
		//寻找尾的前一个和尾
		struct SListNode* tail = *phead;
		struct SListNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		prev->next = tail->next;
		free(tail);
		tail = NULL;
	}
}
//单链表头删
void SListPopFront(SL** phead)
{
	assert(phead);
	//如果头指针指向NULL
	assert(*phead);
	//如果只有一个节点和多个节点的情况
	SL* cur = *phead;
	*phead = cur->next;
	free(cur);
	cur = NULL;
}
//单链表的查找
SL* SListFind(SL* phead,DataType x)
{
	SL* tail = phead;
	//从头找到尾
	while (tail)
	{
		if (tail->data == x)
		{
			return tail;
		}
		tail = tail->next;
	}
	//没找到
	return NULL;
}
//单链表在pos之后插入X
void SListPosAfter(SL* pos,DataType x)
{
	//创建一个新节点
	struct SListNode* newnode = SListBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
//单链表在pos之前插入X
void SListPosPrev(SL** phead,SL* pos,DataType x)
{
	assert(phead);
	//pos的位置不能NULL
	assert(pos);
	//创建一个新节点
	struct SListNode* newnode = SListBuyNode(x);
	
	//如果pos指向NULL的情况,也就是pos == *phead
	if (pos == *phead)
	{
		*phead = newnode;
		(*phead)->next = pos;
	}
	else//多个节点的情况
	{
		SL* cur = *phead;
		SL* prev = NULL;
		//要找到pos前一个位置
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

//删除pos位置
void SListErase(SL** phead,SL* pos)
{
	assert(pos);
	assert(phead);
	//如果只有一个节点pos == *phead
	if (pos == *phead)
	{
		*phead = pos->next;
		free(pos);
		pos = NULL;
	}
	else
	{
		//多个节点的情况
		SL* cur = *phead;
		SL* prev = NULL;
		//要找到pos前一个位置
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos之后的位置
void SListEraseAfter(SL* pos)
{
	assert(pos && pos->next);//pos位置不为NULL,并且pos后面的位置不为NULL，才能删除pos后面的位置
	SL* PosAfter = pos->next;
	pos->next = PosAfter->next;
	free(PosAfter);
	PosAfter = NULL;
}
//销毁链表
void SListDestory(SL** phead)
{
	SL* tail = *phead;
	while (tail)
	{
		tail = tail->next;
		free(*phead);
		*phead = tail;
	}
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SListexe.h"
void test1()
{
	SL* s1 = NULL;//初始化
	//SListPushBack(&s1,1);
	//SListPushBack(&s1, 2);
	//SListPushBack(&s1, 3);
	SListPushFront(&s1,4);
	SListPushFront(&s1, 3);
	/*SListprint(s1);*/
	/*SListPushFront(&s1, 4);*/
	//SListPopFront(&s1);
	//SListPopFront(&s1);
	
	SL* pos = SListFind(s1,3);
	if (pos)
	{
		SListPosAfter(pos,20);
		SListPosPrev(&s1,pos,30);
		/*SListErase(&s1,pos);*/
		/*printf("%d",pos->data);*/
		SListEraseAfter(pos);
	}
	SListprint(s1);
}
int main()
{
	test1();
}

 部分运行结果：

本篇为无头结点单链表篇，如有问题，请大家在评论区多多评论，共同学习O(∩_∩)O

@@永恒
关注
专栏目录
【数据结构】-单链表(无头结点）
RunningSnail的博客
07-18 5152
单链表-无头结点1.头文件及类型定义2.单链表结点类型定义3.函数声明4.基本操作4.1 初始化单链表4.2 判空4.3 插入操作4.3.1 按位插入4.3.2 指定结点插入4.3.2.1 指定结点后插4.3.2.2 指定结点前插4.3.2.2.1 前插法1(时间复杂度为O(n))4.3.2.2.2 前插法2(时间复杂的为O(1))4.4 删除操作4.4.1 按位删除4.4.2 指定结点删除4.4.2.1 删除法1(时间复杂度为O(n))4.4.2.2 删除法2(时间复杂度为O(1))4.5 查找操作4.5
【数据结构】单链表详解-无头单向不循环链表
p2141548684的博客
05-20 457
链表是一种物理存储上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。单链表、双链表和循环链表。单向、双向、带头、不带头、循环、不循环。链表的八种带头单向循环链表、带头单向非循环链表、带头双向循环链表、带头双向非循环链表、无头单向循环链表、无头单向非循环链表、无头双向循环链表、无头双向非循环链表。
无头节点的单链表
07-17
无头节点单链表的实现可是说是对C语言指针一个最直接、最贴合实际、也是最具有归纳性的程序设计应用。许多C语言基础面试题都涉及单链表的实现和构造，其目的就是考察面试者对C语言基础数据类型是否有足够的了解，对C语言指针是否掌握。链表的实现可以简单也可以很复杂，只是我们对待问题的态度不同，回想起了大学刚学习链表的时候，总是对链表中用到的结构体和链表节点有很多的迷茫，直到后来仔细研究了一番，并且写下了这个代码才解开了心中很久的困惑。 回看了一下自己写的这个单链表的实现，注释写的非常详细了，包括了单链表中二级指针的应用场景，为什么要使用二级指针这些问题都有一个详细的总结，也包括链表节点的结构体和学生个人信息结构体的这些区分。可以说是楼主就是从这个阶段才正真开始对结构体，对指针，对链表的“数据域”，“指针域”有了较为清晰的了解。 上传这些代码完全因为楼主确实想把自己学习过程中的遇到到一些问题和错误认识，以及一些经验共享出来，希望帮助那些和曾经的我一样充满迷茫困惑的同学朋友。
无头结点的单链表
明里灰的博客
03-21 610
先来了解头结点是什么：头结点是在首元结点之前设的一个结点，其 next 指针指向首元结点，其数据域可以不存储任何信息，但是头结点一定指向是链表中第一个结点的指针，而且头指针不能变。无头结点时，如果增加的元素放在第一个结点前，或者删除第一个结点时，要换新的首元结点，此时要用到二级指针。有头结点时，对链表的第一个数据元素的操作（插入、删除）与其他的数据元素相同，无需进行特殊处理。无论链表是否为空，头指针都是非空指针，指向首元结点。首先，无头结点的链表和有头结点的链表有什么区别呢？
单链表（无头结点）（C/C++）
最新发布
a770067334的博客
08-30 805
2.带头结点的单链表，无论单链表是否为空链表，头指针都指向头结点。不带头结点的单链表，当单链表为非空链表时，头指针指向链表第一个结点(LNode)，当单链表为空链表时，头指针指向空（NULL）。1.当对单链表的表首元素进行删除或插入操作时，要进行区别处理，无头结点的单链表进行头指针的更新。38 34 12 45 43 89 6 76 此单链表的长度为：8。带头结点与不带头结点的单链表，在进行操作时有哪些区别呢？后插操作：在p结点之后插入元素e。前插操作：在P结点之前插入元素e。在第i个位置插入元素e。
无头结点的单链表（C语言）
weixin_33863087的博客
09-22 3157
1.单链表： 　　在顺序表中，用一组地址连续的存储单元来一次存放线性表的结点，因此结点的逻辑顺序与物理顺序是一致的。但链表却不同，链表是用一组任意的存储单元来存放 线性表的结点，这组存储单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此，链表中结点的逻辑顺序与物理顺序不一定相同。为了正确表示节点间的逻辑关系，必须在存储线性表的每个数据元素的同时，存储指示其后继结点的地址信...
单链表（不带头结点）
qq_39628738的博客
02-19 6085
单链表不带头结点结构体设计： //不带头结点的结构体设计： typedef int ELEM_TYPE; //有效数据节点结构体设计 typedef struct Node { ELEM_TYPE data;//数据域 （1.头结点：不保存任何数据 2.有效数据节点：保存有效值） struct Node* next;//指针域 (1.头结点：保存第一个元素的地址 2.有效数据节点：保存下一个有效元素的地址) }Node, * PNode; 老规矩，实现链表的基本功能：增删
单链表的两种简单实现（有头节点和无头节点）
12-09
在本文中，我们将深入探讨单链表的两种简单实现：有头节点和无头节点。这两种方法虽然看似微小的区别，但在实际编程中可能会产生显著的影响。 首先，我们来理解链表的基本概念。链表不像数组那样在内存中连续存储...
数据结构-（无头结点）单链表的基本操作实现----------随笔记录（3）
yaoyao_ju的博客
04-06 1635
无头结点的单链表的基本操作
2.3.1 单链表无头结点
SJMP
10-28 1002
/* bo2-8.c 不带头结点的单链表(存储结构由c2-2.h定义)的部分基本操作(9个) */  #define DestroyList ClearList /* DestroyList()和ClearList()的操作是一样的 */  void InitList(LinkList *L)  { /* 操作结果：构造一个空的线性表L */    *L=NULL; /* 指针为空 */
小白学编程之单向链表（无头节点）
Super_Market_Z的博客
08-20 882
小白学编程之单向链表（无头节点）
无头结点的单链表的c算法的实现
11-02
无头结点的单链表的c算法的实现，里面有验证程序可以参考，在调试中通过。
无头结点单链表
jyunlon的专栏
10-21 663
#include using namespace std; typedef struct LNode { int data; LNode *next; }LNode,*LList; //LList（实质为LNode*）的无头结点表头 bool isEmptyLList(LList L) { //判断是否空表 if (L) return false; else return t
无头结点的链表
qq_40912965的博客
05-02 266
数据结构 无头结点的单链表
kira_981019的博客
03-15 2429
---------------start reading--------------- 前言 头结点是用来标记单链表的一个标志，有些时候我们可以不使用头结点，这时候操作就完全不一样了。 如何建立一个无头结点的单链表？不能在头结点的数据域中放数据再变成假的第一个数据节点在进行操作，那是自己骗自己。 在单链表中我们直接头结点进行解引用，但无头结点的链表最初其实就是一个指针，没有指向任何结点，在进行插入...
数据结构 严薇敏 单链表（无头结点）的实现(增 删 改 查)及其使用方法详解
qq_50119037的博客
03-19 1698
1.与顺序表的对比 书接上回！我们修炼了顺序表的内功，但是在很多使用场景，他都很受限制！ 缺点： 插入删除的时候，还记得吗！我们都要搬运元素到指定位置，时间复杂度是O(N). 你的顺序表容量是提前给的，扩容的时候还要拷贝数据，开辟新空间，释放旧空间，会有很大的性能消耗。 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。若每次扩容扩少一点，则会导致频繁扩容，频繁扩容同样也会有性能消耗
无头结点链表
qq_38417856的博客
02-20 353
linklist.c文件: #include<stdio.h> #include"linklist.h" struct Node* Create_LinkList()//Creat_Linklist:根据用户输入,创建一个单链表 { ElemType num; struct Node* first=NULL; struct Node* last=NULL; while (1) { sc...
无头结点的单链表的实现
yahid的博客
05-09 3959
链表是基于顺序表之后的一种更加高效的数据结构，他能够有效的增删改查，比顺序表的效率提高了很多。下面我们来实现这一数据结构。 不光是实现，我们还需要通过几个功能来加深大家对链表的理解，这列功能包括链表中的节点我们都设置在一个Linkedlist类里面 public class Linkedlist { } 然后让主类来实现它Linkedlist类里面的方法 public class MyLinkedlist { public static void main(String[] args)
无头节点的单链表代码
08-18
### 回答1： 以下是一个示例无头节点的单链表代码，包括节点的定义、插入、删除、查找和输出操作： ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next class LinkedList: def __init__(self): self.head = None def insert(self, val): new_node = ListNode(val) new_node.next = self.head self.head = new_node def delete(self, val): prev = None curr = self.head while curr is not None and curr.val != val: prev = curr curr = curr.next if curr is not None: if prev is None: self.head = curr.next else: prev.next = curr.next def search(self, val): curr = self.head while curr is not None and curr.val != val: curr = curr.next return curr def print_list(self): curr = self.head while curr is not None: print(curr.val, end=' ') curr = curr.next print() ``` 在这个代码中，节点使用 `ListNode` 类来表示，每个节点包括一个值和一个指向下一个节点的指针。链表使用 `LinkedList` 类来表示，包括一个头节点 `head`，初始化为 `None`。 `insert` 方法用于在链表头部插入一个新节点，首先创建一个新节点，然后将它的 `next` 指针指向当前的头节点，最后将头节点指向新节点。 `delete` 方法用于从链表中删除一个值为 `val` 的节点，首先遍历整个链表找到要删除的节点，然后修改它前面节点的 `next` 指针即可。需要注意的是，如果要删除的节点是头节点，需要特殊处理。 `search` 方法用于在链表中查找一个值为 `val` 的节点，遍历整个链表即可。 `print_list` 方法用于按顺序输出整个链表中的节点值。 ### 回答2： 无头节点的单链表是指链表中没有一个特定的头节点，而是通过记录链表的第一个节点来代表整个链表的首部。下面是一个示例的无头节点的单链表的代码实现： ```python class ListNode: def __init__(self, value): self.value = value self.next = None class LinkedList: def __init__(self): self.head = None def is_empty(self): return self.head is None def insert(self, value): new_node = ListNode(value) if self.is_empty(): self.head = new_node else: current = self.head while current.next: current = current.next current.next = new_node def delete(self, value): if self.is_empty(): return if self.head.value == value: self.head = self.head.next return current = self.head while current.next: if current.next.value == value: current.next = current.next.next return current = current.next def search(self, value): if self.is_empty(): return False current = self.head while current: if current.value == value: return True current = current.next return False ``` 以上是无头节点的单链表的基本操作代码。链表包含两个类，ListNode 表示链表节点，LinkedList 表示链表本身。其中，insert 方法用于插入节点到链表尾部，delete 方法用于删除指定值的节点，search 方法用于查找链表中是否存在指定值的节点。 ### 回答3： 无头节点的单链表是指链表中没有头节点，只有数据节点。在这种情况下，我们需要自己实现链表的插入、删除、查找等操作。 定义一个节点类，用来表示链表的节点，该节点包含两个属性：数据和下一个节点的指针。 ```python class Node: def __init__(self, data=None): self.data = data self.next = None ``` 接下来，我们定义一个LinkedList类，该类包含一些对链表进行操作的方法。 ```python class LinkedList: def __init__(self): self.head = None def insert(self, data): new_node = Node(data) if self.head is None: self.head = new_node else: current = self.head while current.next is not None: current = current.next current.next = new_node def delete(self, data): if self.head is None: return if self.head.data == data: self.head = self.head.next return current = self.head while current.next is not None: if current.next.data == data: current.next = current.next.next return current = current.next def search(self, data): current = self.head while current is not None: if current.data == data: return True current = current.next return False def display(self): current = self.head while current is not None: print(current.data, end=" ") current = current.next print() ``` 上述代码中，我们实现了插入、删除、查找和展示链表数据的方法。我们可以通过创建一个LinkedList对象并调用这些方法来操作链表。 需要注意的是，在无头节点的单链表中，我们需要特别处理链表的头部插入和删除操作。 这样，我们就完成了一个无头节点的单链表的实现。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值