链表的实现

最新推荐文章于 2024-09-26 18:42:37 发布
最新推荐文章于 2024-09-26 18:42:37 发布
阅读量64 收藏 4
点赞数 5
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79274600/article/details/134417421
版权

文章目录

一、概念

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

二、分类

根据单向双向、带头不带头、循环不循环可以分为8种链表结构。

1.单向或双向：

在这里插入图片描述

2.带头或不带头：

在这里插入图片描述

3.循环或不循环

在这里插入图片描述
虽然链表结构众多，但实际中最常用还是两种结构：无头单向不循环链表和带头双向循环链表。接下来我们来实现这两种链表。

在这里插入图片描述

三、无头单向不循环链表

1.SList.h

先在SList.h中声明需要用到的函数和结构体。

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLDataType;

typedef struct SListNode
{
	struct SListNode* next;
	SLDataType val;
}SLNode;

void SLPrint(SLNode* phead);
void SLDestory(SLNode* phead);

void SLPushBack(SLNode** phead, SLDataType x);
void SLPushFront(SLNode** phead, SLDataType x);
void SLPopBack(SLNode** phead);
void SLPopFront(SLNode** phead);

void SLInsert(SLNode** phead, SLNode* pos, SLDataType x);
void SLErase(SLNode** phead, SLNode* pos);

定义节点


typedef struct SListNode
{
	struct SListNode* next;
	SLDataType val;
}SLNode;

在单链表的节点的结构中我们需要一个指向下一节点的指针next，和存数据的val，这里用结构体实现，最后一个节点中的指针存NULL。

2.Slist.c

a.创建节点

SLNode* CreateSLNode(SLDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->next = NULL;
		newnode->val = x;
	}
	return newnode;
}

将节点的指针域置空，数据域存放指定的数据x。

b.打印链表

void SLPrint(SLNode* phead)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d=>", cur->val);
		cur = cur->next;
	}
	printf("\n");
}

从头节点开始打印节点中的数据，while循环保证打印到尾节点，此时cur为尾节点的下一个，为空。

c.销毁链表

void SLDestroy(SLNode** phead)
{
	assert(phead);

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

	*pphead = NULL;
}

free后记得置空，防止后续错误的解引用导致程序崩溃。

d.尾插

void SLPushBack(SLNode** phead, SLDataType x)
{
	SLNode* newnode = CreateSLNode(x);
	if (*phead == NULL)
	{
		*phead = newnode;
	}
	else
	{
		SLNode* cur = *phead;
		while (cur->next)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}

先判断链表中有没有节点，没有就令首节点为要插入的节点，有的话先找到尾节点，再使原先尾节点的指针指向要插入的节点。（创建节点时已经让节点指向空，所以不用再让插入的节点指向空）。这里用二级指针做形参是为了改变节点的指针，不使用二级指针的话也可以将函数的类型改写为返回节点一级指针的类型。

e.头插

void SLPushFront(SLNode** phead, SLDataType x)
{
	SLNode* newnode = CreateSLNode(x);
	if (*phead == NULL)
	{
		*phead = newnode;
	}
	else
	{
		newnode->next = *phead;
		*phead = newnode;
	}
}

和尾插同理，先检查首节点是否为空，注意头插后新节点成为首节点，所以要将新节点赋值给首节点。（*phead = newnode;）

f.尾删

void SLPopBack(SLNode** phead)
{
	assert(*phead);
	SLNode* cur = *phead;
	while (cur->next->next!=NULL)
	{
		cur = cur->next;
	}
	SLNode*next = cur->next;
	free(next);
	next = NULL;
	cur->next = NULL;
}

尾删找尾节点的前一个节点，将其指向空，原来的尾节点释放并置空。

g.头删

void SLPopFront(SLNode** phead)
{
	assert(*phead);
	SLNode* next = (*phead)->next;
	free(*phead);
		*phead = next;
}

将第二个节点赋值给原来的首节点。

h.找节点

SLNode* SLTFind(SLNode* phead, SLNDataType x)
{
	SLNode* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}

	return NULL;
}

i.定点插

void SLInsert(SLNode** phead, SLNode* pos, SLDataType x)
{
	assert(*phead && phead);
	if (pos == *phead)
	{
		SLPushFront(phead, x);
	}
	else
	{
		SLNode* cur = *phead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SLNode* newnode = CreateSLNode(x);
		cur->next = newnode;
		newnode->next = pos;
	}
}

先确保链表不为空，如果插入位置是首节点就直接调用前面的头插函数，不是就先找到pos的前一个节点，让pos前一个节点指向我们要插入的新节点（cur->next = newnode;），新节点指向pos节点（newnode->next = pos;）。

j.定点删

void SLErase(SLNode** phead,SLNode*pos)
{
	assert(*phead && phead);
	if (*phead == pos)
	{
		SLPopFront(phead);
	}
	else
	{
		SLNode* cur = *phead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
	}
}

先判断pos节点是不是首节点，是就调用前面的头删函数，不是就找到pos前一个节点，让pos前一个节点指向pos的后一个节点（ cur->next = pos->next;）。

整体代码

#include"SList.h"

SLNode* CreateSLNode(SLDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->next = NULL;
		newnode->val = x;
	}
	return newnode;
}

void SLDeastory(SLNode*phead)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		SLNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

void SLPrint(SLNode* phead)
{
	assert(phead);
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d=>", cur->val);
		cur = cur->next;
	}
	printf("\n");
}

void SLPushBack(SLNode** phead, SLDataType x)
{
	SLNode* newnode = CreateSLNode(x);
	if (*phead == NULL)
	{
		*phead = newnode;
	}
	else
	{
		SLNode* cur = *phead;
		while (cur->next)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}

void SLPushFront(SLNode** phead, SLDataType x)
{
	SLNode* newnode = CreateSLNode(x);
	if (*phead == NULL)
	{
		*phead = newnode;
	}
	else
	{
		newnode->next = *phead;
		*phead = newnode;
	}
}

void SLPopBack(SLNode** phead)
{
	assert(*phead);
	SLNode* cur = *phead;
	while (cur->next->next!=NULL)
	{
		cur = cur->next;
	}
	SLNode*next = cur->next;
	free(next);
	next = NULL;
	cur->next = NULL;
}

void SLPopFront(SLNode** phead)
{
	assert(*phead);
	SLNode* next = (*phead)->next;
	free(*phead);
		*phead = next;
}

void SLInsert(SLNode** phead, SLNode* pos, SLDataType x)
{
	assert(*phead && phead);
	if (pos == *phead)
	{
		SLPushFront(phead, x);
	}
	else
	{
		SLNode* cur = *phead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SLNode* newnode = CreateSLNode(x);
		cur->next = newnode;
		newnode->next = pos;
	}
}

void SLErase(SLNode** phead,SLNode*pos)
{
	assert(*phead && phead);
	if (*phead == pos)
	{
		SLPopFront(phead);
	}
	else
	{
		SLNode* cur = *phead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
	}
}

3.test.c

下面我们来测试一下
先是尾插：

#include"SList.h"

int main()
{
	SLNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	/*SLPushFront(&plist, 5);
	SLPushFront(&plist, 6);
	SLPopBack(&plist);
	SLPopFront(&plist);
	SLInsert(&plist, plist->next->next, 7);
	SLErase(&plist,plist);*/
	SLPrint(plist);
	return 0;
}

在这里插入图片描述
头插：

#include"SList.h"

int main()
{
	SLNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	SLPushFront(&plist, 5);
	SLPushFront(&plist, 6);
	/*SLPopBack(&plist);
	SLPopFront(&plist);
	SLInsert(&plist, plist->next->next, 7);
	SLErase(&plist,plist);*/
	SLPrint(plist);
	return 0;
}

在这里插入图片描述
头删尾删：

int main()
{
	SLNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	SLPushFront(&plist, 5);
	SLPushFront(&plist, 6);
	SLPopBack(&plist);
	SLPopFront(&plist);
	/*SLInsert(&plist, plist->next->next, 7);
	SLErase(&plist,plist);*/
	SLPrint(plist);
	return 0;
}

在这里插入图片描述
定点插：

int main()
{
	SLNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	SLPushFront(&plist, 5);
	SLPushFront(&plist, 6);
	SLPopBack(&plist);
	SLPopFront(&plist);
	SLInsert(&plist, plist->next->next, 7);
	/*SLErase(&plist,plist);*/
	SLPrint(plist);
	return 0;
}

在这里插入图片描述
定点删：

int main()
{
	SLNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	SLPushFront(&plist, 5);
	SLPushFront(&plist, 6);
	SLPopBack(&plist);
	SLPopFront(&plist);
	SLInsert(&plist, plist->next->next, 7);
	SLErase(&plist,plist->next);
	SLPrint(plist);
	return 0;
}

在这里插入图片描述

四、带头双向循环链表

1.List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType val;
}LTNode;

LTNode* Init();
LTNode* LTFind(LTNode* phead, LTDataType x);
void LTPrint(LTNode* phead);
void LTDestory(LTNode* phead);

void LTInsert(LTNode* phead, LTDataType x);
void LTErase(LTNode* phead);
void LTPushBack(LTNode* phead, LTDataType x);
void LTPushFront(LTNode* phead, LTDataType x);
void LTPopBack(LTNode* phead);
void LTPopFront(LTNode* phead);

循环双向链表中我们需要节点中存放两个指针和一个数据，两个指针一个指向前面的节点，一个指向后面的节点。

2.List.c

a.创建节点

LTNode* CreateLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1)；
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->val = x;
	return newnode;
}

节点中的两个指针置空，数据放指定的x。

b.初始化哨兵位

LTNode* Init()
{
	LTNode* phead = CreateLTNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

先将哨兵位前后节点都指向自己。

c.打印链表

void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	printf("哨兵位<=>");
	while (cur != phead)
	{
		printf("%d<=>", cur->val);
		cur = cur->next;
	}
	printf("\n");
}

d.销毁链表

void LTDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);//调用销毁函数后置空phead或用二级指针写销毁函数
}

j.定点插

带头双向循环链表虽然结构复杂，但实现很简单，头尾的插入删除都可以通过定点的插入删除实现，所以我们先实现定点的插入删除。

void LTInsert(LTNode* pos, LTDataType x)
{
	LTNode* newnode = CreateLTNode(x);
	LTNode* posprev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;
	newnode->prev = posprev;
	posprev->next = newnode;
}

让插入的新节点在pos与pos前一节点间创建相互的指向关系。

k.定点删

void LTErase(LTNode* pos)
{
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

让要删除的pos的前后节点间形成相互指向关系

e.尾插

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

先判断链表不为空，再在首节点前差入节点。

f.头插

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead->next, x);
}

g.尾删

void LTPopBack(LTNode* phead)
{
	assert(phead);
	LTErase(phead->prev);
}

同理尾插，调用定点删除。

h.头删

void LTPopFront(LTNode* phead)
{
	assert(phead);
	LTErase(phead->next);
}

i.找节点

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

整体代码：

#include"List.h"
//创建节点
LTNode* CreateLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->val = x;
	return newnode;
}
//初始化哨兵位
LTNode* Init()
{
	LTNode* phead = CreateLTNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
//打印链表
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	printf("哨兵位<=>");
	while (cur != phead)
	{
		printf("%d<=>", cur->val);
		cur = cur->next;
	}
	printf("\n");
}
//销毁
void LTDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);//调用销毁函数后置空phead或用二级指针写销毁函数
}
//定点插入
void LTInsert(LTNode* pos, LTDataType x)
{
	LTNode* newnode = CreateLTNode(x);
	LTNode* posprev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;
	newnode->prev = posprev;
	posprev->next = newnode;
}

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

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead->next, x);
}

void LTErase(LTNode* pos)
{
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

void LTPopBack(LTNode* phead)
{
	assert(phead);
	LTErase(phead->prev);
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	LTErase(phead->next);
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

3.test.c

下面测试一下：

#include"List.h"
int main()
{
	LTNode* plist = Init();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushFront(plist, 234);
	LTNode* pos = LTFind(plist, 2);
	if (pos)
	{
		pos->val *= 1000;
	}

	LTPrint(plist);
	LTDestory(plist);
	plist = NULL;
	return 0;
}

在这里插入图片描述

gsfl
关注
专栏目录
数据结构实验一 用链表实现大整数加减法
m0_61506053的博客
03-31 4125
题目： 用链表实现大整数加减法操作： 32位机器直接操作的数据最大为32个bit，若超过32bit，则需要单独设计算法。在这里，可以用链表每个结点存储大整数的每一位的十进制数字，则可以进行大整数的算数运算，该实验仅实现加减法操作。 要求: 随机产生2个1~50位的数字串，并存储到2个链表中。 进行加法或减法操作，结果存储到新的链表中。 打印运算结果。 目录 BigInteger.h BigInteger.cpp function.h function.cpp main.cpp ..
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
C语言的链表实现
weixin_73728044的博客
10-16 2260
C语言各种链表学习记录
双向链表实现栈
m0_56398287的博客
10-03 1385
双向链表来实现栈
C语言链表实现栈
wu1217的博客
09-07 4189
/** 链表实现带头结点的栈，入栈用头插法 环境codeblocks */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct Node { ElemType data; struct...
C#中 简单链表实现
weixin_43542114的博客
07-04 2026
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)
栈——链表实现
m0_53223094的博客
11-21 2793
链栈的一些基本操作，附带源码
【C语言】链表实现队列
weixin_43757283的博客
07-14 4946
前言 利用动态数组实现了循环队列，这是静态的队列，缺点是需要预设大小，当队列满时，无法再插入新的数据，只有等队头的数据被取走以后才能往队列放入新的数据。 除了动态数组分配实现的队列之外，还可以使用链表实现队列，这种方式动态创建节点需要的内存，当有新的数据节点要加入时，才去申请内存空间，不需要预设大小，整个队列需要的内存空间不需要连续，并且插入删除更容易实现。但是同时也带来存取速度慢的缺点，操作也比数组的方式更加复杂。 其实用链表实现队列的方式十分简单，只需要在单链表的基础上，增加一个尾指针即可。因为队列的.
学生管理系统——用链表实现
Longlong的博客
03-11 4873
前言 该程序是大一上学期的课设，在上学期的基础上对此程序进行了细节上的优化，以及将程序分成多个文件，第一次对多文件开发有了了解(再也不要将几千行代码放在一个文件内了) 一、 软件功能描述 假设学生成绩信息描述如下： 学号，姓名，身份证号，性别，民族，家庭住址，课程成绩，年龄 要求：程序能够实现，（１）增加、删除、修改学生的基本信息；（２）查询功能：查询学生人数；按性别查询学生人数；按民族查询学生人数；统计学生的平均分数；给学生排榜；按课程统计学生分数；查询获得某课程的最高分的学生信息；(3)、存储学生信
多项式加法运算（链表实现）
热门推荐
2021dragon的博客
04-24 1万+
文章目录创建结点类型打印多项式尾插选择排序多项式相加代码总览 + 结果展示 创建结点类型 我们用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。 typedef int SLTDataType;//指数、系数类型 typedef struct SListNode { SLTDataType coef;//系数 SLTDataType expon;//指数 struct SListNode* ne
Java用链表实现队列
daBai_Zzz的博客
01-08 1957
/** * 链表实现队列 */ public class LinkedQueue { class Node{ int val; Node next; public Node(int val){this.val=val;} public Node(int val,Node next){this.val=val;this.next=next;} } // 队头指针 Node front; // 队尾指针
C语言学生考试系统（链表实现）
05-25
《C语言学生考试系统——链表实现》 在信息技术领域，C语言作为一种基础且强大的编程语言，被广泛用于系统编程、软件开发以及教学实训。本项目“C语言学生考试系统”便是利用C语言来实现的一个简易考试管理工具，其...
学生信息管理系统（C++实现，链表实现，还有完整的实验报告）
06-27
定义结构体类型,使用动态链表结构编程实现学生 管理系统如下功能： (1)录入每个学生的基本信息； (2)计算每个学生的平均分； (3)按平均分从高到低输出学生信息； (4)按学生姓名的字典顺序输出学生基本信息； (5)按...
图书管理系统（C语言链表实现）含实验报告
05-25
大学期间用C语言链表实现的一个图书管理系统，主要功能有 a. 设备申请。由专业人员填写“申请表”送交领导批准购买。 b. 设备入库。新设备购入后要立即进行设备登记（包括类别、设备名、型号、规格、单价、数量、...
链表实现集合运算 链表实现集合交并差运算
12-27
链表实现集合运算 链表实现集合交并差运算
数据结构2——单链表
weixin_73629886的博客
09-23 1127
了解了顺序表的不足，下面我们就来学习一下链表，看一看链表能不能解决顺序表的不足。
浙大数据结构：06-图2 Saving James Bond - Easy Version
最新发布
qq_74924951的博客
09-26 245
采用bfs解决
【数据结构】什么是二叉搜索(排序)树?
C/C++领域,数据结构,linux,MySQl学习者
09-20 1315
数据结构之二叉搜索树概念详解,内容包括:二叉搜索树的概念,二叉搜索树的操作(查找,插入,删除)逻辑详解及图示,二叉搜索树的应用以及二叉搜索树的性能分析。
数据结构之——单链表
m0_71974552的博客
09-23 1040
深入了解单链表：数据结构中的灵活利器
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

gsfl

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

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

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

打赏作者

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

抵扣说明：

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

余额充值