图的广度优先遍历实现

最新推荐文章于 2023-03-20 15:30:42 发布
最新推荐文章于 2023-03-20 15:30:42 发布
阅读量2.1k 收藏 13
点赞数 2
分类专栏： 数据结构与算法 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43671437/article/details/121358125
版权

文章目录

题目描述

图的广度优先遍历实现
要求：
1、以邻接表形式构造图；
2、打印输出邻接表；
3、输出：广度优先遍历序列；

输入：
顶点数、边数目。
点、边集合表示（1代表存在边，0代表不存在边）
输出：
（1）边逻辑正确，则输出：“输入正确！”
（2）边逻辑不正确，则输出：“输入边数不对！程序退出！！“
（3）输出邻接表存储；
（4）输出广义遍历结果。

输入

5 8 // 5代表顶点数， 8 代表边数目
0 1 0 1 1

1 0 1 1 0

0 1 0 1 1

1 1 1 0 1

1 0 1 1 0

输出

输入正确！
图G的邻接表:
0: 1[1]→ 3[1]→ 4[1]→∧
1: 0[1]→ 2[1]→ 3[1]→∧
2: 1[1]→ 3[1]→ 4[1]→∧
3: 0[1]→ 1[1]→ 2[1]→ 4[1]→∧
4: 0[1]→ 2[1]→ 3[1]→∧
广度优先序列: 2 1 3 4 0

样例输入

5 8
0 1 0 1 1

1 0 1 1 0

0 1 0 1 1

1 1 1 0 1

1 0 1 1 1

样例输出

输入边数不对！程序退出！！

代码实现

(1)、图的创建输出销毁

#include <iostream>
#include <stdlib.h>

using namespace std;

#define MAXV 100
#define INF 32767   //定义无穷

typedef int InfoType;

//边
typedef struct ANode
{
    int adjvex;
    struct ANode *nextarc;
    int weight;
} ArcNode;

//顶点
typedef struct Vnode
{
    InfoType info;
    ArcNode *firstarc;
} VNode;

//图
typedef struct
{
    VNode adjlist[MAXV];
    int n, e;
}AdjGraph;


//创建图运算算法
void GreateAdj(AdjGraph *&G, int A[MAXV][MAXV], int n, int e)
{
    int i, j;
    ArcNode *p;
    G = (AdjGraph *)malloc(sizeof(AdjGraph));
    //给邻接表中所有头结点的指针域置初值
    for(i = 0; i < n; i++)
    {
        G->adjlist[i].firstarc = NULL;
    }
    //检查邻接矩阵中的每个元素
    for(i = 0; i < n; i++)
    {
        for(j = n-1; j >= 0; j--)
        {
            //存在一条边
            if(A[i][j] != 0 && A[i][j] != INF)
            {
                //创建一个结点p
                p = (ArcNode *)malloc(sizeof(ArcNode));
                //存放邻接结点
                p->adjvex = j;
                //存放权
                p->weight = A[i][j];
                //采用头插法插入结点p
                p->nextarc = G->adjlist[i].firstarc;
                G->adjlist[i].firstarc = p;
            }
        }
    }
    G->n = n;
    G->e = e;
}


//输出图的运算算法
void DispAdj(AdjGraph *G)
{
    int i;
    ArcNode *p;

    for(i = 0; i < G->n; i++)
    {
        p = G->adjlist[i].firstarc;
        cout<<i<<":   ";
        while(p != NULL)
        {
            cout<<p->adjvex<<"["<<p->weight<<"]"<<"-> ";
            p = p->nextarc;
        }
        cout<<"^"<<endl;
    }
}

//销毁图的运算算法
void DistroyAdj(AdjGraph *&G)
{
    int i;
    ArcNode *pre, *p;
    //扫描所有单链表
    for(i = 0; i < G->n; i++)
    {
        //p指向第i个单链表的头结点
        pre = G->adjlist[i].firstarc;
        if(pre != NULL)
        {
            p = pre->nextarc;
            //释放第i个单链表的所有边结点
            while(p != NULL)
            {
                free(pre);
                pre = p;
                p = p->nextarc;
            }
            free(pre);
        }
    }
    //释放头结点数组
    free(G);
}



int main()
{
    AdjGraph *G;
    int A[MAXV][MAXV];
    int n;
    int e;
    int sum = 0;

    //输入顶点数
    cin>>n;
    //输入边的个数
    cin>>e;

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            cin>>A[i][j];
            if(A[i][j] == 1)
            {
                sum++;
            }
        }
    }
    
    if(sum != 2*e)
    {
        cout<<"输入边数不对！程序退出！！"<<endl;
        return 0;
    }
    cout<<"输入正确！"<<endl;
    cout<<"图G的邻接表:"<<endl;
    //创建图
    GreateAdj(G, A, n, e);

    //打印图
    DispAdj(G);

    //销毁图
    DistroyAdj(G);

    return 0;
}

(2)、含广度优先遍历实现代码（c++）

#include <iostream>
#include <stdlib.h>

using namespace std;

#define MAXV 100
#define MaxSize 10
#define INF 32767   //定义无穷

typedef int InfoType;
typedef int ElemType;


//边
typedef struct ANode
{
    int adjvex;
    struct ANode *nextarc;
    int weight;
} ArcNode;

//顶点
typedef struct Vnode
{
    InfoType info;
    ArcNode *firstarc;
} VNode;

//图
typedef struct
{
    VNode adjlist[MAXV];
    int n, e;
}AdjGraph;

typedef struct
{
    ElemType data[MaxSize];
    int front, rear;
} SqQueue;


//创建图运算算法
void GreateAdj(AdjGraph *&G, int A[MAXV][MAXV], int n, int e)
{
    int i, j;
    ArcNode *p;
    G = (AdjGraph *)malloc(sizeof(AdjGraph));
    //给邻接表中所有头结点的指针域置初值
    for(i = 0; i < n; i++)
    {
        G->adjlist[i].firstarc = NULL;
    }
    //检查邻接矩阵中的每个元素
    for(i = 0; i < n; i++)
    {
        for(j = n-1; j >= 0; j--)
        {
            //存在一条边
            if(A[i][j] != 0 && A[i][j] != INF)
            {
                //创建一个结点p
                p = (ArcNode *)malloc(sizeof(ArcNode));
                //存放邻接结点
                p->adjvex = j;
                //存放权
                p->weight = A[i][j];
                //采用头插法插入结点p
                p->nextarc = G->adjlist[i].firstarc;
                G->adjlist[i].firstarc = p;
            }
        }
    }
    G->n = n;
    G->e = e;
}


//输出图的运算算法
void DispAdj(AdjGraph *G)
{
    int i;
    ArcNode *p;

    for(i = 0; i < G->n; i++)
    {
        p = G->adjlist[i].firstarc;
        cout<<" "<<i<<": ";
        while(p != NULL)
        {
            cout<<" "<<p->adjvex<<"["<<p->weight<<"]"<<"→";
            p = p->nextarc;
        }
        cout<<"^"<<endl;
    }
}

//销毁图的运算算法
void DistroyAdj(AdjGraph *&G)
{
    int i;
    ArcNode *pre, *p;
    //扫描所有单链表
    for(i = 0; i < G->n; i++)
    {
        //p指向第i个单链表的头结点
        pre = G->adjlist[i].firstarc;
        if(pre != NULL)
        {
            p = pre->nextarc;
            //释放第i个单链表的所有边结点
            while(p != NULL)
            {
                free(pre);
                pre = p;
                p = p->nextarc;
            }
            free(pre);
        }
    }
    //释放头结点数组
    free(G);
}

void InitQueue(SqQueue *&q)
{
    q = (SqQueue *)malloc(sizeof(SqQueue));
    q->front = q->rear = 0;
}


void DestroyQueue(SqQueue *&q)
{
    free(q);
}

bool QueueEmpty(SqQueue *q)
{
    return (q->front == q->rear);
}

bool enQueue(SqQueue *&q, ElemType e)
{
    if((q->rear+1)%MaxSize == q->front)
    {
        //printf("队列已满，%d进队不成功！\n", e);
        cout<<"队列已满，%d进队不成功！\n"<<e;
        return false;
    }

    q->rear = (q->rear+1)%MaxSize;
    q->data[q->rear] = e;
    return true;

}

bool deQueue(SqQueue *&q, ElemType &e)
{
    if(q->front == q->rear)
        return false;
    q->front = (q->front + 1)%MaxSize;
    e = q->data[q->front];
    return true;
}

//广度优先序列
void BFS(AdjGraph *G, int v)
{
    int w, i;
    ArcNode *p;
    SqQueue *qu;
    InitQueue(qu);
    int visited[MAXV];
    for(i = 0; i < G->n; i++)
    {
        visited[i] = 0;
    }
    cout<<"广度优先序列:"<<v;
    visited[v] = 1;
    enQueue(qu, v);
    while(!QueueEmpty(qu))
    {
        deQueue(qu, w);
        p = G->adjlist[w].firstarc;
        while(p != NULL)
        {
            if(visited[p->adjvex] == 0)
            {
                cout<<" "<<p->adjvex;
                visited[p->adjvex] = 1;
                enQueue(qu, p->adjvex);
            }
            p = p->nextarc;
        }

    }
    cout<<endl;
}

int main()
{
    AdjGraph *G;
    int A[MAXV][MAXV];
    int n;
    int e;
    int sum = 0;

    //输入顶点数
    cin>>n;
    //输入边的个数
    cin>>e;

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            cin>>A[i][j];
            if(A[i][j] == 1)
            {
                sum++;
            }
        }
    }

    if(sum != 2*e)
    {
        cout<<"输入边数不对！程序退出！！"<<endl;
        return 0;
    }
    cout<<"输入正确！"<<endl;
    cout<<"图G的邻接表:"<<endl;
    //创建图
    GreateAdj(G, A, n, e);

    //打印图
    DispAdj(G);
    
    int v = 2;
    BFS(G, v);
    //销毁图
    DistroyAdj(G);

    return 0;
}

(3)、含广度优先遍历实现代码（C）

//广度优先遍历算法

#define MaxSize 100

//图的基本运算算法
#include <stdio.h>
#include <malloc.h>
//图的两种存储结构
#define INF 32767				//定义∞
#define	MAXV 100				//最大顶点个数
typedef char InfoType;
#include<iostream>
using namespace std;
//以下定义邻接矩阵类型
typedef struct
{	int no;						//顶点编号
	InfoType info;				//顶点其他信息
} VertexType;					//顶点类型
typedef struct
{	int edges[MAXV][MAXV];		//邻接矩阵数组
	int n,e;					//顶点数，边数
	VertexType vexs[MAXV];		//存放顶点信息
} MatGraph;						//完整的图邻接矩阵类型

//以下定义邻接表类型
typedef struct ANode
{	int adjvex;					//该边的邻接点编号
	struct ANode *nextarc;		//指向下一条边的指针
	int weight;					//该边的相关信息，如权值（用整型表示）
} ArcNode;						//边结点类型
typedef struct Vnode
{	InfoType info;				//顶点其他信息
	int count;					//存放顶点入度,仅仅用于拓扑排序
	ArcNode *firstarc;			//指向第一条边
} VNode;						//邻接表头结点类型
typedef struct 
{	VNode adjlist[MAXV];		//邻接表头结点数组
	int n,e;					//图中顶点数n和边数e
} AdjGraph;						//完整的图邻接表类型

void CreateMat(MatGraph &g,int A[MAXV][MAXV],int n,int e) //创建图的邻接矩阵
{
	int i,j;
	g.n=n; g.e=e;
	for (i=0;i<g.n;i++)
		for (j=0;j<g.n;j++)
			g.edges[i][j]=A[i][j];
}
void DispMat(MatGraph g)	//输出邻接矩阵g
{
	int i,j;
	for (i=0;i<g.n;i++)
	{
		for (j=0;j<g.n;j++)
			if (g.edges[i][j]!=INF)
				printf("%4d",g.edges[i][j]);
			else
				printf("%4s","∞");
		printf("\n");
	}
}

void CreateAdj(AdjGraph *&G,int A[MAXV][MAXV],int n,int e) //创建图的邻接表
{
	int i,j;
	ArcNode *p;
	G=(AdjGraph *)malloc(sizeof(AdjGraph));
	for (i=0;i<n;i++)								//给邻接表中所有头结点的指针域置初值
		G->adjlist[i].firstarc=NULL;
	for (i=0;i<n;i++)								//检查邻接矩阵中每个元素
		for (j=n-1;j>=0;j--)
			if (A[i][j]!=0 && A[i][j]!=INF)			//存在一条边
			{	p=(ArcNode *)malloc(sizeof(ArcNode));	//创建一个结点p
				p->adjvex=j;
				p->weight=A[i][j];
				p->nextarc=G->adjlist[i].firstarc;	//采用头插法插入结点p
				G->adjlist[i].firstarc=p;
			}
	G->n=n; G->e=n;
}
void DispAdj(AdjGraph *G)	//输出邻接表G
{
	int i;
	ArcNode *p;
	for (i=0;i<G->n;i++)
	{
		p=G->adjlist[i].firstarc;
		printf("%3d: ",i);//"  0:   "
		while (p!=NULL)
		{
			printf("%3d[%d]→",p->adjvex,p->weight);
			p=p->nextarc;
		}
		printf("∧\n");
	}
}
void DestroyAdj(AdjGraph *&G)		//销毁图的邻接表
{	int i;
	ArcNode *pre,*p;
	for (i=0;i<G->n;i++)			//扫描所有的单链表
	{	pre=G->adjlist[i].firstarc;	//p指向第i个单链表的首结点
		if (pre!=NULL)
		{	p=pre->nextarc;
			while (p!=NULL)			//释放第i个单链表的所有边结点
			{	free(pre);
				pre=p; p=p->nextarc;
			}
			free(pre);
		}
	}
	free(G);						//释放头结点数组
}

typedef int ElemType;
typedef struct 
{	
	ElemType data[MaxSize];
	int front,rear;		//队首和队尾指针
} SqQueue;
void InitQueue(SqQueue *&q)
{	q=(SqQueue *)malloc (sizeof(SqQueue));
	q->front=q->rear=0;
}
void DestroyQueue(SqQueue *&q)
{
	free(q);
}
bool QueueEmpty(SqQueue *q)
{
	return(q->front==q->rear);
}
bool enQueue(SqQueue *&q,ElemType e)
{	if ((q->rear+1)%MaxSize==q->front)	//队满上溢出
		return false;
	q->rear=(q->rear+1)%MaxSize;
	q->data[q->rear]=e;
	return true;
}
bool deQueue(SqQueue *&q,ElemType &e)
{	if (q->front==q->rear)				//队空下溢出
		return false;
	q->front=(q->front+1)%MaxSize;
	e=q->data[q->front];
	return true;
}


void BFS(AdjGraph *G,int v)  
{
	int w,i;
	ArcNode *p;
	SqQueue *qu;							//定义环形队列指针
	InitQueue(qu);							//初始化队列
	int visited[MAXV];            			//定义顶点访问标志数组
	for (i=0;i<G->n;i++) visited[i]=0;		//访问标志数组初始化
	printf("%2d",v); 						//输出被访问顶点的编号
	visited[v]=1;              				//置已访问标记
	enQueue(qu,v);
	while (!QueueEmpty(qu))       			//队不空循环
	{	
		deQueue(qu,w);						//出队一个顶点w
		p=G->adjlist[w].firstarc; 			//指向w的第一个邻接点
		while (p!=NULL)						//查找w的所有邻接点
		{	
			if (visited[p->adjvex]==0) 		//若当前邻接点未被访问
			{
				printf("%2d",p->adjvex);  	//访问该邻接点
				visited[p->adjvex]=1;		//置已访问标记
				enQueue(qu,p->adjvex);		//该顶点进队
           	}
           	p=p->nextarc;              		//找下一个邻接点
		}
	}
	printf("\n");
}

int main()
{	int sum1=0;
	int sum0=0;
	AdjGraph *G;
	int A[MAXV][MAXV]={{0,1,0,1,1},{1,0,1,1,0},
			{0,1,0,1,1},{1,1,1,0,1},{1,0,1,1,0}};
	int n=5, e=8;
	cin>>n>>e;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			cin>>A[i][j];
		}
	}
	for(int i1=0;i1<n;i1++){
		for(int j1=0;j1<n;j1++){
			if(A[i1][j1]==1){sum1=sum1+1;}
			if(A[i1][j1]==0){sum0=sum0+1;}
		}
	}
	if(sum1==2*e&&sum0==n*n-2*e){
		cout<<"输入正确！"<<endl;
	}else{
		cout<<"输入边数不对！程序退出！！"<<endl;
		return 0;
	}
	CreateAdj(G,A,n,e);			//建立《教程》中图8.1(a)的邻接表

	printf("图G的邻接表:\n");
	DispAdj(G);					//输出邻接表G
	printf("广度优先序列:");BFS(G,2);printf("\n");
	DestroyAdj(G);				//销毁邻接表
	return 1;
}

运行结果

在这里插入图片描述

Mr.史
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
图的深度、广度优先遍历（c语言）
12-20
本程序方便的实现了图的深度、广度优先遍历。是数据结构中的一部分，现与大家分享
算法详解——图的深度优先遍历和广度优先遍历
最新发布
python_plus的博客
03-13 1264
图数据中的深度优先遍历算法和广度优先遍历算法
图的广度优先遍历概念和实现
yulio1234的博客
08-31 1041
广度优先遍历是按层次遍历，和树的广度优先遍历很像。给定一个顶点，一层一层的往外遍历。可以想象成一组人在向各个方向走迷宫，当遇到路口时等待其他人走到这一层路口，然后分裂成更多的人走这个迷宫。 广度优先遍历是通过队列实现的。/** * 广度优先遍历 * @author yuli * */ public class BreadthFirstSearch implements Paths{
【数据结构】图的广度优先遍历
每天进步一点丶的博客
03-20 1250
文章目录1.算法思想2.定义结构体3.函数实现4.测试结果5.完整代码 1.算法思想 广度优先遍历，类似于树的层次遍历，又是熟悉的队列实现。首先将第一个顶点添加到队列中，然后讲该顶点的所有邻接顶点都加入队列中，再将该顶点输出。如此重复直到遍历完整个图。 2.定义结构体 typedef struct { char vertex[VERTEXNUM]; int edge[VERTEXNUM][VERTEXNUM]; int n,e; } MGraph; 3.函数实现 Q:队列，用于存
【经典算法实现 32】图的遍历 --- 广度优先遍历算法
|~~~热爱生活、努力学习的小伙汁~~~|
08-24 2920
【经典算法实现 31】图的遍历 --- 广度优先遍历算法一、 广度优先遍历算法1.1 实现思路1.2 广度优先遍历算法代码实现二、完整代码2.1 运行结果 本文接着 《【经典算法实现 30】图的创建 — 十字链表法》， 《【经典算法实现 31】图的遍历 — 深度优先遍历算法》 本文，我们来实现图的广度优先遍历算法。 先上图 一、 广度优先遍历算法 深度优先遍历算法 与 广度优先遍历算法 最大的区别在于， 深度优先遍历算法 使用的栈，后进先出 广度优先遍历算法 使用的是队列，先进先出 1.1 实现
C++实现图的邻接表存储和广度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接表存储和广度优先遍历方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6...
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
主要介绍了JavaScript树的深度优先遍历和广度优先遍历算法,结合实例形式分析了JavaScript树的深度优先遍历、广度优先遍历递归与非递归相关实现技巧,需要的朋友可以参考下
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
js代码-二叉树广度优先遍历
07-16
js代码-二叉树广度优先遍历
PHP实现二叉树的深度优先与广度优先遍历方法
12-19
本文实例讲述了PHP实现二叉树的深度优先与广度优先遍历方法。分享给大家供大家参考。具体如下： #二叉树的广度优先遍历 #使用一个队列实现 class Node { public $data = null; public $left = null; public $...
广度优先遍历,深度优先遍历实例代码
12-06
图的遍历，查找最短路径 广度优先遍历 深度优先遍历
图的深度优先遍历与广度优先遍历(C语言实现)
10-17
数据结构中的图结构，其中最重要的两个遍历算法——深度优先遍历与广度优先遍历
图的遍历（深度优先和广度优先遍历算法）
04-18
图作为较为复杂的数据结构，对图的操作首先应该了解图的深度优先和广度优先搜索遍历算法！
C# 广度优先遍历(BFS)算法实现
01-06
那么广度遍历的顺序就是ABCDEF 从上到下，从左到右去访问 运用到格子游戏中，找寻某点到某点的路径 【假设只记录四方位（遍历顺序上左下右）】 向队列中存入起点，遍历该点周围的点，边界看做障碍，遍历到结束点返回...
C++无向图深度优先和广度优先遍历（编译可运行）.rar
07-12
以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。 注： 1.代码共182行。 2.代码经过多次编译运行，无错误。
PIPIOJ 1397:图的遍历——广度优先搜索
已归档
02-28 773
题目描述： 广度优先搜索遍历类似于树的按层次遍历的过程。其过程为：假设从图中的某顶点v出发，在访问了v之后依次访问v的各个未曾被访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作为起始点。重复上述过程，直至图中所有顶点都被访问到为止。 在本题中，读入一个无向图的邻接矩阵（即数组表示），建立无向图并按照以上描述中的算法遍历所有
（bfs）广度优先 实现图的遍历
zhenaoxi1077的博客
05-17 372
参考书： 《啊哈算法第五章：图的遍历》 《第一节。深度优先和广度优先究竟是啥》——广度优先 实现图的遍历 广度优先算法实现图的遍历代码如下： #include &amp;lt;iostream&amp;gt; using namespace std; int book[101], n = 5, e[101][101]; //n为顶点个数 int que[10001], cur=1, head=...
广度优先遍历代码
Norton的专栏
03-21 877
广度优先周游二叉树(层序遍历)是用队列来实现的，从二叉树的第一层（根结点）开始，自上至下逐层遍历；在同一层中，按照从左到右的顺序对结点逐一访问。 按照从根结点至叶结点、从左子树至右子树的次序访问二叉树的结点。算法：     1初始化一个队列，并把根结点入列；     2根节点入队     3循环直到队列空       3.1  q=队列头元素出队       3.2  访问q的数据域
广度优先遍历实现原理
12-21
广度优先遍历（BFS）是一种图遍历算法，它从图的某个顶点开始，先访问该顶点，然后依次访问该顶点的所有邻接顶点，再依次访问邻接顶点的邻接顶点，以此类推，直到图中所有顶点都被访问到为止。 广度优先遍历的实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Mr.史

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

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

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

打赏作者

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

抵扣说明：

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

余额充值