C || 图的四种存储结构实现

最新推荐文章于 2024-05-10 03:59:29 发布
最新推荐文章于 2024-05-10 03:59:29 发布
阅读量2.2k 收藏 21
点赞数 4
分类专栏： 数据结构 算法 c 文章标签： c graph
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/perry0528/article/details/82794564
版权
数据结构 同时被 3 个专栏收录
29 篇文章 5 订阅
订阅专栏
算法
27 篇文章 1 订阅
订阅专栏
c
13 篇文章 0 订阅
订阅专栏

1. 数组表示法（邻接矩阵法）：

#include <stdio.h>
#include <limits.h>

#define INFINITY INT_MAX
#define Maxvex 100

typedef struct graph {
	int vexs[Maxvex+1];  //顶点
	int AdjMatrix[Maxvex+1][Maxvex+1]; //邻接矩阵
	int vexsnum, edgenum; //顶点数，边数
}Graph;

void CreateGraph(Graph *G) {
	printf("请输入顶点数，边数：");
	scanf("%d %d",&G->vexsnum, &G->edgenum);
	for (int i = 1; i <= G->vexsnum; i++) {
		scanf("%d",&G->vexs[i]);
		for (int j = 1; j <= G->vexsnum; j++) {
			G->AdjMatrix[i][j] = INFINITY;	
		}
	}
	int row, col, w;
	for (int i = 1; i <= G->edgenum; i++) {
		printf("输入边坐标i,j,权值:");
		scanf("%d%d%d",&row, &col, &w);
		G->AdjMatrix[row][col] = w;
		G->AdjMatrix[col][row] = w;
	}
}

int main () {
	Graph G;
	CreateGraph(&G);
	
	return 0;
}

2.邻接表

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

#define Vertex_Num 100
typedef int VertexType;

//存储弧的结点
typedef struct ArcNode {
	int adjvex; //该弧所指向的顶点的位置
	int info; //该弧的权值
	struct ArcNode *next; //指向下一条弧的指针
}ArcNode;

//存储顶点的结点
typedef struct VNode {
	VertexType data;
	ArcNode *first;//指向第一条依附该顶点的弧的指针
}VNode, AdjList[Vertex_Num];

//图
typedef struct {
	AdjList vertices;
	int vexnum, arcnum; //图的顶点数和弧数
}Graph;	

void CreateGraph(Graph *G) {
	printf("请输入顶点数，边数:\n");
	scanf("%d %d", &G->vexnum, &G->arcnum);
	printf("请输入顶点\n");
	for (int i = 1; i <= G->vexnum; i++) {
		scanf("%d",&G->vertices[i].data);
		G->vertices[i].first = NULL;
	}
	printf("请选择你要建立的存储类型，1表示邻接表，0表示逆邻接表:\n");
	int choice;
	scanf("%d",&choice);
	int vex1, vex2, weight;
	if (choice != 1 && choice != 0) {
		printf("输入有错，请重新输入\n");
		scanf("%d",&choice);
	}
	
	if (choice == 1) {
		for (int j =1; j <= G->arcnum; j++) {
			printf("请输入边的两个顶点以及权值:\n");
			scanf("%d%d%d", &vex1, &vex2, &weight);
			ArcNode *edge = (ArcNode*)malloc(sizeof(ArcNode));
			edge->adjvex = vex2;
			edge->info = weight;
			edge->next = G->vertices[vex1].first;
			G->vertices[vex1].first = edge;
		}
	}
	if (choice == 0) {
		for (int j =1; j <= G->arcnum; j++) {
			printf("请输入边的两个顶点以及权值:\n");
			scanf("%d%d%d", &vex1, &vex2, &weight);
			ArcNode *edge = (ArcNode*)malloc(sizeof(ArcNode));
			edge->adjvex = vex1;
			edge->info = weight;
			edge->next = G->vertices[vex2].first;
			G->vertices[vex2].first = edge;
		}	
	}
	
}



int main()
{
    Graph G;
    CreateGraph(&G);
    for(int i = 1; i <= G.vexnum; i++)
    {
        printf("|%d|->", G.vertices[i].data);
        ArcNode *e = G.vertices[i].first;
        while(e != NULL)
        {
            printf("%d->", e->adjvex);
            e = e->next;
        }
        printf("NULL\n");
    }
 
    return 0;

}

运行结果：

  • 邻接表：

在这里插入图片描述

  • 逆邻接表：
    在这里插入图片描述
    c++按顺序实现：
//邻接表和逆邻接表的c++表示
//主要表现的为有向图
#include <iostream>
#include <string>
#include <malloc.h>
#include <string.h>
#define Vertex_Num 20

using namespace std;
struct ArcNode {
	int adjvex;
	ArcNode *nextarc;
};
struct VNode
{
	int data;
	ArcNode *first;
};

typedef VNode AdjList[Vertex_Num];

struct Graph
{
	AdjList vertices;
	int vexnum, arcnum; //图的顶点数和弧数
	int kind;
};

int findData(AdjList adj, int num, int v) {
	for (int i = 0; i < num; i++) {
		if (adj[i].data == v) {
			return i;
		}
	}
}

void CreateGraph(Graph *G) {
	cout << "请输入顶点数和弧数: " << endl;
	cin >> G->vexnum >> G->arcnum;
	cout << "请输入顶点: " << endl;
	for (int i = 0; i < G->vexnum; i++) {
		cin >> G->vertices[i].data;
		G->vertices[i].first = NULL;
	}
	cout << "请输入你要存储的类型: 0表示邻接表, 1表示逆邻接表: " << endl;
	cin >> G->kind;
	if (G->kind == 0) {
		for (int i = 0; i < G->arcnum; i++) {
			int v1, v2;
			cout << "请输入要存储的弧尾和弧头：" << endl;
			cin >> v1 >> v2;
			int i0 = findData(G->vertices, G->vexnum, v1);
			ArcNode *arc0 = new ArcNode;
			arc0->adjvex = v2;
			arc0->nextarc = NULL;
			if (G->vertices[i0].first == NULL) {
				G->vertices[i0].first = arc0;
			}
			else {
				ArcNode *head = G->vertices[i0].first;
				while (head->nextarc != NULL) {
					head = head->nextarc;
				}
				head->nextarc = arc0;
			}
		}
	}
	else if (G->kind == 1) {
		for (int i = 0; i < G->arcnum; i++) {
			int v1, v2;
			cout << "请输入要存储的弧尾和弧头：" << endl;
			cin >> v2 >> v1;
			int i0 = findData(G->vertices, G->vexnum, v1);
			ArcNode *arc0 = new ArcNode;
			arc0->adjvex = v2;
			arc0->nextarc = NULL;
			if (G->vertices[i0].first == NULL) {
				G->vertices[i0].first = arc0;
			}
			else {
				ArcNode *head = G->vertices[i0].first;
				while (head->nextarc != NULL) {
					head = head->nextarc;
				}
				head->nextarc = arc0;
			}
		}
	}
	else {
		cout << "输入错误！" << endl;
	}
}

void PrintGraph(Graph G) {
	for (int i = 0; i < G.vexnum; i++) {
		cout << "|" << G.vertices[i].data << "|" << "->";
		ArcNode *head = G.vertices[i].first;
		while (head != NULL) {
			cout << head->adjvex << "->";
			head = head->nextarc;
		}
		cout << "NULL" << endl;
	}
}

int main () {
	Graph g;
	CreateGraph(&g);
	PrintGraph(g);
	return 0;
}

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

3. 十字链表：

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

// - - - - - 有向图的十字链表存储结构 - - - - -
//相当于把有向图的邻接表和逆邻接表结合到一起得到的一种链表
#define VERTEX_NUM 100
typedef int VertexType;

//弧结点
typedef struct ArcBox {
	int tailvex, headvex; //弧头和弧尾的位置
	struct ArcBox *hlink, *tlink; //分别指向下一个弧头和弧尾相同的链域
	int info;  //弧的权值	
}ArcBox;

//顶点结点
typedef struct VexNode {
	VertexType data;
	ArcBox *firstin, *firstout;	
}VexNode;

//图
typedef struct {
	VexNode xlist[VERTEX_NUM]; //表头向量
	int vexnum, arcnum; //有向图的当前顶点数和弧数
}Graph;


void CreateGraph(Graph *G) {
	printf("请输入顶点数，弧数:\n");
	scanf("%d%d",&G->vexnum, &G->arcnum);
	printf("请输入顶点:\n");
	for (int i = 1; i <= G->vexnum; i++) {
		scanf("%d",&G->xlist[i].data);
		G->xlist[i].firstin = NULL;
		G->xlist[i].firstout = NULL;
	}
	int vex1, vex2, weight;
	for (int i = 1; i <= G->arcnum; i++) {
		printf("请输入弧尾，弧头，弧的权值\n");
		scanf("%d%d%d",&vex1, &vex2, &weight);
		ArcBox *e = (ArcBox*)malloc(sizeof(ArcBox));
		e->tailvex = vex1;
		e->headvex = vex2;
		e->tlink = NULL;
		e->hlink = NULL;
		e->tlink = G->xlist[vex1].firstout;
		G->xlist[vex1].firstout = e;
		e->hlink = G->xlist[vex2].firstin;
		G->xlist[vex2].firstin = e;
	}	
}

4. 邻接多重表：

// - - - - - 图的邻接多重表存储表示 - - - - -
// - - - - - - 更适用于无向图 - - - - - -
// - - 相比邻接表更方便对某一条边进行操作 - -
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define VERTEX_NUM 100

typedef enum {unvisited, visited} VisitIf;
typedef int VertexType;

typedef struct EBox {
	VisitIf mark; //访问标记
	int ivex, jvex;
	struct EBox *ilink, *jlink; //分别指向依附这两个顶点的下一条边
	int info; //权值
}EBox;

typedef struct VexBox {
	VertexType data;
	EBox *firstedge; //指向第一条依附该顶点的边
}VexBox;

typedef struct {
	VexBox adjmulist[VERTEX_NUM];
	int vexnum, edgenum; //图的顶点数和弧数
}Graph;

void CreateGraph(Graph *G) {
	//G = (Graph*)malloc(sizeof(Graph)); 
	printf("请输入点数，弧数\n");
	scanf("%d%d",&G->vexnum, &G->edgenum);
	printf("请输入顶点\n");
	for(int i = 1; i <= G->vexnum; i++) {
		scanf("%d",&G->adjmulist[i].data);
		G->adjmulist[i].firstedge = NULL;
	}
	int v1, v2, weight;
	for(int k = 1; k <= G->edgenum; k++) {
		printf("请输入两个顶点v1,v2以及弧的权值\n");		
		scanf("%d%d%d",&v1,&v2,&weight);
		EBox *edge = (EBox*)malloc(sizeof(EBox));
		edge->mark = unvisited;
		edge->ivex = v1;
		edge->jvex = v2;
		edge->info = weight;
		edge->ilink = NULL;
		edge->jlink = NULL;
		EBox *p = G->adjmulist[v1].firstedge;
		if (!p) {
			G->adjmulist[v1].firstedge = edge;
		}
		else {
			while((p->ilink != NULL && p->ivex == v1) || (p->jlink != NULL && p->jvex == v1)) {
				if(v1 == p->ivex) 
					p = p->ilink; 
				else 
					p = p->jlink; 
			} 
				if(p->ivex == v1) p->ilink = edge; 
				else p->jlink = edge;  
		}
		p = G->adjmulist[v2].firstedge;
		if (!p) {
			G->adjmulist[v2].firstedge = edge;
		}
		else {
			while((p->ilink != NULL && p->ivex == v2) || (p->jlink != NULL && p->jvex == v2)) {
				if(v2 == p->ivex) 
					p = p->ilink; 
				else
					p = p->jlink; 
			} 
				if(p->ivex == v2) p->ilink = edge; 
				else p->jlink = edge; 

		}
	}
}

void PrintGraph(Graph G)
{
    EBox *p;
    for(int i = 1; i <= G.vexnum; ++i)
    {
        p = G.adjmulist[i].firstedge;
        while(p != NULL)
        {
            if(p->ivex == i)    //判断相等才能知道连接上的是ivex还是jvex;
            {
                printf("%d--%d\n", G.adjmulist[p->ivex].data, G.adjmulist[p->jvex].data);
                p = p->ilink;
            }
            else
            {
                printf("%d--%d\n", G.adjmulist[p->jvex].data, G.adjmulist[p->ivex].data);
                p = p->jlink;
            }
        }
    }
}

int main () {
	Graph G;
	CreateGraph(&G);
	PrintGraph(G);
	return 0;
}

运行结果：
在这里插入图片描述
c++实现：

//无向图的邻接多重表
#include <iostream>
using namespace std;
#define MAX_VERTEX_NUM 20
enum VisitIf {unvisited, visited};
class EBox {
public:
	VisitIf mark; //访问标记
	int ivex, jvex; //该边依附的两个顶点位置
	EBox *ilink, *jlink; //分别指向依附这两个顶点的下一条边
};
template <typename T>
class VexBox {
public:
	T data;
	EBox *firstedge; //指向第一条依附该顶点的边
};
template <typename T>
class AMLGraph {
public:
	VexBox<T> adjmulist[MAX_VERTEX_NUM];
	int vexnum, edgenum; //无向图的当前顶点数和边数
};
template <typename T>
int LocateVex(VexBox<T> adj[], int num, T v) {
	for (int i = 0; i < num; i++) {
		if (adj[i].data == v) {
			return i;
		}
	}
}
template <typename T>
void CreateGraph(AMLGraph<T> *G) {
	cout << "请输入顶点数和弧数: " << endl;
	cin >> G->vexnum >> G->edgenum;
	cout << "请输入顶点: " << endl;
	for (int i = 0; i < G->vexnum; i++) {
		cin >> G->adjmulist[i].data;
		G->adjmulist[i].firstedge = NULL;
	}
	for (int i = 0; i < G->edgenum; i++) {
		cout << "请输入边的两个顶点: " << endl;
		T v1, v2;
		cin >> v1 >> v2;
		int i1 = LocateVex(G->adjmulist, G->vexnum, v1);
		int i2 = LocateVex(G->adjmulist, G->vexnum, v2);
		//cout << i1 << "...." << i2 << endl;
		EBox *p = new EBox;
		p->mark = unvisited;
		p->ivex = i1;
		p->jvex = i2;
		p->ilink = G->adjmulist[i1].firstedge;
		p->jlink = G->adjmulist[i2].firstedge;
		G->adjmulist[i1].firstedge = p;
		G->adjmulist[i2].firstedge = p;
	}
}
template <typename T>
void PrintGraph(AMLGraph<T> G)
{
    EBox *p;
    for(int i = 0; i < G.vexnum; ++i)
    {
        p = G.adjmulist[i].firstedge;
        while(p != NULL)
        {
            if(p->ivex == i)    //判断相等才能知道连接上的是ivex还是jvex;
            {
            	cout <<  G.adjmulist[p->ivex].data << "------" << G.adjmulist[p->jvex].data << endl;
                //printf("%d--%d\n", G.adjmulist[p->ivex].data, G.adjmulist[p->jvex].data);
                p = p->ilink;
            }
            else
            {
               cout <<  G.adjmulist[p->jvex].data << "------" << G.adjmulist[p->ivex].data << endl;
                p = p->jlink;
            }
        }
    }
}

int main () {
	AMLGraph<string> g;
	CreateGraph(&g);
	PrintGraph(g);
	return 0;
}

在这里插入图片描述
总结一下以上所有的表示形式中，邻接矩阵有向无向图都可用，但常用于表现无向图。邻接表也是有向无向都可用，但因为表示无向图会使边重复显得繁琐，所以常用于表示有向图。十字链表是将有向图的邻接表和逆邻接表相结合使用。而邻接多重表相当于无向图的十字链表表示法。无向图我们常用邻接矩阵和邻接多重表表示，尤其邻接多重表可避免双边的重复访问。

perry0528
关注
  • 4
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言 数据结构实现之字符串
08-30
C语言数据结构实现之字符串 C语言数据结构实现之字符串是指使用C语言来实现字符串数据结构的相关操作。字符串是一种基本的数据结构，广泛应用于计算机科学和信息技术领域。下面将详细介绍C语言数据结构实现之字符串...
C语言实现数据结构串（堆分配存储表示法）实例详解
01-20
存储结构： 构建堆来存储字符串，本质上是顺序表 实现代码： #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 #define STR_INIT_SIZE 100 #...
数据结构--图的存储方式
IT小小鸟～～
03-30 9258
主要写一下图的几种表示方法。 今天写的几种图存储结构包括邻接矩阵，邻接表，十字链表，邻接多重表，边集数组。 主要是邻接表，十字链表和邻接多重表。邻接矩阵和边集数组比较好理解和实现 我在网上查了一些资料和看了课本上的十字链表和邻接多重表的例子，个人觉得讲的不那么通俗，尤其是课本... 目录：          0.预备知识          1.邻接矩阵        
图的五种存储结构及其C语言实现
CS_boy的博客
10-18 4068
文章目录???? 一、图的基本概念????二、图的基本存储结构????1.邻接矩阵法????1.1 存储结构????1.2 创建邻接矩阵????1.3 打印邻接矩阵存储的图????1.4 测试函数????2.邻接表法????2.1 存储结构????2.2 创建邻接表????2.3 打印邻接表法存储的图????2.4 测试函数????️3.十字链表法????️3.1 存储结构????3.2 创建十字链表????3.3 打印十字链表存储的图????3.4 测试函数????4.邻接多重表法????4.1 存储结构
2024年最全【开卷数据结构 】图的五大存储方式_图的存储(1)，零基础学大数据开发开发
2401_84592111的博客
05-10 882
jlink 指向下一条依附于顶点 jvex 的边，info 为指向和边相关的各种信息的指针域。**A：**在邻接多重表中，所有依附于同一顶点的边串联在同一链表中，由于每条边依附于两个顶点，因此每个边结点同时链接在两个链表中。对无向图而言，其邻接多重表和邻接表的差别仅在于，同一条边在邻接表中用两个结点表示，而在邻接多重表中只有一个结点。另一个是存储边的信息。在邻接表中，容易求得顶点和边的各种信息，但在邻接表中求两个顶点之间是否存在边而对边执行删除等操作时，需要分别在两个顶点的边表中遍历，效率较低。
图——基本的图算法（一）图的存储结构
hh66__66hh的博客
10-19 2万+
图——基本的图算法（一）图的存储结构 1. 图的表示方法 对于图G=(V, E)来说，可以有两种标准的表示方法，这两种方法都可以表示有向图和无向图： （1）邻接矩阵 （2）邻接链表 ...
【数据结构（28）】6.4 图的存储结构
shangguanxiu的博客
01-19 3178
严蔚敏版【数据结构】1. 邻接矩阵表示法：无向图的邻接矩阵、有向图的邻接矩阵、网的邻接矩阵、邻接矩阵创建无向网 2. 邻接表：无向图的邻接表、有向图的邻接表、图的邻接表存储表示、邻接表示法创建无向图 3. 十字链表 4. 邻接多重表
【数据结构】图的四种存储结构
haohulala的博客
07-14 4208
邻接矩阵 //邻接矩阵 //分别存储两个矩阵 //一个矩阵用于存顶点的信息 //另一个矩阵用于存弧的信息 #define INFINITY 65535 #define MAX_VERTEX_NUM 20 typedef int VEType; typedef int InforType; typedef enum{DG, DN, UDG, UDN} GraphKind; //图的类...
线性表的顺序存储结构c语言实现
07-01
C语言是一种强大的系统编程语言，非常适合实现这样的数据结构。 在顺序存储结构中，线性表的元素按照它们在内存中的位置顺序存储，这种存储方式具有连续性，便于进行随机访问和元素的物理位置操作。下面将详细介绍...
数据结构使用类C语言实现.zip
10-18
《严蔚敏数据结构使用类C语言实现》是一本经典的计算机科学教材，它详细介绍了如何用类C语言来实现各种重要的数据结构。在本压缩包中，包含的是一个名为"data-structures-master"的项目源码，这个项目是为了帮助读者...
四则运算_C语言_数据结构_四则运算_
10-02
在这个项目中，我们看到的是如何用C语言来实现一个能够处理包括括号在内的四则运算的程序。 首先，我们来看"四则运算(带括号).cpp"这个文件。在C语言中，处理带有括号的表达式通常涉及解析算法，这可能使用到了递归...
c语言版数据结构书内44种结构实现.rar
11-25
这本C语言版的数据结构书籍涵盖了44种不同的数据结构实现，每一种都是理解算法和优化程序性能的关键。下面我们将深入探讨这些数据结构及其在C语言中的实现。 首先，我们有基础的线性数据结构，如数组、链表和栈。...
《数据结构》的全部代码实现C语言.zip
06-18
C语言中通常使用邻接矩阵或邻接表来存储图，实现图的遍历算法（深度优先搜索和广度优先搜索）。 4. **哈希表**： - 哈希表提供快速的查找、插入和删除操作，基于哈希函数将键映射到数组的索引。C语言中的哈希表...
严蔚敏数据结构全套C语言实现
最新发布
05-21
这本书主要采用C语言作为实现语言，C语言因其高效、灵活而常被用于编写底层数据结构和算法。 1. **数组**：数组是最基础的数据结构，它是一个相同类型元素的集合，通过索引进行访问。C语言中的数组可以是一维、二维...
C语言基础学习包括数据结构C语言实现
11-16
本主题主要关注C语言的基础学习及其在数据结构实现中的应用。 首先，我们需要理解C语言的基础概念。C语言的核心包括变量、常量、运算符、控制结构（如if语句、switch语句、for循环、while循环）、函数等。掌握这些...
线性表链式存储结构C语言实现
10-04
本主题主要关注的是链式存储结构在C语言中的实现。 链式存储结构与顺序存储不同，不依赖于内存中的连续空间来存储元素。每个元素（称为节点）包含两部分：数据域，用于存储数据；指针域，用于存储指向下一个节点的...
计算机四种存储结构,数据的四种存储结构
weixin_42115074的博客
07-27 8902
大家好，我是时间财富网智能客服时间君，上述问题将由我为大家进行解答。数据的四种基本存储结构是：1、顺序存储顺序存储方式就是在一块连续的存储区域一个接着一个的存放数据。顺序存储方式把逻辑上相邻的节点存储在物理位置相邻的存储单元里，节点间的逻辑关系由存储单元的邻接关系来体现。顺序存储方式也称为顺序存储结构，一般采用数组或结构数组来描述。2、链接存储链接存储方式比较灵活，不要求逻辑上相邻的节点在物理位置...
数据结构之图的存储结构一及其实现
顾小豆的博客
02-27 1万+
图的存储结构由于图的结构比较复杂，任意两个顶点之间都可能存在联系，因此无法以数据元素在存储区中的物理位置来表示元素之间的关系，即图没有顺序映像的存储结构，但可以借助数组的数据类型表示元素之间的关系。另一方面，用多重链表表示图是自然的事，它是一种最简单的链式映像结构，即以一个右一个数据域和多个指针域组成的结点表示图中的一个顶点，其中数据域存储该顶点的信息，指针域存储指向其邻接点的指针。但是，由于图中...
数据结构：图的存储结构之邻接表
热门推荐
Meditation
04-30 14万+
对于图来说，邻接矩阵是不错的一种图存储结构，但是我们也发现，对于边数相对顶点较少的图，这种结构是存在对存储空间的极大浪费的。因此我们考虑另外一种存储结构方式：邻接表（Adjacency List），即数组与链表相结合的存储方法。 邻接表的处理方法是这样的。 1、图中顶点用一个一维数组存储，另外，对于顶点数组中，每个数据元素还需要存储指向第一个邻接点的指针，以便于查找该顶点的边信息。 2、图中
C语言实现数据结构：逻辑与存储结构详解
数据结构C语言是一本由朱战立编著，电子工业出版社于2009年1月出版的教材，该书将数据结构理论与C语言编程实践相结合，旨在帮助读者深入理解数据结构的基本概念，并掌握如何在C语言环境中实现它们。以下是本书的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值