数据结构之图（三）

最新推荐文章于 2024-07-18 21:59:46 发布
最新推荐文章于 2024-07-18 21:59:46 发布
阅读量95 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/semu2000/article/details/130342391
版权

目录

图的遍历

从图中某一顶点出发访遍图中其余顶点，且使每一顶点仅被访问一次，这一过程就叫做图的遍历(Traversing Graph).
树是一种特殊的图，所以树的遍历实际上也可视为一种特殊的图的遍历。
图的遍历比树的遍历要复杂得多，因为图的任一顶点都可能和其余顶点相邻接，所以访问某个顶点后，可能沿着某条路径搜索回到该顶点上。为避免同一个顶点被访问多次，在图的遍历过程中，必须记下每个已访问过的顶点，为此可以设一个辅助数组visited[ ]来标记顶点是否被访问过。

1. 深度优先遍历

深度优先遍历（Depth First Search）,也有称为深度优先搜索，简称为DFS。
深度优先遍历类似于树的先序遍历。
基本思想如下：首先访问图中某一起始顶点v，然后从v出发，访问与v邻接且未被访问的任一顶点w1，再访问与w1邻接且未被访问的任一顶点w2…重复上述过程。当不能再继续向下访问时，依次退回到最近被访问的顶点，若它还有邻接顶点未被访问过，则从该点开始继续上述搜索过程，直至图中所有顶点均被访问过为止。


//邻接矩阵的深度优先递归算法
void DFS(MGraph G, int i)
{
	int j;
	visited[i] = TRUE;
	printf("%c ", G.vexs[i]);  //打印顶点，也可以是其他操作

	for (j = 0; j < G.numVertexes; j++)
	{
		if (G.arc[i][j] == 1 && !visited[j])
		{
			DFS(G, j);
		}
	}
}

//邻接矩阵的深度遍历操作
void DFSTraverse(MGraph G)
{
	int i;
	for (i = 0; i < G.numVertexes; i++)
	{
		visited[i] = FALSE;   //初始所有顶点状态都是未访问过状态
		for (i = 0; i < G.numVertexes; i++)
		{
			if (!visited[i])
			{
				DFS(G, i);   //对未访问过的顶点调用DFS，若是连通图，只会执行一次
			}
		}
	}
}

2. 广度优先遍历

广度优先遍历（Breadth First Search）,又称为广度优先搜索，简称BFS。类似于二叉树的层序遍历算法。
基本思想是：首先访问起始顶点v，接着由v出发，依次访问v的各个未访问过的邻接顶点 w 1 , w 2 , . . . , w i w_1,w_2,...,w_i w1​,w2​,...,wi​,然后依次访问 w 1 , w 2 , . . . , w i w_1,w_2,...,w_i w1​,w2​,...,wi​的所有未被访问过的邻接顶点；在从这些访问过的顶点出发，访问它们所有未被访问过的邻接顶点，直到图中所有顶点都被访问过为止。

* 邻接矩阵的广度遍历算法 */
void BFSTraverse(MGraph G)
{
	int i, j;
	Queue Q;
	for (i = 0; i < G.numVertexes; i++)
		visited[i] = FALSE;
	InitQueue(&Q);		/* 初始化一辅助用的队列 */
	for (i = 0; i < G.numVertexes; i++)  /* 对每一个顶点做循环 */
	{
		if (!visited[i])	/* 若是未访问过就处理 */
		{
			visited[i] = TRUE;		/* 设置当前顶点访问过 */
			printf("%c ", G.vexs[i]);/* 打印顶点，也可以其它操作 */
			EnQueue(&Q, i);		/* 将此顶点入队列 */
			while (!QueueEmpty(Q))	/* 若当前队列不为空 */
			{
				DeQueue(&Q, &i);	/* 将队对元素出队列，赋值给i */
				for (j = 0; j < G.numVertexes; j++)
				{
					/* 判断其它顶点若与当前顶点存在边且未访问过  */
					if (G.arc[i][j] == 1 && !visited[j])
					{
						visited[j] = TRUE;			/* 将找到的此顶点标记为已访问 */
						printf("%c ", G.vexs[j]);	/* 打印顶点 */
						EnQueue(&Q, j);				/* 将找到的此顶点入队列  */
					}
				}
			}
		}
	}
}

3.实现代码

3.1 邻接矩阵结构

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int Boolean;

typedef char VertexType;
typedef int EdgeType;

#define MAXSIZE 9
#define MAXEDGE 15
#define MAXVEX 9

typedef struct  //邻接矩阵结构
{
	VertexType vexs[MAXVEX];    //顶点表
	EdgeType arc[MAXVEX][MAXVEX];   //邻接矩阵
	int numVertexes;
	int numEdges;
}MGraph;


//用到的队列结构与函数————————————————————————————————————————

//循环队列的顺序存储结构
typedef struct
{
	int data[MAXSIZE];
	int front;
	int rear;
}Queue;

//初始化一个空队列Q
Status InitQueue(Queue* Q)
{
	Q->front = 0;
	Q->rear = 0;
	return OK;
}

//判空
Status QueueEmpty(Queue Q)
{
	if (Q.front == Q.rear)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//插入元素（入队）
Status EnQueue(Queue* Q, int e)
{
	if ((Q->rear + 1) % MAXSIZE == Q->front)
	{
		return ERROR; //队列满的情况
	}
	Q->data[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXSIZE;

	return OK;
}

//删除队列元素（出队）
Status DeQueue(Queue* Q, int* e)
{
	if (Q->front == Q->rear)
	{
		return	ERROR;
	}
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;

	return OK;
}

//____________________

void CreateMGraph(MGraph* G)
{
	int i, j;

	G->numEdges = 15;
	G->numVertexes = 9;

	//读入顶点信息，建立顶点表
	G->vexs[0] = 'A';
	G->vexs[1] = 'B';
	G->vexs[2] = 'C';
	G->vexs[3] = 'D';
	G->vexs[4] = 'E';
	G->vexs[5] = 'F';
	G->vexs[6] = 'G';
	G->vexs[7] = 'H';
	G->vexs[8] = 'I';

	for (i = 0; i < G->numVertexes; i++)
	{
		for (j = 0; j < G->numVertexes; j++)
		{
			G->arc[i][j] = 0;
		}
	}

	G->arc[0][1] = 1;
	G->arc[0][5] = 1;

	G->arc[1][2] = 1;
	G->arc[1][8] = 1;
	G->arc[1][6] = 1;

	G->arc[2][3] = 1;
	G->arc[2][8] = 1;

	G->arc[3][4] = 1;
	G->arc[3][7] = 1;
	G->arc[3][6] = 1;
	G->arc[3][8] = 1;

	G->arc[4][5] = 1;
	G->arc[4][7] = 1;

	G->arc[5][6] = 1;

	G->arc[6][7] = 1;


	for (i = 0; i < G->numVertexes; i++)
	{
		for (j = i; j < G->numVertexes; j++)
		{
			G->arc[j][i] = G->arc[i][j];
		}
	}
}

Boolean visited[MAXVEX];  //访问标志的数组

//邻接矩阵的深度优先递归算法
void DFS(MGraph G, int i)
{
	int j;
	visited[i] = TRUE;
	printf("%c ", G.vexs[i]);  //打印顶点，也可以是其他操作

	for (j = 0; j < G.numVertexes; j++)
	{
		if (G.arc[i][j] == 1 && !visited[j])
		{
			DFS(G, j);
		}
	}
}

//邻接矩阵的深度遍历操作
void DFSTraverse(MGraph G)
{
	int i;
	for (i = 0; i < G.numVertexes; i++)
	{
		visited[i] = FALSE;   //初始所有顶点状态都是未访问过状态
		for (i = 0; i < G.numVertexes; i++)
		{
			if (!visited[i])
			{
				DFS(G, i);   //对未访问过的顶点调用DFS，若是连通图，只会执行一次
			}
		}
	}
}

/* 邻接矩阵的广度遍历算法 */
void BFSTraverse(MGraph G)
{
	int i, j;
	Queue Q;
	for (i = 0; i < G.numVertexes; i++)
		visited[i] = FALSE;
	InitQueue(&Q);		/* 初始化一辅助用的队列 */
	for (i = 0; i < G.numVertexes; i++)  /* 对每一个顶点做循环 */
	{
		if (!visited[i])	/* 若是未访问过就处理 */
		{
			visited[i] = TRUE;		/* 设置当前顶点访问过 */
			printf("%c ", G.vexs[i]);/* 打印顶点，也可以其它操作 */
			EnQueue(&Q, i);		/* 将此顶点入队列 */
			while (!QueueEmpty(Q))	/* 若当前队列不为空 */
			{
				DeQueue(&Q, &i);	/* 将队对元素出队列，赋值给i */
				for (j = 0; j < G.numVertexes; j++)
				{
					/* 判断其它顶点若与当前顶点存在边且未访问过  */
					if (G.arc[i][j] == 1 && !visited[j])
					{
						visited[j] = TRUE;			/* 将找到的此顶点标记为已访问 */
						printf("%c ", G.vexs[j]);	/* 打印顶点 */
						EnQueue(&Q, j);				/* 将找到的此顶点入队列  */
					}
				}
			}
		}
	}
}

int main()
{
	MGraph G;
	CreateMGraph(&G);

	printf("\n深度遍历：");
	DFSTraverse(G);

	printf("\n广度遍历：");
	BFSTraverse(G);
	


	return 0;
}

3.2 邻接表

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 9
#define MAXEDGE 15
#define MAXVEX 9

typedef int Status;
typedef int Boolean;

typedef char VertexType;
typedef int EdgeType;

//邻接矩阵结构
typedef struct   
{
	VertexType vexs[MAXVEX];
	EdgeType arc[MAXVEX][MAXVEX];
	int numVertexes;
	int numEdges;
}MGraph;

//邻接表结构
typedef struct EdgeNode   //边表结点
{
	int adjvex;
	int weight;
	struct EdgeNode* next;
}EdgeNode;

typedef struct VertexNode  //顶点表结点
{
	int in;
	char data;
	EdgeNode* firstedge;
}VertexNode,AdjList[MAXVEX];

typedef struct
{
	AdjList adjList;
	int numVertexes;
	int numEdges;
}graphAdjList,*GraphAdjList;


//用到的队列结构
typedef struct
{
	int data[MAXSIZE];
	int front;    	/* 头指针 */
	int rear;		/* 尾指针,若队列不空,指向队列尾元素的下一个位置 */
}Queue;

/* 初始化一个空队列Q */
Status InitQueue(Queue* Q)
{
	Q->front = 0;
	Q->rear = 0;
	return  OK;
}

/* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(Queue Q)
{
	if (Q.front == Q.rear) /* 队列空的标志 */
		return TRUE;
	else
		return FALSE;
}

/* 若队列未满,则插入元素e为Q新的队尾元素 */
Status EnQueue(Queue* Q, int e)
{
	if ((Q->rear + 1) % MAXSIZE == Q->front)	/* 队列满的判断 */
		return ERROR;
	Q->data[Q->rear] = e;			/* 将元素e赋值给队尾 */
	Q->rear = (Q->rear + 1) % MAXSIZE;/* rear指针向后移一位置, */
								/* 若到最后则转到数组头部 */
	return  OK;
}

/* 若队列不空,则删除Q中队头元素,用e返回其值 */
Status DeQueue(Queue* Q, int* e)
{
	if (Q->front == Q->rear)			/* 队列空的判断 */
		return ERROR;
	*e = Q->data[Q->front];				/* 将队头元素赋值给e */
	Q->front = (Q->front + 1) % MAXSIZE;	/* front指针向后移一位置, */
									/* 若到最后则转到数组头部 */
	return  OK;
}


void CreateMGraph(MGraph* G)
{
	int i, j;

	G->numEdges = 15;
	G->numVertexes = 9;

	/* 读入顶点信息,建立顶点表 */
	G->vexs[0] = 'A';
	G->vexs[1] = 'B';
	G->vexs[2] = 'C';
	G->vexs[3] = 'D';
	G->vexs[4] = 'E';
	G->vexs[5] = 'F';
	G->vexs[6] = 'G';
	G->vexs[7] = 'H';
	G->vexs[8] = 'I';


	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	{
		for (j = 0; j < G->numVertexes; j++)
		{
			G->arc[i][j] = 0;
		}
	}

	G->arc[0][1] = 1;
	G->arc[0][5] = 1;

	G->arc[1][2] = 1;
	G->arc[1][8] = 1;
	G->arc[1][6] = 1;

	G->arc[2][3] = 1;
	G->arc[2][8] = 1;

	G->arc[3][4] = 1;
	G->arc[3][7] = 1;
	G->arc[3][6] = 1;
	G->arc[3][8] = 1;

	G->arc[4][5] = 1;
	G->arc[4][7] = 1;

	G->arc[5][6] = 1;

	G->arc[6][7] = 1;


	for (i = 0; i < G->numVertexes; i++)
	{
		for (j = i; j < G->numVertexes; j++)
		{
			G->arc[j][i] = G->arc[i][j];
		}
	}

}

/* 利用邻接矩阵构建邻接表 */
void CreateALGraph(MGraph G, GraphAdjList* GL)
{
	int i, j;
	EdgeNode* e;

	*GL = (GraphAdjList)malloc(sizeof(graphAdjList));

	(*GL)->numVertexes = G.numVertexes;
	(*GL)->numEdges = G.numEdges;
	for (i = 0; i < G.numVertexes; i++) /* 读入顶点信息,建立顶点表 */
	{
		(*GL)->adjList[i].in = 0;
		(*GL)->adjList[i].data = G.vexs[i];
		(*GL)->adjList[i].firstedge = NULL; 	/* 将边表置为空表 */
	}

	for (i = 0; i < G.numVertexes; i++) /* 建立边表 */
	{
		for (j = G.numVertexes - 1; j >= 0; j--)
		{
			if (G.arc[i][j] == 1)
			{
				e = (EdgeNode*)malloc(sizeof(EdgeNode));

				//下面6句代码仅仅只是为了与图书中的206页图匹配，让生成的队列符合书中图示。
				//实际构建无需这样，只需理解当前就是构建一个图结构的邻接表即可
				if (i == 1 && j == 8)
					e->adjvex = 6;
				else if (i == 1 && j == 6)
					e->adjvex = 8;
				else
					e->adjvex = j;					/* 邻接序号为j */

				//正常代码下如下
				//e->adjvex=j;					/* 邻接序号为j */   

				e->next = (*GL)->adjList[i].firstedge;	/* 将当前顶点上的指向的结点指针赋值给e */
				(*GL)->adjList[i].firstedge = e;		/* 将当前顶点的指针指向e */
				(*GL)->adjList[j].in++;

			}
		}
	}
}

Boolean visited[MAXSIZE]; /* 访问标志的数组 */

/* 邻接表的深度优先递归算法 */
void DFS(GraphAdjList GL, int i)
{
	EdgeNode* p;
	visited[i] = TRUE;
	printf("%c ", GL->adjList[i].data);/* 打印顶点,也可以其它操作 */
	p = GL->adjList[i].firstedge;
	while (p)
	{
		if (!visited[p->adjvex])
			DFS(GL, p->adjvex);/* 对为访问的邻接顶点递归调用 */
		p = p->next;
	}
}

/* 邻接表的深度遍历操作 */
void DFSTraverse(GraphAdjList GL)
{
	int i;
	for (i = 0; i < GL->numVertexes; i++)
		visited[i] = FALSE; /* 初始所有顶点状态都是未访问过状态 */
	for (i = 0; i < GL->numVertexes; i++)
		if (!visited[i]) /* 对未访问过的顶点调用DFS,若是连通图,只会执行一次 */
			DFS(GL, i);
}

/* 邻接表的广度遍历算法 */
void BFSTraverse(GraphAdjList GL)
{
	int i;
	EdgeNode* p;
	Queue Q;
	for (i = 0; i < GL->numVertexes; i++)
		visited[i] = FALSE;
	InitQueue(&Q);
	for (i = 0; i < GL->numVertexes; i++)
	{
		if (!visited[i])
		{
			visited[i] = TRUE;
			printf("%c ", GL->adjList[i].data);/* 打印顶点,也可以其它操作 */
			EnQueue(&Q, i);
			while (!QueueEmpty(Q))
			{
				DeQueue(&Q, &i);
				p = GL->adjList[i].firstedge;	/* 找到当前顶点的边表链表头指针 */
				while (p)
				{
					if (!visited[p->adjvex])	/* 若此顶点未被访问 */
					{
						visited[p->adjvex] = TRUE;
						printf("%c ", GL->adjList[p->adjvex].data);
						EnQueue(&Q, p->adjvex);	/* 将此顶点入队列 */
					}
					p = p->next;	/* 指针指向下一个邻接点 */
				}
			}
		}
	}
}

int main(void)
{
	MGraph G;
	GraphAdjList GL;
	CreateMGraph(&G);
	CreateALGraph(G, &GL);

	printf("\n深度遍历:");
	DFSTraverse(GL);
	printf("\n广度遍历:");
	BFSTraverse(GL);
	return 0;
}

END

semu2000
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验报告三.doc
12-17
这篇实验报告三是关于数据结构的实验报告，报告中包括数据结构的基本概念、数据结构的类型、数据结构的操作、数据结构的应用等内容。 在报告的开头，作者对数据结构进行了定义，并简要介绍了数据结构的历史发展和...
算法设计技巧与分析（六）：图遍历(Graph Traversal)
m0_52935007的博客
12-07 1289
文章目录图遍历(Graph Traversal)一、深度优先搜索(Depth-First Search)二、寻找关节点(Finding Articulation Points in a Graph)三、广度优先搜索(Depth-First Search) 图遍历(Graph Traversal) 一、深度优先搜索(Depth-First Search) 深度优先搜索如下图所示： 图 算法伪代码如下： Input: 无向图G=(V, E); Output: 对应深度优先搜索树中顶点的预排序和后排序 pred
四川大学数据结构实验三
06-15
在四川大学的数据结构课程中，实验三是对理论学习的重要实践环节，旨在加深学生对数据结构的理解和应用能力。实验三通常会围绕一个具体的问题或项目展开，比如构建一个数字化校园系统，这涉及到大量的数据处理和算法...
北邮 数据结构第三次实验 图 实验报告
06-06
数据结构是计算机科学中的核心课程之一，特别是在C++这样的编程语言中，理解并掌握数据结构对于开发高效算法至关重要。本实验报告聚焦于“图”这一关键数据结构，它在多种应用中都有广泛的应用，如网络路由、社交...
广东专插本 数据结构 王晓东 第三班 pdf
03-21
数据结构是计算机科学中的核心课程之一，它主要研究如何在计算机中组织和管理数据，以实现高效的存储和检索。广东专插本（全称：广东省普通高等学校本科插班生考试）是针对已获得专科文凭的学生提升学历的一种考试，...
c语言 数据结构实现之字符串
08-30
C语言数据结构实现之字符串 C语言数据结构实现之字符串是指使用C语言来实现字符串数据结构的相关操作。字符串是一种基本的数据结构，广泛应用于计算机科学和信息技术领域。下面将详细介绍C语言数据结构实现之字符串...
数据结构day3
qq_55245263的博客
07-18 149
【代码】数据结构day3。
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 323
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 791
24暑假刷题day15打卡 二叉树进阶
【数据结构】二叉树-1
m0_46676283的博客
07-15 859
现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
【排序算法】—— 归并排序
2302_80105876的博客
07-15 784
归并排序，排序，归并排序非递归，有序数组排序，外排序算法
【数据结构】手写快速排序
qq_59143106的博客
07-14 300
什么是快速排序？首先确立pivot，比如下图位于末尾然后i遍历3到6在3的时候，j指向i前面一位如果3
【Java--数据结构】栈的应用
2301_80898480的博客
07-14 753
如有错误，欢迎指出~
7月18日学习打卡，数据结构堆
最新发布
2302_81982408的博客
07-18 398
数据结构堆打卡
（9）Python 数据结构：构建高效算法与金融应用的基石
架构筑梦的Cherry Yang的博客
07-14 937
当我们谈论数据结构时，我们实际上是在探讨一种组织、存储和管理数据的系统方法。在编程中，数据结构的选择对程序的性能、可读性和可维护性都有着深远的影响。Python，作为一种功能强大且易于学习的编程语言，提供了丰富的数据结构供我们使用。
数据结构——考研笔记（三）线性表之单链表
weixin_73044854的博客
07-15 858
顺序表优点：可随机存取，存储密度高缺点：要求大片连续空间，改变容量不方便单链表优点：不要求大片连续空间，改变容量方便缺点：不可随机存取，要消耗一定空间存放指针用代码实现单链表typedef struct LNode{ //定义单链表结点类型//每个节点存放一个数据元素//指针指向下一个节点。
数据结构第29节 后缀树和后缀数组
hummhumm的专栏
07-15 505
后缀树和后缀数组都是用于高效处理字符串搜索问题的数据结构，它们特别适合于解决涉及字符串模式匹配、重复子串查找等问题。下面我将结合Java代码解释这两种数据结构的基本概念以及如何构建它们。
C语言强化-1.数据结构概述
Annabelle___的博客
07-18 427
与408的关联：1. 逻辑结构和存储结构在选择题中会有涉及。2. 时间复杂度几乎是每一年大题必考内容！
数据结构_顺序表专题
2301_80682565的博客
07-14 624
准确概念数据结构就是计算机存储、组织数据的方式概念分析从上句分析，数据结构是一种方式。一种管理数据的方式。为了做什么？为的就是计算机存储数据，组织数据。存储数据好理解，就是把数据导进计算机。组织数据：组织二字：就好比将军带兵。计算机无疑就是将军，数据就是征入军营的士兵们，数据现在还没真正成为士兵，得靠将军对它们进行管理、操练。比如增加能人志士，淘汰不合格的士兵，平时点卯（对士兵进行点名），对士兵在刀剑、骑射方面进行能力的增强。概念解释清楚了，再看一眼概念：相信同学们已经把概念刻进了DNA。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值