【代码解析】图的邻接表、DFS和BFS

已于 2022-07-30 16:27:01 修改
阅读量1.6k 收藏 11
点赞数 3
分类专栏： C与数据结构背诵知识点整理 文章标签： c语言
于 2022-04-25 14:28:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xza13155/article/details/124394562
版权

目录

邻接表

有如下无向图
在这里插入图片描述
邻接表的存储结构如下：

//邻接表链表顶点
typedef struct _ENode
{
	int ivex;
	struct _ENode* next_edge;
}ENode;

//邻接表表顶点
typedef struct _VNode
{
	char data;
	ENode* first_edge;
}VNode;

//邻接表
typedef struct _LGraph
{
	int vexnum;
	int edgnum;
	VNode vexs[MAX];
}LGraph;

首先定义一个LGraph为邻接表，存储整个图的节点数量和边数，以及所有节点数组；
再定义一个VNode存储每个节点的名称以及该节点的边；如A节点有三条边AD AF AC；
最后定义ENode，存储每一个终点节点在VNode数组中的下标，以及连接下一条边的指针。值得注意的是虽然叫边节点（ENode）实际存储的是边的信息，不是节点。
在这里插入图片描述

对邻接表初始化

ENode* node1, * node2;
	LGraph* pG;//pG表示图
	//初始化矩阵
	if ((pG = (LGraph*)malloc(sizeof(LGraph))) == NULL)
		return NULL;
	memset(pG, 0, sizeof(LGraph));//就是把申请的空间内初始化为零

	// 初始化"顶点数"和"边数"
	pG->vexnum = vlen;
	pG->edgnum = elen;

初始化邻接表，内存都置为0
在这里插入图片描述
记录邻接表的节点和边的数量，都为7
在这里插入图片描述
循环读取节点数据，初始化节点数组，边都设为NULL

// 初始化"邻接表"的顶点，边都置空
	for (i = 0; i < pG->vexnum; i++)
	{
		pG->vexs[i].data = vexs[i];
		pG->vexs[i].first_edge = NULL;
	}

在这里插入图片描述
两个辅助函数，get_position输入节点名称，返回该节点在节点数组中的下标；
link_last，list为节点中已连接的边；将node连接到list末尾。

//返回ch在矩阵中的位置
static int get_position(LGraph g, char ch)
{
	int i;
	//遍历顶点
	for (i = 0; i < g.vexnum; ++i)
		if (g.vexs[i].data == ch)
			return i;
	return -1;
}

//node链接到list末尾
static void link_last(ENode* list, ENode* node)
{
	ENode* p = list;
	while (p->next_edge)
	{
		p = p->next_edge;
	}
	p->next_edge = node;
}

循环读取每一条边，获取起点P1和终点P2的下标；将P1连接到P2节点的边上；P2连接到P1节点的边上。
对于有向图，只把P2连接到P1节点的边上。

//像节点内写入边
	for (i = 0; i < pG->edgnum; i++)
	{
		// 读取边的起始顶点和结束顶点
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = get_position(*pG, c1);//p1对应起始顶点下标位置
		p2 = get_position(*pG, c2);//p1对应结束顶点下标位置
		// 初始化node1
		node1 = (ENode*)calloc(1, sizeof(ENode));
		node1->ivex = p2;
		if (pG->vexs[p1].first_edge == NULL)
			pG->vexs[p1].first_edge = node1;
		else
			link_last(pG->vexs[p1].first_edge, node1);
		// 初始化node2
		node2 = (ENode*)calloc(1, sizeof(ENode));
		node2->ivex = p1;
		// 将node2链接到"p2所在链表的末尾"
		if (pG->vexs[p2].first_edge == NULL)
			pG->vexs[p2].first_edge = node2;
		else
			link_last(pG->vexs[p2].first_edge, node2);
	}

DFS

深度优先搜索的步骤分为
1.递归下去
顾名思义，深度优先，则是以深度为准则，先一条路走到底，直到达到目标。这里称之为递归下去。

2.回溯上来。
否则既没有达到目标又无路可走了，那么则退回到上一步的状态，走其他路。这便是回溯上来。

对于下面的图，DFS的思路如下：

1.递归下去
从A出发，到 C；
发现C还与B连接，还可以走，到B；

2.回溯上来。
到B后没有与其他节点连接，无法继续向下走；便向上回溯到C；
仍然没有与其他节点连接，再回溯到A；

1.递归下去
从A出发，到D；

2.回溯上来。
再回溯到A

1.递归下去
从A出发向下遍历F G E
在这里插入图片描述
借助辅助数组visited，初始visited全为0，代表对应下标的节点未被访问。
然后遍历邻接表中的每个节点；如果该节点没有访问就进入DFS函数，进一步向下遍历

void DFSTraverse(LGraph G)
{
	int i;
	int visited[MAX];       // 顶点访问标记

	// 初始化所有顶点都没有被访问
	for (i = 0; i < G.vexnum; i++)
		visited[i] = 0;

	printf("DFS: ");
	//从A开始深度优先遍历
	for (i = 0; i < G.vexnum; i++)
	{
		if (!visited[i])
			DFS(G, i, visited);
	}
	printf("\n");
}

首先将当前节点p1打印，并标记为已经访问
然后获取当前节点p1连接的下一个顶点p2，如果对应顶点p2没有访问就递归执行DFS
递归出来后就循环对p1连接的其余顶点p3 p4 进行递归

static void DFS(LGraph G, int i, int* visited)
{
	ENode* node;
	visited[i] = 1;//要访问当前结点了，所以打印
	printf("%c ", G.vexs[i].data);
	node = G.vexs[i].first_edge;//拿当前顶点的后面一个顶点
	while (node != NULL)
	{
		if (!visited[node->ivex])//只要对应顶点没有访问过，深入到下一个顶点访问
			DFS(G, node->ivex, visited);
		node = node->next_edge;//某个顶点的下一条边，例如B结点的下一条边
	}
}

BFS

每一次搜索，都会将与该节相连的所有节点全部找完。

从A出发，依次遍历与A连接的C D F
然后从C出发遍历与C相连的B
然后从F出发遍历与F相连的G
然后从G出发遍历与G相连的E
在这里插入图片描述
需要借助队列queue和访问数组visited执行，初始化visited中元素为0；
依次遍历邻接表中每个节点；
如果该节点p1没有访问过，就将其入队，并打印标记；
然后将p1出队，遍历p1所有连接的节点p2 p3 …；
如果没有访问过就将顶点入队，并打印标记；
访问完所有与p1相连的顶点后，循环对队中顶点出队，遍历相连顶点操作；
直到队空，就继续遍历邻接表中余下节点。

void BFS(LGraph G)
{
	int head = 0;
	int rear = 0;
	int queue[MAX];     // 辅组队列
	int visited[MAX];   // 顶点访问标记
	int i, j, k;
	ENode* node;

	//每个顶点未被访问
	for (i = 0; i < G.vexnum; i++)
		visited[i] = 0;
	//从零号顶点开始遍历
	printf("BFS: ");
	for (i = 0; i < G.vexnum; i++)//对每个连同分量均调用一次BFS
	{
		if (!visited[i])//如果没访问过，就打印，同时入队,最初是A
		{
			visited[i] = 1;//标记已经访问过
			printf("%c ", G.vexs[i].data);
			queue[rear++] = i;  // 入队列
		}
		while (head != rear) //第一个进来的是A，遍历A的每一条边
		{
			j = queue[head++];  // 出队列
			node = G.vexs[j].first_edge;
			while (node != NULL)
			{
				k = node->ivex;
				if (!visited[k])
				{
					visited[k] = 1;
					printf("%c ", G.vexs[k].data);
					queue[rear++] = k;//类似于树的层次遍历，遍历到的同时入队
				}
				node = node->next_edge;
			}
		}
	}
	printf("\n");
}

新开通了本人的公众号，欢迎关注：燕南路GISer ，专注GIS干货分享，不定期更新。
主要兴趣：GIS、时空数据挖掘、python、机器学习深度学习
提问、求资源等都可在公众号后台留言
CSDN的部分内容会重写再搬迁到公众号，欢迎关注！
在这里插入图片描述

完整代码

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

#define MAX 100
#define isLetter(a)  ((((a)>='a')&&((a)<='z')) || (((a)>='A')&&((a)<='Z')))
#define LENGTH(a)  (sizeof(a)/sizeof(a[0]))

//邻接表链表顶点
typedef struct _ENode
{
	int ivex;
	struct _ENode* next_edge;
}ENode;

//邻接表表顶点
typedef struct _VNode
{
	char data;
	ENode* first_edge;
}VNode;

//邻接表
typedef struct _LGraph
{
	int vexnum;
	int edgnum;
	VNode vexs[MAX];
}LGraph;

//返回ch在矩阵中的位置
static int get_position(LGraph g, char ch)
{
	int i;
	//遍历顶点
	for (i = 0; i < g.vexnum; ++i)
		if (g.vexs[i].data == ch)
			return i;
	return -1;
}

//node链接到list末尾
static void link_last(ENode* list, ENode* node)
{
	ENode* p = list;
	while (p->next_edge)
	{
		p = p->next_edge;
	}
	p->next_edge = node;
}
/*
 * 创建邻接表对应的图(有向图)
 */
LGraph* create_example_lgraph_directed()
{
	char c1, c2;
	char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
	char edges[][2] = {
		{'A', 'B'},
		{'B', 'C'},
		{'B', 'E'},
		{'B', 'F'},
		{'C', 'E'},
		{'D', 'C'},
		{'E', 'B'},
		{'E', 'D'},
		{'F', 'G'} };
	int vlen = LENGTH(vexs);
	int elen = LENGTH(edges);
	int i, p1, p2;
	ENode* node1;
	LGraph* pG;


	if ((pG = (LGraph*)malloc(sizeof(LGraph))) == NULL)
		return NULL;
	memset(pG, 0, sizeof(LGraph));

	// 初始化"顶点数"和"边数"
	pG->vexnum = vlen;
	pG->edgnum = elen;
	// 初始化"邻接表"的顶点
	for (i = 0; i < pG->vexnum; i++)
	{
		pG->vexs[i].data = vexs[i];
		pG->vexs[i].first_edge = NULL;
	}

	// 初始化"邻接表"的边
	for (i = 0; i < pG->edgnum; i++)
	{
		// 读取边的起始顶点和结束顶点
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = get_position(*pG, c1);
		p2 = get_position(*pG, c2);
		// 初始化node1
		node1 = (ENode*)calloc(1, sizeof(ENode));
		node1->ivex = p2;
		// 将node1链接到"p1所在链表的末尾"
		if (pG->vexs[p1].first_edge == NULL)
			pG->vexs[p1].first_edge = node1;
		else
			link_last(pG->vexs[p1].first_edge, node1);
	}

	return pG;
}

//创建邻接表对应的图(用已提供的数据)，无向图
LGraph* create_example_lgraph()
{
	char c1, c2;
	char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
	char edges[][2] = {
		{'A', 'C'},
		{'A', 'D'},
		{'A', 'F'},
		{'B', 'C'},
		{'C', 'D'},
		{'E', 'G'},
		{'F', 'G'} };
	//记录节点和边的数量
	int vlen = LENGTH(vexs);
	int elen = LENGTH(edges);
	//上面类似一个邻接矩阵存储
	int i, p1, p2;
	ENode* node1, * node2;
	LGraph* pG;//pG表示图
	//初始化矩阵
	if ((pG = (LGraph*)malloc(sizeof(LGraph))) == NULL)
		return NULL;
	memset(pG, 0, sizeof(LGraph));//就是把申请的空间内初始化为零

	// 初始化"顶点数"和"边数"
	pG->vexnum = vlen;
	pG->edgnum = elen;
	// 初始化"邻接表"的顶点，边都置空
	for (i = 0; i < pG->vexnum; i++)
	{
		pG->vexs[i].data = vexs[i];
		pG->vexs[i].first_edge = NULL;
	}
	//像节点内写入边
	for (i = 0; i < pG->edgnum; i++)
	{
		// 读取边的起始顶点和结束顶点
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = get_position(*pG, c1);//p1对应起始顶点下标位置
		p2 = get_position(*pG, c2);//p1对应结束顶点下标位置
		// 初始化node1
		node1 = (ENode*)calloc(1, sizeof(ENode));
		node1->ivex = p2;
		if (pG->vexs[p1].first_edge == NULL)
			pG->vexs[p1].first_edge = node1;
		else
			link_last(pG->vexs[p1].first_edge, node1);
		// 初始化node2
		node2 = (ENode*)calloc(1, sizeof(ENode));
		node2->ivex = p1;
		// 将node2链接到"p2所在链表的末尾"
		if (pG->vexs[p2].first_edge == NULL)
			pG->vexs[p2].first_edge = node2;
		else
			link_last(pG->vexs[p2].first_edge, node2);
	}
	return pG;
}

void print_lgraph(LGraph G)
{
	int i;
	ENode* node;

	printf("List Graph:\n");
	for (i = 0; i < G.vexnum; i++)//遍历所有的顶点
	{
		printf("%d(%c): ", i, G.vexs[i].data);
		node = G.vexs[i].first_edge;
		while (node != NULL)//把每个顶点周围的结点都输出一下
		{
			printf("%d(%c) ", node->ivex, G.vexs[node->ivex].data);
			node = node->next_edge;
		}
		printf("\n");
	}
}

/*
 * 深度优先搜索遍历图的递归实现
 */
static void DFS(LGraph G, int i, int* visited)
{
	ENode* node;

	visited[i] = 1;//要访问当前结点了，所以打印
	printf("%c ", G.vexs[i].data);
	node = G.vexs[i].first_edge;//拿当前顶点的后面一个顶点
	while (node != NULL)
	{
		if (!visited[node->ivex])//只要对应顶点没有访问过，深入到下一个顶点访问
			DFS(G, node->ivex, visited);
		node = node->next_edge;//某个顶点的下一条边，例如B结点的下一条边
	}
}

/*
 * 深度优先搜索遍历图
 */
void DFSTraverse(LGraph G)
{
	int i;
	int visited[MAX];       // 顶点访问标记

	// 初始化所有顶点都没有被访问
	for (i = 0; i < G.vexnum; i++)
		visited[i] = 0;

	printf("DFS: ");
	//从A开始深度优先遍历
	for (i = 0; i < G.vexnum; i++)
	{
		if (!visited[i])
			DFS(G, i, visited);
	}
	printf("\n");
}

/*
 * 广度优先搜索（类似于树的层次遍历）
 */
void BFS(LGraph G)
{
	int head = 0;
	int rear = 0;
	int queue[MAX];     // 辅组队列
	int visited[MAX];   // 顶点访问标记
	int i, j, k;
	ENode* node;

	//每个顶点未被访问
	for (i = 0; i < G.vexnum; i++)
		visited[i] = 0;
	//从零号顶点开始遍历
	printf("BFS: ");
	for (i = 0; i < G.vexnum; i++)//对每个连同分量均调用一次BFS
	{
		if (!visited[i])//如果没访问过，就打印，同时入队,最初是A
		{
			visited[i] = 1;//标记已经访问过
			printf("%c ", G.vexs[i].data);
			queue[rear++] = i;  // 入队列
		}
		while (head != rear) //第一个进来的是A，遍历A的每一条边
		{
			j = queue[head++];  // 出队列
			node = G.vexs[j].first_edge;
			while (node != NULL)
			{
				k = node->ivex;
				if (!visited[k])
				{
					visited[k] = 1;
					printf("%c ", G.vexs[k].data);
					queue[rear++] = k;//类似于树的层次遍历，遍历到的同时入队
				}
				node = node->next_edge;
			}
		}
	}
	printf("\n");
}
int main()
{
	LGraph* pG;
	pG = create_example_lgraph();
	print_lgraph(*pG);
	DFSTraverse(*pG);//深度优先遍历
    BFS(*pG);//广度优先遍历
	return 0;
}

新开通了本人的公众号，欢迎关注：燕南路GISer ，专注GIS干货分享，不定期更新。
主要兴趣：GIS、时空数据挖掘、python、机器学习深度学习
CSDN的部分内容会重写再搬迁到公众号，欢迎关注！
在这里插入图片描述

燕南路GISer
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
图的BFS与DFS算法在邻接矩阵与邻接表存储结构下实现
weixin_46127065的博客
10-19 3040
如题 自用笔记 如有错误欢迎及时指正
图的邻接表存储及DFS，BFS遍历
zhangjc9401的专栏
02-03 729
每天进步一小步~
图的基础 邻接表 dfs bfs前置知识
weixin_46879396的博客
09-24 265
本文包括图的基础 性质 类别 加几种建图方式
图——邻接表的DFS，BFS
卖核弹的小男孩 的博客
05-06 4369
邻接表做存储结构时，找邻接点所需的时间取决于顶点和边的数量，DFS，BFS时间复杂度为O(n+e)。 1、邻接表 2、邻接表 DFS： 从起点出发，走过的点要做标记，发现有没走过的点，就随意挑一个往前走，走不了就回退，此种路径搜索策略就称为“深度优先搜索”，简称“深搜”。其实称为“远度优先搜索”更容易理解些。因为这种策略能往前走一步就往前走一 步，总是试图走得更远。所谓远近(或深度），就是以...
邻接表BFS(深度优先算法)数据结构c语言
最新发布
2302_80479160的博客
06-01 133
实际上这里打印的是各连通分量的排序组合。
数据结构之图的邻接表实现（包含BFS、DFS的实现）
codegun7
06-02 1668
后附代码 基础知识 有向图中 孤立点：V中不与E中任一条边关联的点称为D的孤立点． 简单图：不含平行边的图称为简单图． 完备图：图中任两个顶点U与u之间，恰有两条有向边(u，v)，及(v，u)，则称该有向图D为完备图． 基本图：把有向图D的每条边除去定向就得到一个相应的无向图G，称G为D的基本图．称D为G的定向图。 强连通图：给定有向图G=(VE)，并且给定该图G中的任意两个结点u和v，如果结点u...
用邻接表来表达DFS(深度优先搜索)
super604zong的博客
12-14 2906
一.邻接表:1.简介 邻接表是图的链式存储结构，他克服了邻接矩阵的缺点，只存储定点之间有关联的信息，邻接表由边表 和定点表组成， 所以它存储的是稀疏图，也就是边数e < nlnn(n为顶点数)，这样相比于邻接矩阵极大 的节省了空间，顶点表用于存放图中 每个顶点的信息以及指向该定点边表的头指针，顶点表采用的 是顺序存储结构。边表就是对于针对顶点表中的每一个定点建立链表，来存储与
有向图的DFS和BFS（邻接矩阵实现）
tracker_097的博客
12-02 6883
第一篇博客（误删重发）
图的创建和遍历（邻接表、邻接矩阵存储实现BFS、DFS）
caka07的博客
06-13 1653
图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。在学习图的过程中，知道图中存储的数据称为顶点，无向图连接顶点之间关系的称为边，有向图连接顶点的称为弧，弧的起点为弧尾，终点为弧头。图可以根据边有无方向，分为无向图和有向图，只要存在有方向的边，则为有向图，全部为无方向边的图，则为无向图。
基于邻接表的dfs和bfs
DBEBCXRQ的博客
09-18 225
访问标记数组，dfs和bfs都需要。（1）辅助队列，这边用的是循环队列。一、深度优先搜索dfs。二、广度优先搜索bfs。
数据结构：邻接表
Jackourer的博客
06-01 3063
摘要：邻接表是图的一种链式存储结构。在邻接表中，对图中每个顶点Vi建立一个单链表，把与Vi相邻接的顶点放在这个链表中。邻接表中每个单链表的第一个节点都存放着有关顶点的信息，把这一节点看成链表的表头，其余节点存放有关边的信息，邻接表包括表头结点表和边表。1)抄代码我们今天写的邻接表是有二维数组图结构转化而来的。所以可以将之前的代码现抄过来。 2）邻接表的结构体定义 3）将图转化为邻接表 4）打印邻接表 5）广度遍历 6）测试函数 二、完整代码及运行结果 1）完整代码 2）运行结果
图的遍历——用邻接表实现DFS
So_cute_SJM的博客
02-04 1194
文章目录一. 遍历思想二. DFS（深度优先遍历）设计思想三. 具体分析四. 实现深度优先遍历的递归算法 一. 遍历思想 给定一个图G=(V,E)和其中任意一个顶点v，从顶点v出发，访问图G中的所有顶点而且每个顶点仅被访问一次，这一过程称为图的遍历。 为了避免同一顶点被访问多次，在遍历图的过程中，必须记下每个已被访问过的顶点。 为此设一个辅助数组visited[]，用以标记顶点是否被访问过，其...
图的遍历，图的深度优先搜索(DFS)、广度优先搜索(BFS)详解及C++代码详细实现(邻接矩阵版，邻接表版)
weixin_45651616的博客
07-25 1934
图的遍历，使用深度优先搜索(DFS)、广度优先搜索(BFS)遍历图的过程详解及C++代码详细实现(邻接矩阵版、邻接表版)
日撸 Java 三百行（36 天: 邻接表的代码实现)
ALBlack的博客
04-17 2417
这里是JAVA自学与了解的同步笔记与记录，如有问题欢迎指正说明
邻接表/图/DFS/BFS
m0_61548909的博客
06-06 840
目录存储形式 采用邻接表法创建无向网邻接表的特点 邻接矩阵与邻接表表示法的关系完整代码 顶点的结构 弧（边）的结点结构 图的结构定义 邻接表操作举例说明 邻接表的特点
BFS(邻接矩阵+队列)和DFS(邻接表+栈)C++实现
leoabcd12的博客
07-19 1556
5.2 图的遍历 5.2.1 广度优先搜索 概念 广度优先搜索（也称宽度优先搜索，缩写BFS）是连通图的一种遍历算法这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中止。一般
数据结构图 算法6.1-6.2创建无向网 算法6.4-6.6DFS
weixin_62075168的博客
12-06 2236
本关任务：编写一个能输出无向图邻接矩阵的小程序。为了完成本关任务，你需要掌握：1.创建邻接矩阵根据提示，在右侧编辑器补充代码，输出邻接矩阵。第一行是顶点数目n和边数目e，中间以空格分开 第二行是n个字符型的顶点数目名称，中间以空格分开 接下来e行分别是对应的边 比如说 A B 400 表示顶点A和B之间有边，权值为400平台会对你编写的代码进行测试：测试输入：预期输出：
图的邻接表存储及图的遍历（DFS）
xiaowu_wu的博客
04-14 1216
图的邻接表存储及图的遍历（DFS）
图的dfs遍历模板（邻接表和邻接矩阵存储）
Lucky小黄人的博客
09-07 202
我们做算法题的目的是解决问题，完成任务，而不是创造算法，解题的过程是利用算法的过程而不是创造算法的过程，我们不能不能陷入这样的认识误区。而想要快速高效的利用算法解决算法题，积累算法模板就很重要，利用模板可以使我们编码更高效，思路更清晰，不容易出bug.下面是利用DFS算法思想遍历图的模板。 邻接矩阵版： //邻接矩阵版 int n, G[MAXV][MAXV]; ...
图的应用算法详解：存储结构与遍历方法
本文主要介绍了考研数据结构中关于图的相关应用算法，包括图的存储结构（邻接矩阵和邻接表）、图的遍历方法（DFS和BFS）、拓扑排序、最小代价生成树（Prim和Kruskal算法）以及最短路径（Dijkstra和Floyd算法）。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

燕南路GISer

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

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

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

打赏作者

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

抵扣说明：

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

余额充值