链表操作总结

最新推荐文章于 2022-02-28 23:22:20 发布
原创 最新推荐文章于 2022-02-28 23:22:20 发布 · 287 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了动态链表的创建、节点插入、删除以及链表的反转、清空、升序插入等操作。通过示例代码详细展示了如何实现这些基本的链表操作，包括在特定节点前插入新节点、删除指定节点以及保持链表升序的插入方法。

声明

一年前闲着无聊时，研究研究了链表，当时写的时候也花了不少时间，当时我的思路如下

动态链表带头结点

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
}

	head->id =-1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout <<"请输入数据";
		cin>>data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
			if (pNew == NULL) {
				continue;
			}

		pNew->id = data;
		pNew->next = NULL;
		//链表建立关系
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一个有效结点，head的下一次结点
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout <<pCur->id<<"->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;
}

结点的插入

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
//在值为x的结点前，插入值为y的结点，若x结点不存在，则插在表尾
int increasenode(node* head, int x, int y)
{
	if (head == NULL)
	{
		return -1;
	}
	node* Pre = head;
	node* Cur = head->next;
	while (Cur != NULL)
	{
		if (Cur->id == x)
		{
			break;
		}
		Pre = Cur;
		Cur = Cur->next;
	}
	node* pNew = (node*)malloc(sizeof(node));
	if (pNew == NULL) {
		return -2;
	}
	pNew->id = y;
	pNew->next = NULL;

	Pre->next = pNew;
	pNew->next = Cur;
}

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "请输入数据";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//链表建立关系
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一个有效结点，head的下一次结点
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	int x; int y;
	cout << "分别输入x和y，在x的前面插入y" << endl;
	cin >> x >> y;
	increasenode(head, x, y);
	cout << "在x的前面插入y:";
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;

}

静态链表

#include <iostream>
using namespace std;
class node {
public:
	int id;
	char name[100];
	node* next;

};
int  main() {

	node s1 = { 1,"biaobiao",NULL };
	node s2 = { 2,"aha",NULL };
	node s3 = { 3,"leilei",NULL };
	s1.next = &s2;
	s2.next = &s3;
	s3.next = NULL;
	node* p = &s1;
	while (p != NULL) {
		cout << p->id << "   " << p->name << "   " << endl;
		p = p->next;
	}
}

链表反转

#include<iostream>
using namespace std;
 class node {
public:
	int id;
	node* next;
};
int noderexerse(node* head) {
	if (head == NULL || head->next == NULL || head->next->next == NULL)
	{
		return -1;
	}
	node* pre = head->next;
	node* cur = pre->next;
	node* temp=NULL;
	while (cur != NULL)
	{
		temp=cur->next;
		cur->next = pre;

		pre = cur;
		cur = temp;
	}
	head->next->next = NULL;
	head->next = pre;
	return 0;
}

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "请输入数据";
		cin >> data;
		if (data == -1) {
			break;
		}

		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//链表建立关系
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一个有效结点，head的下一次结点
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	noderexerse(head);
	cout << "反转后为：" << endl;
	ListPrint(head);
}

清空动态建立的链表

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
//清空链表
int destroynode(node* head) {
	if (head == NULL) {
		return -1;
	}
	node* temp = NULL;
	int i = 0;
	while (head != NULL)
	{
		temp = head->next;
		free(head);
		head = NULL;
		head = temp;
		i++;
	}
	cout << "释放次数为：" << i<<endl;
	return 0;
}
node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "请输入数据";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//链表建立关系
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一个有效结点，head的下一次结点
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	destroynode(head);
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;
}

删除第一个为x的结点

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
int freecode(node*head,int x)
{
	if (head == NULL)
	{
		return -1;
	}
	node* Pre = head;
	node* Cur = head->next;
	int flag = 0;//0没有找到，1找到了
	while (Cur != NULL)
	{
		if (Cur->id == x)
		{
			Pre->next = Cur->next;
			free(Cur);
			Cur = NULL;
			flag = 1;
			break;
		}
		Pre = Cur;
		Cur = Cur->next;
	}
	if (flag == 0)
	{
		cout << "没有值为" << x << "的结点" << endl;
		return -2;
	}


}
node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "请输入数据";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//链表建立关系
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一个有效结点，head的下一次结点
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	int x;
	cout << "请输入需要删除的结点" << endl;
	cin >> x;
	freecode(head, x);
	cout << "删除后结果为:" << endl;
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;

}

删除所有为x的结点

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
int freecode(node* head, int x)
{
	if (head == NULL)
	{
		return -1;
	}
	node* Pre = head;
	node* Cur = head->next;
	int flag = 0;//0没有找到，1找到了
	while (Cur != NULL)
	{
		if (Cur->id == x)
		{
			Pre->next = Cur->next;
			free(Cur);
			Cur = NULL;
			flag = 1;
			Cur = Pre->next;
			continue;
			//break;
		}
		Pre = Cur;
		Cur = Cur->next;
	}
	if (flag == 0)
	{
		cout << "没有值为" << x << "的结点" << endl;
		return -2;
	}


}
node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "请输入数据";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//链表建立关系
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一个有效结点，head的下一次结点
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	int x;
	cout << "请输入需要删除的结点" << endl;
	cin >> x;
	freecode(head, x);
	cout << "删除后结果为:" << endl;
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;

}

升序链表插入

#include<iostream>
using namespace std;
 struct node {

	int id;
	node* next;
};
//假如原来链表是升序 的，升序后插入新节点
//不能插入结点后再排序，是升序插入新节点x
int  insertnode(node* head, int x) {
	
	 if (head == NULL)
	 {
		 return -1;
	 }
	 node* Pre = head;
	 node* Cur = head->next;
	 while (Cur != NULL)
	 {
		 if (Cur->id > x)
		 {
			 break;
		 }
		 Pre = Cur;
		 Cur = Cur->next;
	 }
	 node* pNew = (node*)malloc(sizeof(node));
	 if (pNew == NULL) {
		 return -2;
	 }
	 pNew->id = x;
	 pNew->next = NULL;

	 Pre->next = pNew;
	 pNew->next = Cur;

  }
int  nodesort(node* head)
{
	if (head == NULL || head->next == NULL)
	{
		return 0;
	}
	node* pre = NULL;
	node* cur = NULL;
	node temp;
	for (pre = head->next; pre->next != NULL; pre = pre->next)
	{
		for (cur = pre->next; cur != NULL; cur = cur->next)
		{
			if (pre->id > cur->id)
			{
				temp.id = cur->id;
				cur->id = pre->id;
				pre->id = temp.id;
				/*
				temp = *cur;
				*cur = *pre;
				*pre = temp;
				temp.next = cur->next;
				cur->next = pre->next;
				pre->next = temp.next;*/
			}
		}
	}
	return 0;
}

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "请输入数据";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//链表建立关系
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一个有效结点，head的下一次结点
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	nodesort(head);
	int x;
	cout << "输入想要升序插入的数：" << endl;
	cin >> x;
	cout << "升序插入" << x << "后:" << endl;
	insertnode(head, x);
	ListPrint(head);
}

用链表进行排序

#include<iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
int  nodesort(node* head) {
	if (head == NULL || head->next == NULL)
	{
		return 0;
	}
	node* pre = NULL;
	node* cur = NULL;
	node temp;
	for (pre = head->next; pre->next != NULL; pre = pre->next)
	{
		for (cur = pre->next; cur != NULL; cur = cur->next)
		{
			if (pre->id > cur->id)
			{
				temp.id = cur->id;
				cur->id = pre->id;
				pre->id = temp.id;
				/*
				temp = *cur;
				*cur = *pre;
				*pre = temp;
				temp.next = cur->next;
				cur->next = pre->next;
				pre->next = temp.next;*/
			}
		}
	}
	return 0;
}

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "请输入数据";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//链表建立关系
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一个有效结点，head的下一次结点
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	nodesort(head);
	cout << "排序后为：";
	ListPrint(head);
}
直击高频编程考点：链表知识及经典算法题总结
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
10-24 5万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
链表基础操作总结
仙八哥的博客
03-09 594
链表的内存申请和释放
链表系列操作总结
dzpspace
05-14 215
/** * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ 基本操作 查 查找第 m 个 结点 增 在末尾加入结点 public void addNode(ListNode head, int val) { ListNod...
链表基本操作总结
lighter
04-08 1339
二、单链表     线性表的链式存储结构是用一组任意的存储单元存储线性表的数据元素，而非连续的存储单元。每个结点中既包含数据元素又包含指向后继结点的指针。通常我们会设置一个头指针指向单链表，有时为了算法的一致性，我们会在第一个结点之前附加一个头结点，头结点的数据域内可以不存放任何信息，也可存放诸如线性表长度之类的附加信息。 1、存储结构 typedef struct LNode
链表的基本操作总结
HanSion.Z
06-25 587
定义一个链表 typedef int DataType; typedef struct Node { DataType data; struct Node * next; }Node,*pNode,LinkList,*pLinkList; pLinkList list; 链表的操作接口 //初始化一个链表 void InitLinkList(pLinkList ...
链表操作大总结！！！
蹦跶跶
10-01 879
1.单链表 list.h #ifndef _LIST_H_ #define _LIST_H_ #include <iostream> using namespace std; typedef int ElementType;//数据类型 class Node{ public: Node(){next = NULL;} ElementType data; Node* next; }; class List{ public: List(); virtu
C语言中链表的操作，总结到位！
11-13
4. **头节点**：头节点的数据类型与首节点相同，但并不存放有效数据，主要用于简化链表操作。 5. **头指针**：指向头节点的指针。 6. **尾指针**：指向尾节点的指针。 #### 三、节点的定义 为了定义链表中的节点，...
链表题目总结1
08-03
此外，还有其他解题策略，如使用哈希表、栈等数据结构来优化链表操作。例如： - 在寻找环形链表的交点时，可以使用哈希表记录节点，当发现节点已存在则表明有环。 - 在判断链表是否相交时，可以用栈存储两个链表的...
一、静态链表的定义 二、静态链表的设计 三、静态链表的操作 总结 附录 前言 你认识静态链表吗？听起来是不是很陌
最新发布
09-13
三、静态链表的操作 总结 附录 前言 你认识静态链表吗？听起来是不是很陌生呢？本文将较为详细的向你介绍它，感兴趣的话就一起来看看吧。 一、静态链表的定义 逻辑结构上相邻的数据元素，存储在指定的一块内存...
单链表基本操作总结
m0_52464332的博客
04-06 219
单链表插入 /*************************************************** 思路： 1>声明一个指向头结点的指针P 2>遍历列表使P指向第i-1个结点 3>当p为空或j>i,则不存在。 4>生成空结点赋值并插入 *****************************************************/ Status LinkInsert(LinkInsert *L, int i, El
关于链表的一些操作总结
一个简单的故事
10-03 810
链表反转 这是一个简单的链表操作问题，在leetcode上面有52.7%的通过率，难度是简单。但是还是想在这里基于python做一下总结，顺便总结一下链表的各种操作。 首先先看一下leetcode上面的题目： 反转一个单链表。 示例: 输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL 输出: 5-&gt;4-&gt;3-&gt;2-&gt;1-&gt;NULL 进阶:...
链表基本操作（详解）
Czc1357618897的博客
11-30 1万+
链表的基本操作 这里写目录标题链表的基本操作一：单链表的基础知识二：单链表的建立头插法尾插法三：单链表的遍历四：单链表结点数目判断五：单链表的插入链表头插入任意结点插入链表尾部插入六：单链表的删除七 ：单链表的查询 一：单链表的基础知识 为什么需要链表？ 我们在使用数组存放数据是非常方便，但是由于数组的长度是固定的，所以当存储不同的元素数量时，就很容易出现问题。如果向数组中添加的数量大于数组大小时候，信息无法完全被保存。所以我们需要另一种存储方式来存储数据，其中存储的元素的个数不受限制。这种存储方式就是链
链表基础知识总结
闲适_
02-28 1万+
什么是链表 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点都包括两部分：一是数据域，用来存储元素数值数据，另一个是存储直接后继结点地址的指针域，该指针一般称为next，用来指向下一个结点的位置。由于下一个结点也是链表类型，所以next的指针也要定义为链表类型。 链表中的一些基本定义和特点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中存储的第一个数据元素的结
关于数据结构之单链表的C++实现
qq_43435984的博客
11-17 184
1、链表List的基本单元是节点Node，因此想要操作方便，就必须为每一步打好基础，Node的基本结构如下： class Node { public: int data; Node *next; Node(int da=0,Node *p=NULL) { this-&amp;amp;amp;amp;gt;data=da; this-&amp;amp;amp;amp;gt;next=p; } }; 我们可以看出，Node的成员变量一共有两个，都是public，因...
学习心得：链表的操作（C语言实现）
热门推荐
lpp0900320123的专栏
03-03 11万+
今天将给大家讲述链表的学习心得。学习数据结构，毋庸置疑链表必须学好，后面的栈、队列、树、图都是以链表为基础的；链表的种类很多，有单链表、双链表、循环链表、非循环链表；在此，我们以非循环单链表为例，来讲链表的创建、求长度、排序、插入和排序。 1.什么是链表      链表我的理解要包含以下特征：（1）.由n个节点离散分配；（2）.每个节点通过指针连接（3）每一个节点由一个前驱节点和一个后驱节点（
第二天-------单链表的基本操作，源码
可行的code
07-04 3284
一、 目的 1．掌握单链表的存储特点及其实现。 2．掌握单链表的插入、删除算法及其应用算法的程序实现。 二、内容 1、内容 编写一个完整的程序，实现单链表的生成、插入、删除、输出等基本操作。 （1）随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。 （2）计算单链表的长度，遍历单链表。 （3）把单链表中的元...
单链表的一些基本操作（自我总结）
weixin_45928836的博客
01-15 455
链表可分为两种 1.无头结点定义 2.有头节点定义 无头结点定义的链表： 它的第一个节点就开始储存数据，这样在进行后续某些操作时会造成一些不方便的地方。 （这是我从啊哈算法中看到的版本，没有分开函数去创立链表） #include using namespace std; //链表是由多个结构体组成，其中的指针指向的下一个结构体的地址 struct node{ int data; ...
数据结构：单链表（c++继承和复合的形式实现）
qq_43353709的博客
05-18 543
#include<iostream> using namespace std; class node { public: int data; node *next; node(int d=0,node *temp=NULL):data(d),next(temp) {} }; class nodelist :public node { protected: node *head...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

寻梦&之璐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值