图之邻接表详解（C语言版）

已于 2022-12-24 23:52:09 修改
阅读量9.3k 收藏 91
点赞数 23
分类专栏： 数据结构与算法 文章标签： 数据结构
于 2021-04-25 12:09:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44075108/article/details/116107861
版权

文章目录

一、定义

        图的邻接表是一种顺序与链式存储相结合的存储方式。下面给出一个示例，以便大家能够理解邻接表这种存储方式：
        无向图G1

在这里插入图片描述
        用邻接表来存储G1

在这里插入图片描述
        每一个顶点所在结点都是之后链表的头结点，之后的链表结点存放从头结点所存顶点能够直接到达顶点的位置下标，如顶点A能够直接到达D，B两个顶点，D的顶点存放在3位置，B顶点存放在1位置，所以A之后的链表结点存放的值为3和1
        有向图G2
在这里插入图片描述
        用邻接表来存储有向图G2
在这里插入图片描述
        可见无向图和有向图都可以用邻接表来表示，只需将无向图中连接两个顶点的边看成是有向图中两条相互指向的边，就可以将无向图转换成有向图进行处理。

二、结构

        结构图
在这里插入图片描述

        代码描述

//顶点默认元素个数
#define Default_Vertex_Size 10
#define T  char //顶点元素类型
//边结构
typedef struct Edge
{
	int dest;  //存放顶点下标
	struct Edge *link;//连接下一个顶点
}Edge;
//顶点结构
typedef struct Vertex
{
	T data;//顶点数据
	Edge *adj;//指向边结构指针
}Vertex;
//邻接表
typedef struct GraphLnk
{
	int MaxVertices; //最大顶点个数
	int NumVertices; //实际顶点个数
	int NumEdges;  //边的条数

	Vertex *NodeTable; //指向顶点结构表
}GraphLnk;

三、常用操作

        下面给出存储图的邻接表的常用操作代码实现，无向图和有向图的邻接表操作代码实现上基本一致，只有在插入边操作和删除边操作中存在一些差异。

        初始化

//初始化
void InitGraph(GraphLnk *g)
{
	g->MaxVertices = Default_Vertex_Size;//初始化最大顶点个数
	g->NumEdges = g->NumVertices = 0;//初始化实际顶点个数和边条数
	//为顶点结构表开辟空间
	g->NodeTable = (Vertex*)malloc(sizeof(Vertex) * g->MaxVertices);
	assert(g->NodeTable != NULL);
	for(int i=0; i<g->MaxVertices; ++i)//顶点结构表的初始化
	{
		g->NodeTable[i].adj = NULL;
	}
}

        获取顶点位置

//获取顶点位置
int  GetVertexPos(GraphLnk *g, T v)
{
	for(int i=0; i<g->NumVertices; ++i)
	{
		if(g->NodeTable[i].data == v)//判断是否找到
			return i;
	}
	return -1;
}

        打印图

//打印图
void ShowGraph(GraphLnk *g)
{
	Edge *p;
	for(int i=0; i<g->NumVertices; ++i)//对顶点进行遍历
	{
		printf("%d %c:>",i,g->NodeTable[i].data);//输出顶点
		p = g->NodeTable[i].adj;//指向边结构
		while(p != NULL)//打印相连的顶点
		{
			printf("%d-->",p->dest);
			p = p->link;
		}
		printf("Nul.\n");
	}
	printf("\n");
}

插入顶点

//插入顶点
void InsertVertex(GraphLnk *g, T v)
{
	//判断顶点表是否已满
	if(g->NumVertices >= g->MaxVertices)
		return;
	g->NodeTable[g->NumVertices++].data = v;//插入
}

        插入边（无向图）

//插入边：在顶点vertex1和vertex2之间插入一条边
void InsertEdge(GraphLnk *g, T vertex1, T vertex2)
{
	int v1 = GetVertexPos(g,vertex1);//获取vertex1的位置
	int v2 = GetVertexPos(g,vertex2);//获取vertex2的位置
	if(v1==-1 || v2==-1)
		return;

	Edge *s;
	//无向图是双向的插入要两次
	//插入V1 --> V2的边 头插法插入
	s = (Edge *)malloc(sizeof(Edge));
	assert(s != NULL);
	s->dest = v2;
	s->link = g->NodeTable[v1].adj;
	g->NodeTable[v1].adj = s;

	//插入V2 --> V1的边 头插法插入
	s = (Edge *)malloc(sizeof(Edge));
	assert(s != NULL);
	s->dest = v1;
	s->link = g->NodeTable[v2].adj;
	g->NodeTable[v2].adj = s;

	g->NumEdges++;
}

        插入边（有向图）

//插入边：在顶点vertex1和vertex2之间插入一条边
void InsertEdge(GraphLnk *g, T vertex1, T vertex2)
{
	int v1 = GetVertexPos(g,vertex1); //获取vertex1的位置
	int v2 = GetVertexPos(g,vertex2); //获取vertex2的位置
	if(v1==-1 || v2==-1)
		return;

	Edge *s;
	//插入V1 --> V2的边 头插法插入
	s = (Edge *)malloc(sizeof(Edge));
	assert(s != NULL);
	s->dest = v2;
	s->link = g->NodeTable[v1].adj;
	g->NodeTable[v1].adj = s;

	g->NumEdges++;
}

        删除边（无向图）

//删除一条边：删除顶点vertex1和顶点vertex2之间的边
void RemoveEdge(GraphLnk *g, T vertex1, T vertex2)
{
	int v1 = GetVertexPos(g,vertex1);//获取v1所在位置
	int v2 = GetVertexPos(g,vertex2);//获取顶点v2所在位置

	if(v1==-1 || v2==-1)
		return;

	Edge *q = NULL;
	Edge *p;
	//无向图是双向的，所以需要删除两边相对的边
	//删除v1 -- > v2的边
	p = g->NodeTable[v1].adj;
	while(p != NULL && p->dest != v2)
	{//从v1后面的链表中查找v2顶点，其中q指向v2顶点的前驱,p指向v2顶点
		q = p;
		p = p->link;
	}
	if(p == NULL)
		return;

	if(q == NULL)//判断找到的结点是否是链表内的第一个结点
	{//是  头删
		g->NodeTable[v1].adj = p->link;//头删
	}
	else
	{//不是 直接删除
		q->link = p->link;
	}
	free(p); //释放空间

	//删除v2 --> v1的边
	q = NULL;
	p = g->NodeTable[v2].adj;
	while(p->dest != v1)
	{//从v2后面的链表中查找v1顶点，其中q指向v1顶点的前驱,p指向v1顶点
		q = p;
		p = p->link;
	}
	if(q==NULL)//判断找到的结点是否是链表内的第一个结点
	{//是  头删
		g->NodeTable[v2].adj = p->link;
	}
	else
	{//不是 直接删除
		q->link = p->link;
	}
	free(p); //释放空间
	g->NumEdges--; //边数减一
}

        删除边（有向图）

//删除一条边：删除顶点vertex1和顶点vertex2之间的边
void RemoveEdge(GraphLnk *g, T vertex1, T vertex2)
{
	int v1 = GetVertexPos(g,vertex1); //获取v1所在位置
	int v2 = GetVertexPos(g,vertex2); //获取顶点v2所在位置

	if(v1==-1 || v2==-1)
		return;

	Edge *q = NULL;
	Edge *p;
	//删除v1 -- > v2的边
	p = g->NodeTable[v1].adj;
	while(p != NULL && p->dest != v2)
	{//从v1后面的链表中查找v2顶点，其中q指向v2顶点的前驱,p指向v2顶点
		q = p;
		p = p->link;
	}
	if(p == NULL)
		return;

	if(q == NULL)//判断找到的顶点是否是链表内的第一个顶点
	{//是  头删
		g->NodeTable[v1].adj = p->link; //头删
	}
	else
	{//不是 直接删除
		q->link = p->link;
	}
	free(p);  //释放空间

	g->NumEdges--;
}

        删除顶点

//删除顶点
void RemoveVertex(GraphLnk *g, T vertex)
{
	int v = GetVertexPos(g,vertex);//获取顶点vertex的位置
	if(v == -1)
		return;

	//删除顶点所相连的边
	Edge *p = g->NodeTable[v].adj;//获取与顶点vertex相连的链表

	int k;
	Edge *t = NULL;//t是s的前驱
	Edge *s;
	while(p!=NULL)
	{
		k = p->dest;//获取与v相连的顶点k
		s = g->NodeTable[k].adj;//获取与k连接的链表
		while(s!=NULL && s->dest!=v)//从该链表中查找与v连接的结点
		{
			t = s;
			s = s->link;
		}
		if(s!=NULL)//判断是否找到
		{//找到
			if(t==NULL)//判断是否是第一个结点
			{//是  头删
				g->NodeTable[k].adj = s->link;
			}
			else
			{//否 直接删除
				t->link = s->link;
			}
			free(s);//释放空间
		}
		//释放与v连接链表中的k结点
		g->NodeTable[v].adj = p->link;
		free(p);
		p = g->NodeTable[v].adj;
	}
	
	g->NumVertices--;//顶点数减一
	//拿最后一个顶点的值覆盖要删除的顶点
	g->NodeTable[v].data = g->NodeTable[g->NumVertices].data;
	g->NodeTable[v].adj = g->NodeTable[g->NumVertices].adj;

	//调整链表内结点的指向：将原来标明到最后一个顶点的结点，标明到最后一个结点更改后的位置
	s = g->NodeTable[v].adj;//指向原来与最后一个顶点连接的链表
	while(s != NULL)//对链表进行搜索，看哪些顶点与原来最后一个顶点相连
	{
		k = s->dest;//获取相连的顶点位置
		p = g->NodeTable[k].adj;//找到与相邻顶点连接的链表
		while(p != NULL)//对该链表进行搜索
		{
			if(p->dest == g->NumVertices)//判断是否找到指向最后一个顶点的结点
			{//找到
				p->dest = v;//更换指向，指向最后一个顶点更新后的位置
				break;
			}
			p = p->link;//没找到，则继续查找下一个
		}
		s = s->link;//进入下一个结点，准备下一个顶点链表结点的替换
	}
}

        获取第一个邻接顶点

//获取第一个邻接顶点
int  GetFirstNeighbor(GraphLnk *g, T vertex)
{
	int v = GetVertexPos(g,vertex);//获取顶点vertex的位置
	if(v == -1)
		return -1;
	//从vertex所连接链表的第一个结点处取得第一个邻接顶点
	Edge *p = g->NodeTable[v].adj;
	if(p != NULL)
		return p->dest;
	return -1;
}

        获取邻接顶点的下一个顶点

//获取邻接顶点的下一个顶点：获取顶点vertex1的邻接顶点，该邻接顶点在vertex1的邻接顶点vertex2的下一个
int  GetNextNeighbor(GraphLnk *g,  T vertex1, T vertex2)
{
	int v1 = GetVertexPos(g,vertex1);//获取vertex1的位置
	int v2 = GetVertexPos(g,vertex2);//获取vertex2的位置
	if(v1==-1 || v2==-1)
		return -1;

	Edge *p = g->NodeTable[v1].adj;//获取与顶点vertex1相连的链表
	while(p != NULL && p->dest != v2)//从链表中查找到指向vertex2顶点的结点位置
		p = p->link;
	if(p!=NULL && p->link!=NULL)//判断是否找到
		return p->link->dest;//找到，那么它的下一个结点就是所求的邻接顶点
	return -1;
}

        销毁图

//销毁图
void DestroyGraph(GraphLnk *g)
{
	Edge *p;
	//释放每一个顶点指向的链表空间
	for(int i=0; i<g->NumVertices; ++i)
	{
		p = g->NodeTable[i].adj;
		while(p != NULL)
		{
			g->NodeTable[i].adj = p->link;
			free(p);
			p = g->NodeTable[i].adj;
		}
	}
	//释放存放顶点的空间
	free(g->NodeTable);
	g->NodeTable = NULL;
	g->MaxVertices = g->NumEdges = g->NumVertices = 0;
}

四、测试

无向图测试

#include"GraphLnk.h"

void main()
{
	//建立无向图
	GraphLnk gl;
	InitGraph(&gl);
	//插入顶点
	InsertVertex(&gl,'A');
	InsertVertex(&gl,'B');
	InsertVertex(&gl,'C');
	InsertVertex(&gl,'D');
	InsertVertex(&gl,'E');
	//插入边
	InsertEdge(&gl,'A','B');
	InsertEdge(&gl,'A','D');
	InsertEdge(&gl,'B','C');
	InsertEdge(&gl,'B','E');
	InsertEdge(&gl,'C','D');
	InsertEdge(&gl,'C','E');
	
	ShowGraph(&gl);

	DestroyGraph(&gl);
}

运行结果

在这里插入图片描述

有向图测试

#include"GraphLnk.h"

void main()
{
	//建立有向图
	GraphLnk gl;
	InitGraph(&gl);
	//插入顶点
	InsertVertex(&gl,'A');
	InsertVertex(&gl,'B');
	InsertVertex(&gl,'C');
	InsertVertex(&gl,'D');
	InsertVertex(&gl,'E');
	InsertVertex(&gl,'F');
	//插入边
	InsertEdge(&gl,'A','B');
	InsertEdge(&gl,'A','C');
	InsertEdge(&gl,'A','D');
	InsertEdge(&gl,'C','B');
	InsertEdge(&gl,'C','E');
	InsertEdge(&gl,'D','E');
	InsertEdge(&gl,'F','D');
	InsertEdge(&gl,'F','E');
	//显示图结构
	ShowGraph(&gl);
	//销毁图
	DestroyGraph(&gl);
}

运行结果

在这里插入图片描述

结语

        对图的邻接表的介绍就到这里啦，希望这篇文章能给予你一些帮助，感谢各位人才的：点赞、收藏和评论，我们下次见。

附录

        测试代码：图之邻接表详解（C语言版）

红心火柴
关注
  • 23
    点赞
  • 踩
  • 91
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
图之邻接表详解（C语言版）.rar
04-25
"图之邻接表详解（C语言版）"博文测试代码，博文链接：https://blog.csdn.net/qq_44075108/article/details/116107861
C语言 图操作--邻接表法
qq_51838257的博客
04-13 2143
C语言 图操作–邻接表法 一、图的介绍 图是一种相较于链表和树更为复杂的数据结构。在线性表中，数据元素之间仅有线性关系，每个元素只有一个直接前驱和一个直接后继（每个元素之间一个一个逐个相连）。在树形结构中，数据元素之间有着明显的层次关系，上一层元素能和下层多个元素相关，但是下层元素只能与一个上层元素相关。而在图结构中，节点之间的关系任意，任何两个顶点都可能相连。 图结构如图所示 此中为“离散数学”中的图理论。 二、图的术语 接下来介绍图结构中的一些术语。 1.顶点 图中的数据元素通常称为顶点。 2.边
【图】（三）顶点度的计算 - C语言
友人帐_的博客
11-01 5067
以无向图为例分别介绍了在邻接矩阵和邻接表两种存储结构下顶点度的计算公式，并给出代码示例。
邻接表法存储有向图
最新发布
weixin_73592765的博客
04-23 188
拓扑排序的核心思想是在遍历所有节点时，找出入度为0的节点，然后经过寻找该节点对应的边来进行遍历查找操作，最后找到最优解。然后需要一个int数组存储邻接表，一个数组存储节点入度情况，以及一个变量记录边的数量。首先需要一个结构体边数组来存储每条边对应的终点和起点的邻接表的表头信息。依次给出5个点及6条边，根据邻接表来存储有向图。因此还需要一个队列来进行push，pop操作。
图的邻接表代码实现
u010232308的博客
11-26 3948
图的邻接表代码实现（抄自mooc）/* 图的邻接表表示法 */ #define MaxVertexNum 100 /* 最大顶点数设为100 */ typedef int Vertex; /* 用顶点下标表示顶点,为整型 */ typedef int WeightType; /* 边的权值设为整型 */ typedef char DataType;
邻接表创建有向图
qq_42169456的博客
11-11 5275
使用邻接表创建有向图，可以使用数组+链表的方式创建 #include <iostream> using namespace std; //采用邻接表存储节点 #define MaxSize 10 // 定义边 typedef struct arc_node { int adj_vex; //该边所指向节点的位置 struct arc_node *next_arc; } ArcNode; //定义顶点 typedef struct vnode { char dat
邻接表-数据结构(C语言)
weixin_44681349的博客
05-09 5665
邻接表 邻接表的构造与邻接矩阵完全不同，同学们应该发现了，邻接表的的结构更像是由几个链表构成的。 在构造邻接表时，我们的确会借助链表的结构。对图中每个顶点的信息，我们都会分别使用一个链表来进行存储。因此，我们需要初始化一个有 n 个元素的链表数组， n 为图中顶点数量。 我们要在邻接表中存储的图的信息，实际上就是顶点之间存在的有向边。当从顶点 a 到顶点 b 存在一条有向边时，我们只需要在头结点为 a 的链表后插入一个结点 b。值得注意的是，当一条边是从顶点 b 到顶点 a 时，我们同样需要在以 b
【C语言】图的邻接表——超详细解析
Jaye513的博客
12-09 4473
快看这篇，学不会你来打我（bushi）
C语言数据结构之图的遍历实例详解
08-30
"C语言数据结构之图的遍历实例详解" 本文主要介绍了C语言数据结构之图的遍历实例详解的相关知识点，包括图的遍历算法、图的存储结构、图的遍历实现等。 一、图的遍历算法 图的遍历算法是指从图的一点出发，遍历图...
C语言邻接表结构实现克鲁斯卡尔算法
12-27
C语言采用邻接表结构实现克鲁斯卡尔算法。 也可以在相应github上下载，https://github.com/Sunnk/Data-Structure，其中Kruskal文件夹中即为克鲁斯卡尔算法，可用vs打开
C语言单向链表的表示与实现实例详解
09-04
相对于双向链表，这种普通的，每个节点只有一个指针的链表也叫单向链表，或者单链表，通常用在每次都只会按顺序遍历这个链表的时候（例如图的邻接表，通常都是按固定顺序访问的）。 在C语言中，单向链表的实现可以...
图遍历详解（C语言版）.rar
04-28
博文图遍历详解（C语言版）的测试代码，博文链接：https://blog.csdn.net/qq_44075108/article/details/116222906 详细介绍了基于邻接表存储的图的深度优先遍历和广度优先遍历的实现
数据结构——图（邻接链表）
zouzp的博客
07-21 1万+
邻接链表 邻接矩阵是不错的⼀种图存储结构，但是我们也发现，对于边数相对顶点较少的图，这种结构是存在对存储空间的极大浪费的。比如说，如果我们要处理下图这样的稀疏有向图，邻接矩阵中除了arc[1][0]有权值外，没有其他弧，其实这些存储空间都浪费掉了。 因此选择一种新的数据结构来存储这种稀疏图则尤为重要了。此时则使用链表结构来存储原来的连接信息。 定义如下数据结构 //图的邻接链表存储结构 //...
图(3)——邻接链表法
热门推荐
阳光日志
07-08 2万+
邻接链表法 基本思想：对图的每个顶点建立一个单链表，存储该顶点所有邻接顶点及其相关信息。每一个单链表设一个表头结点。 第i个单链表表示依附于顶点Vi的边(对有向图是以顶点Vi为头或尾的弧)。 1结点结构与邻接链表示例 链表中的结点称为表结点，每个结点由三个域组成，如图(a)所示。其中邻接点域(adjvex)指示与顶点Vi邻接的顶点在图中的位置(顶点编号)，链域(nextar
数据结构——邻接表，c语言实现
weixin_61375386的博客
03-26 5437
邻接表：图的常用储存结构之一，由表头结点和表结点两部分组成，其中表头结点存储图的各顶点，表结点用单向链表存储表头结点所对应顶点的相邻顶点（也就是表示了图的边）。在有向图里表示表头结点指向其它结点（a->b）,无向图则表示与表头结点相邻的所有结点（a—b） 邻接表（无向图）： 代码实现： 邻接表（无向图）： #include<stdio.h> #include<stdlib.h> #define MVNum 100 //边表 typedef struct ArcNo
无向图的邻接矩阵表示求各顶点的度-----数据结构与算法笔记
王先生的蒋小姐的博客
01-20 1万+
参考书：《数据结构（C语言）》–严蔚敏等编著，清华大学出版社。
“数据结构”最小生成树题目和解析
星空的日常博客，希望日常能给你帮助
01-16 461
[6-1] 无向网的5个顶点依序为a, b, c, d, e，其邻接矩阵如下，画出该图及其最小生成树。 [6-2] 画出如下有向图的邻接表和逆邻接表。 [6-3] 以邻接表存储图中边或弧的信息，定义图的数据类型。分别编程实现求第一个邻接点和下一个邻接点的函数。 Typedef Struct node{ Int adj; Struct node *next; }arcnode; Typedef Struct{ Element vex; arcnode *first; }listnode; Typed
C语言 图的建立（邻接矩阵与邻接表）
m0_73070900的博客
05-25 5025
5Cinfty。
邻接表的相关操作（类C语言）
m0_68536532的博客
12-04 1066
邻接表的相关操做（类C语言） 包括邻接表的建立、求顶点的度、广度和深度遍历输出。
邻接表生成逆邻接表用C语言实现
06-01
下面是一个使用C语言实现邻接表生成逆邻接表的示例代码： ```c #include <stdio.h> #include <stdlib.h> #define MAX_NODE_NUM 100 // 最大节点数 // 邻接表节点结构体 typedef struct AdjListNode { int dest; // 邻接节点编号 struct AdjListNode* next; // 指向下一个邻接节点的指针 } AdjListNode; // 邻接表结构体 typedef struct AdjList { AdjListNode* head; // 邻接表头指针 } AdjList; // 图结构体 typedef struct Graph { int num_vertices; // 节点数 AdjList* adj_lists; // 邻接表数组 } Graph; // 创建邻接节点 AdjListNode* createAdjListNode(int dest) { AdjListNode* newNode = (AdjListNode*)malloc(sizeof(AdjListNode)); newNode->dest = dest; newNode->next = NULL; return newNode; } // 创建图 Graph* createGraph(int num_vertices) { Graph* graph = (Graph*)malloc(sizeof(Graph)); graph->num_vertices = num_vertices; graph->adj_lists = (AdjList*)malloc(num_vertices * sizeof(AdjList)); for (int i = 0; i < num_vertices; i++) { graph->adj_lists[i].head = NULL; } return graph; } // 添加边 void addEdge(Graph* graph, int src, int dest) { AdjListNode* newNode = createAdjListNode(dest); newNode->next = graph->adj_lists[src].head; graph->adj_lists[src].head = newNode; } // 生成逆邻接表 Graph* getReverseGraph(Graph* graph) { Graph* reverseGraph = createGraph(graph->num_vertices); for (int i = 0; i < graph->num_vertices; i++) { AdjListNode* curr = graph->adj_lists[i].head; while (curr != NULL) { addEdge(reverseGraph, curr->dest, i); curr = curr->next; } } return reverseGraph; } // 打印邻接表 void printGraph(Graph* graph) { for (int i = 0; i < graph->num_vertices; i++) { AdjListNode* curr = graph->adj_lists[i].head; printf("节点 %d 的邻接节点：", i); while (curr != NULL) { printf("%d ", curr->dest); curr = curr->next; } printf("\n"); } } int main() { Graph* graph = createGraph(5); addEdge(graph, 0, 1); addEdge(graph, 0, 2); addEdge(graph, 1, 3); addEdge(graph, 2, 3); addEdge(graph, 3, 4); printGraph(graph); Graph* reverseGraph = getReverseGraph(graph); printf("逆邻接表：\n"); printGraph(reverseGraph); return 0; } ``` 在上面的示例代码中，我们首先定义了邻接表节点结构体和邻接表结构体，并使用它们创建了一个图结构体。接着，我们实现了创建邻接节点、创建图、添加边、打印邻接表等相关函数，其中 `addEdge` 函数用于向图中添加边，`getReverseGraph` 函数用于生成逆邻接表。 最后，在 `main` 函数中，我们创建了一个包含 5 个节点的图，并向其中添加边。然后，我们打印出图的邻接表，并生成其对应的逆邻接表并打印出来。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值