图的存储结构之打印邻接表

置顶 已于 2024-05-07 17:59:47 修改
阅读量734 收藏 2
点赞数 1
分类专栏： pta 文章标签： 数据结构 c++
于 2021-05-28 12:30:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53054984/article/details/117357471
版权

🌟欢迎来到 我的博客 —— 探索技术的无限可能！


🌟博客的简介（文章目录）

邻接表 [路径判断][最短路径]

文章目录

一、邻接表是什么？

图的邻接表存储方法跟树的孩子链表示法相类似，是一种顺序分配和链式分配相结合的存储结构。如这个表头结点所对应的顶点存在相邻顶点，则把相邻顶点依次存放于表头结点所指向的单向链表中。
对于无向图来说，使用邻接表进行存储也会出现数据冗余，表头结点A所指链表中存在一个指向C的表结点的同时，表头结点C所指链表也会存在一个指向A的表结点。

邻接表是图的一种最主要存储结构,用来描述图上的每一个点。对图的每个顶点建立一个容器（n个顶点建立n个容器），第i个容器中的结点包含顶点Vi的所有邻接顶点。实际上我们常用的邻接矩阵就是一种未离散化每个点的边集的邻接表。
在有向图中，描述每个点向别的节点连的边（点a->点b这种情况）。
在无向图中，描述每个点所有的边(点a-点b这种情况)

二、构建图的邻接表

1.构建 图的邻接表 函数

//构建图的邻接表
PtrToGNode BuildGraph()
{
    PtrToGNode Graph;//指向邻接表的指针
    int v,w;
    int Nv;//顶点个数

    cin>>Nv;
    Graph = CreateGraph(Nv);

    cin>>Graph->Ne;
    if(Graph->Ne != 0){
        for(int i=0;i<Graph->Ne;i++)
        {
            cin>>v>>w;
            InsertEdge(Graph,v,w);
        }
    }
    return Graph;//指针 返回建好的邻接表
}

2.主函数（全代码）

	   打印邻接表，各个顶点的邻居有谁
格式：顶点编号->邻居1的编号->邻居2的编号

输入格式

输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。
随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

输出格式

顶点 边数
N,E
格式：顶点编号->邻居1的编号->邻居2的编号

输入样例

7 6
0 1
2 3
1 4
0 2
1 3
5 6

输出样例

顶点 边数
   7    6
0->2->1
1->3->4->0
2->0->3
3->1->2
4->1
5->6
6->5

代码如下：

#include <bits/stdc++.h>
using namespace std;

typedef struct AdjVNode *PtrToAdjVNode;
//邻居//邻接点
struct AdjVNode{
    int AdjV;  //邻居顶点编号
    PtrToAdjVNode Next;  //下一个邻居
};

typedef struct VNode {        //指针里面的元素
    PtrToAdjVNode FirstEdge;  //指向邻居链表的指针
}AdjList[100];

typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;//顶点
    int Ne;//边的数量
    AdjList G;//邻接表//等同于struct VNode G[100];
};
//生成顶点数组
PtrToGNode CreateGraph(int Nv)
{
    PtrToGNode Graph;
    Graph =new GNode();
    Graph->Nv = Nv;
    Graph->Ne = 0;
    for(int v=0;v<Nv;v++)
    {
        Graph->G[v].FirstEdge = NULL;
    }
    return Graph;
}
//在无向图内加入一条边 (v, w)
void InsertEdge(PtrToGNode Graph, int v, int w)
{
    PtrToAdjVNode newNode;
    newNode = new AdjVNode();
    newNode->AdjV = w;//记住v的邻居是w    w是v的邻居           AdjV是记录值 Next是记录指针
    //把newNode插入到顶点v的邻居（链表）内
    newNode->Next = Graph->G[v].FirstEdge;
    Graph->G[v].FirstEdge = newNode;

    newNode = new AdjVNode();
    newNode->AdjV = v;//记住w的邻居是v    v是w的邻居
    //把newNode插入到顶点w的邻居（链表）内
    newNode->Next = Graph->G[w].FirstEdge;
    Graph->G[w].FirstEdge = newNode;
}
//构建图的邻接表
PtrToGNode BuildGraph()
{
    PtrToGNode Graph;//指向邻接表的指针
    int v,w;
    int Nv;//顶点个数

    cin>>Nv;
    Graph = CreateGraph(Nv);

    cin>>Graph->Ne;
    if(Graph->Ne != 0){
        for(int i=0;i<Graph->Ne;i++)
        {
            cin>>v>>w;
            InsertEdge(Graph,v,w);
        }
    }
    return Graph;//指针 返回建好的邻接表
}

bool visited[100]={false};//visited数组记住哪些顶点已经被记住
void DFS(PtrToGNode graph,int start)
{
    visited[start]= true;
    for(PtrToAdjVNode w=graph->G[start].FirstEdge;w!=NULL;w=w->Next)
    {
        if(!visited[w->AdjV])
            DFS(graph,w->AdjV);
    }
}
int main()
{
    PtrToGNode graph = BuildGraph();

    cout<<"顶点 边数"<<endl;
//    cout<<graph->Nv<<","<<graph->Ne;
	printf("%4d %4d",graph->Nv,graph->Ne) ;

    //      打印邻接表，各个顶点的邻居有谁
    //格式：顶点编号->邻居1的编号->邻居2的编号
    cout<<endl;
    for(int i=0;i<graph->Nv;i++)
    {
        cout<<i;
        PtrToAdjVNode  ptr = graph->G[i].FirstEdge;
        while(ptr != NULL)
        {
            cout<<"->"<<ptr->AdjV;
            ptr = ptr->Next;
        }
        cout<<endl;
    }
}

三、可运用邻接表的题目

ag1：路径判断 (20 分)

给定一个有N个顶点和E条边的无向图，请判断给定的两个顶点之间是否有路径存在。 假设顶点从0到N−1编号。

输入格式:

输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。
随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。
最后一行给出两个顶点编号i，j（0≤i,j<N）,i和j之间用空格分隔。

输出格式:

如果i和j之间存在路径，则输出"There is a path between i and j.“，
否则输出"There is no path between i and j.”。

输入样例1

7 6
0 1
2 3
1 4
0 2
1 3
5 6
0 3

输出样例1

There is a path between 0 and 3.

输入样例2

7 6
0 1
2 3
1 4
0 2
1 3
5 6
0 6

输出样例2

There is no path between 0 and 6.

代码：（用DFS）

#include <bits/stdc++.h>
using namespace std;

typedef struct AdjVNode *PtrToAdjVNode;
//邻居//邻接点
struct AdjVNode{
    int AdjV;  //邻居顶点编号
    PtrToAdjVNode Next;  //下一个邻居
};

typedef struct VNode {        //指针里面的元素
    PtrToAdjVNode FirstEdge;  //指向邻居链表的指针
}AdjList[100];

typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;//顶点
    int Ne;//边的数量
    AdjList G;//邻接表//等同于struct VNode G[100];
};
//生成顶点数组
PtrToGNode CreateGraph(int Nv)
{
    PtrToGNode Graph;
    Graph =new GNode();
    Graph->Nv = Nv;
    Graph->Ne = 0;
    for(int v=0;v<Nv;v++)
    {
        Graph->G[v].FirstEdge = NULL;
    }
    return Graph;
}
//在无向图内加入一条边 (v, w)
void InsertEdge(PtrToGNode Graph, int v, int w)
{
    PtrToAdjVNode newNode;
    newNode = new AdjVNode();
    newNode->AdjV = w;//记住v的邻居是w    w是v的邻居           AdjV是记录值 Next是记录指针
    //把newNode插入到顶点v的邻居（链表）内
    newNode->Next = Graph->G[v].FirstEdge;
    Graph->G[v].FirstEdge = newNode;

    newNode = new AdjVNode();
    newNode->AdjV = v;//记住w的邻居是v    v是w的邻居
    //把newNode插入到顶点w的邻居（链表）内
    newNode->Next = Graph->G[w].FirstEdge;
    Graph->G[w].FirstEdge = newNode;
}
//构建图的邻接表
PtrToGNode BuildGraph()
{
    PtrToGNode Graph;//指向邻接表的指针
    int v,w;
    int Nv;//顶点个数

    cin>>Nv;
    Graph = CreateGraph(Nv);

    cin>>Graph->Ne;
    if(Graph->Ne != 0){
        for(int i=0;i<Graph->Ne;i++)
        {
            cin>>v>>w;
            InsertEdge(Graph,v,w);
        }
    }
    return Graph;//指针 返回建好的邻接表
}

bool visited[100]={false};//visited数组记住哪些顶点已经被记住
void DFS(PtrToGNode graph,int start)
{
    visited[start]= true;
    for(PtrToAdjVNode w=graph->G[start].FirstEdge;w!=NULL;w=w->Next)
    {
        if(!visited[w->AdjV])
            DFS(graph,w->AdjV);
    }
}
int main()
{
    PtrToGNode graph = BuildGraph();

//    cout<<"顶点 边数"<<endl;
    cout<<graph->Nv<<","<<graph->Ne;
//	printf("%4d %4d",graph->Nv,graph->Ne) ;

    //      打印邻接表，各个顶点的邻居有谁
    //格式：顶点编号->邻居1的编号->邻居2的编号
//    cout<<endl;
//    for(int i=0;i<graph->Nv;i++)
//    {
//        cout<<i;
//        PtrToAdjVNode  ptr = graph->G[i].FirstEdge;
//        while(ptr != NULL)
//        {
//            cout<<"->"<<ptr->AdjV;
//            ptr = ptr->Next;
//        }
//        cout<<endl;
//    }
    int start, end;
    cin>>start>>end;
    DFS(graph, start);
    if(visited[end])
        cout<<"There is a path between "<<start<<" and "<<end<<".\n";
    else
        cout<<"There is no path between "<<start<<" and "<<end<<".\n";

}

其他方法解题

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

#define MaxVertexNum 10  /* 最大顶点数设为10 */

typedef struct GNode *PtrToGNode;
struct GNode{
   int Nv;  /* 顶点数 */
   int Ne;  /* 边数   */
   int g[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
};
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */

int isvisited[20];

void DFS( MGraph Graph, int V)
{
	isvisited[V] = 1;
	for(int j=0;j<Graph->Nv;j++)
	{
		int w = Graph->g[V][j];
		if(w != 0 && !isvisited[j])
		{
			DFS(Graph,j);
		}
	}
}

int main()
{
	PtrToGNode G = (PtrToGNode)malloc(sizeof(struct GNode));
	scanf("%d %d",&G->Nv,&G->Ne);
	int x,y;
	for(int i=0;i<G->Nv;i++)
	{
		isvisited[i] = 0;
		for(int j=0;j<G->Nv;j++)
		{
			G->g[i][j] = 0;
		}
	}
	for(int i=0;i<G->Ne;i++)
	{
		scanf("%d %d",&x,&y);
		G->g[x][y] = 1;
		G->g[y][x] = 1;
	}
	scanf("%d %d",&x,&y);
	DFS(G,x);
	if(isvisited[y] == 1)
	{
		printf("There is a path between %d and %d.",x,y);
	}
	else
	{
		printf("There is no path between %d and %d.",x,y);
	}
	return 0;
}

ag2：最短路径 (20 分)

给定一个有N个顶点和E条边的无向图，顶点从0到N−1编号。请判断给定的两个顶点之间是否有路径存在。如果存在，给出最短路径长度。 这里定义顶点到自身的最短路径长度为0。 进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:

输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。
随后E行，每行给出一条边的两个顶点。每行中的数字之间用1空格分隔。
最后一行给出两个顶点编号i，j（0≤i,j<N）,i和j之间用空格分隔。

输出格式:

如果i和j之间存在路径，则输出"The length of the shortest path between i and j is X."
X为最短路径长度， 否则输出"There is no path between i and j."。

输入样例1:

7 6
0 1
2 3
1 4
0 2
1 3
5 6
0 3

输出样例1:

The length of the shortest path between 0 and 3 is 2.

输入样例2:

7 6
0 1
2 3
1 4
0 2
1 3
5 6
0 6

输出样例2:

There is no path between 0 and 6.

代码：（用BFS）

#include <bits/stdc++.h>
using namespace std;

typedef struct AdjVNode * PtrToAdjVNode;
//邻接点 
struct AdjVNode{
	int AdjV;  //邻居顶点编号 
	PtrToAdjVNode Next;  //下一个邻居 
};

typedef struct VNode {
	PtrToAdjVNode FirstEdge;  //指向邻居链表的指针 
} AdjList[100]; //AdjList是struct VNode[]，是数组类型 

typedef struct GNode * PtrToGNode;
struct GNode {
	int Nv;
	int Ne;    //边数 
	//AdjList G; //等同于struct VNode G[100] 
	struct VNode G[100];  
};
//生成0条边的邻接表 
PtrToGNode CreateGraph(int Nv)
{
	PtrToGNode Graph;
	Graph =new GNode();
	Graph->Nv = Nv;
	Graph->Ne = 0;
	for(int v=0; v<Nv; v++)
	{
		Graph->G[v].FirstEdge = NULL;
	}
	return Graph;
}
//在无向图内加入一条边 (v, w)
void InsertEdge(PtrToGNode Graph, int v, int w)
{
	PtrToAdjVNode newNode;
	newNode = new AdjVNode();  //邻接点 
	newNode->AdjV = w;   //记住w是v的邻居 
	//把newNode插入到顶点v的邻居（链表）内 
	newNode->Next = Graph->G[v].FirstEdge;   
	Graph->G[v].FirstEdge = newNode;
	
	newNode = new AdjVNode();
	newNode->AdjV = v;   //记住v是w的邻居 
	//把newNode插入到顶点w的邻居（链表）内 
	newNode->Next = Graph->G[w].FirstEdge;   
	Graph->G[w].FirstEdge = newNode;	
	
}
//构建图的邻接表 
PtrToGNode BuildGraph()
{
	PtrToGNode Graph;  //指向邻接表的指针
	int v, w;
	int Nv;
	
	cin>>Nv;
	Graph = CreateGraph(Nv);  
	
	cin>>Graph->Ne; 
	if(Graph->Ne != 0)  {
		for(int i=0; i<Graph->Ne; i++)
		{
			cin>>v>>w;
			InsertEdge(Graph, v, w);
		}
	}
	
	return Graph;
	
}
int distances[100] = {0};
void BFS(PtrToGNode graph, int start)
{
	queue<int> vnodes;
	vnodes.push(start);
	distances[start] = 0;
	while(!vnodes.empty())
	{
		int v = vnodes.front();
		vnodes.pop();
		for(PtrToAdjVNode w=graph->G[v].FirstEdge; w!=NULL; w=w->Next)
		{
			if(distances[w->AdjV] < 0)
			{
				distances[w->AdjV] = distances[v] + 1;
				vnodes.push(w->AdjV);
			}
		}
	}
	return;
}


int main()
{
	PtrToGNode graph = BuildGraph();

	int start, end;
	cin>>start>>end;
	for(int i=0; i<100; i++)
	{
		distances[i] = -1;
	} 
	BFS(graph, start);
	if (start == end)
		cout<<"The length of the shortest path between "<<start<<" and "<<end<<" is 0.\n";		
	else if(distances[end] > 0)
		cout<<"The length of the shortest path between "<<start<<" and "<<end<<" is "<<distances[end]<<".\n";
	else
		cout<<"There is no path between "<<start<<" and "<<end<<".\n";
}
ZShiJ
关注
专栏目录
数据结构（廿三） -- C语言版 -- 图 - 图的存储结构 -- 邻接表、逆邻接表
青椒*^_^*凤爪爪的博客
08-15 1万+
在图中任何两个顶点之间都可能存在联系，所以图的存储结构应该需要根据具体问题的要求来进行设计。从图的逻辑结构定义来看，图中任何一个顶点都可以看成是第一个顶点。常用的存储结构有邻接矩阵、邻接表（逆邻接表）、十字链表、邻接多重表、 边集数组。那么本博文将带你就 “邻接表（逆邻接表）” 来窥探一二。。。
两顶点之前有路径吗？ (20 分)
dsrics的博客
11-18 2010
这道题有一个坑点在于自身是有路径的 int hasPath(struct Graph *g, int v, int w){ for(int i=0;i<g->v;i++)g->Adj[i][i]=1; for (int i = 0; i < g->v; i++) { for (int j =0; j &lt...
PAT 路径判断（并查集解法）
Aaron_Yang
08-05 894
题目： 给定一个有N个顶点和E条边的无向图，请判断给定的两个顶点之间是否有路径存在。 假设顶点从0到N−1编号。 输入格式: 输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。 随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。 最后一行给出两个顶点编号i，j（0≤i,j<N）,i和j之间用空格分隔。 输出格式: 如果i和j之间存在路径，则输出"There is a path between i and j."， 否则输出"There is no path b
判定图的两点是否有路
weixin_30791095的博客
12-03 536
问题描述 给定一个有向图G，以及两个顶点s和t，判定s和t是否存在一条有向路径(s->t) 输入描述 输入文件，包含多组数据，每个测试数据的第一行为两个整数n和m，分别表示图G的顶点数和变数， 接下来有m行，每行为两个整数u，v，描述一条有向边<u,v>， 最后有一行为两个整数，s，t，其中s≠t，且n<=50，且此图为简单图，其基图为连同的。 输入文件的最后一...
PTA 7-4 两点间有路径吗？ (20 分) dfs+并查集和并查集两种方式实现
weixin_46623714的博客
10-12 1140
题目描述： 对于给定的无向图以及图中的两个顶点，计算两个顶点所在的连通分量中的顶点数，并且判断这两个顶点之间是否有路径。 输入格式: 第一行是不超过20的正整数N，表示图有N个顶点，顶点的编号即0~N-1； 接下来N行，是N*N的邻接矩阵，矩阵的元素间用空格分隔； 最后一行是用空格隔开的两个顶点编号v和w 输出格式: 第一行输出v所在的连通分量的顶点数 第二行输出w所在的连通分量的顶点数 第三行，若v和w之间有路径，则输出Yes，否则输出No 注意：当v和w是同一个顶点时，认为v和w之间
数据结构算法—邻接表存储有向图求两点间是否存在路径
m0_53793974的博客
12-16 6566
数据结构算法—邻接表存储有向图求两点间是否存在路径 题目：试基于图的深度优先搜索策略编写一程序，判别以邻接表方式存储的有向图中是否存在有顶点Vi到Vj顶点的路径(i≠j)。 邻接表存储结构 typedef struct ArcNode{ int adjvex;//边指向的顶点 struct ArcNode *nextarc; // 下一条边的指针 }ArcNode; typedef struct VNode{ int data;//顶点信息 ArcNode *fristarc;//该结点的第一条
头歌数据结构图的邻接表存储及遍历操作
05-26
邻接表是一种用于表示图的存储结构，适用于稀疏图（即边的数量远小于顶点数量的平方）。它通过一系列链表来表示图中的各个顶点及其相邻的顶点，对于每个顶点，都有一个链表用来存储与之相连的所有顶点。 ### 二、头...
数据结构学习--图的邻接矩阵和邻接表存储
06-25
图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素表示图中顶点之间的边。对于无向图，邻接矩阵是对称的，即如果顶点i和顶点j之间有一...
数据结构-c语言-带main函数-图7.2-图的存储结构-图的邻接表的创建-无向图。
06-24
在 `main` 函数中，我们创建一个图 `G`，然后调用 `CreateUDG` 函数创建图的邻接表，最后调用 `PrintCreateUDG` 函数打印邻接表。 结语 在本节中，我们讨论了图的存储结构，并使用 C 语言实现了图的邻接表的创建。...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
- **邻接表**：是一种存储图的有效方式，特别是对于稀疏图（边的数量远小于顶点数量的平方）。它为每个顶点维护一个链表，链表中的元素表示与该顶点相连的所有其他顶点。 - **邻接矩阵**：是一个二维数组，其中的...
判断图中是否存在路径
07-31
数据结构中判断图中是否存在路径，包括建立图，从键盘上输入两个点看是否存在这样的路径
6-2 两顶点之前有路径吗？
国家一级致癌物
11-23 1606
6-2 两顶点之前有路径吗？ (20 分) 对于给定的无向图及两个图中的顶点，请实现一个函数，分别打印包含这两个顶点的连通分量中的顶点数，并判断这两个顶点之间是否有路径。 函数接口定义： int hasPath(struct Graph *g, int v, int w); 其中v和w是顶点 图定义如下: #define MaxVertexNum 20 /* 最大顶点数 */ struct Graph{ int v; /* 顶点数量 */ int Adj[MaxVertexNum
7-1 堆中的路径（25 分）
z6_6z的博客
03-11 909
7-1 堆中的路径（25 分）将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i，打印从H[i]到根结点的路径。输入格式:每组测试第1行包含2个正整数N和M(≤1000)，分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。输出格式:对输入中给出的每个下标i，在一行中输出从H...
用两种遍历方法判断图中两点是否有路径
小杏儿的小家
09-02 1231
图的路径判断问题
判断两点之间是否存在路径 PTA (JAVA)
最新发布
Narnat的博客
11-30 1437
本题要求输出两个顶点之间是否存在路径 。java实现
给定一个有N个顶点和E条边的无向图，请判断给定的两个顶点之间是否有路径存在。 假设顶点从0到N−1编号。 输入格式: 输入第1行给出2个整数N(0＜N≤10)和E，分别是图的顶点数和边数。 随后
jinzai9976的博客
05-14 3813
https://blog.csdn.net/weixin_45735242/article/details/106878853 转载地址如上，仅作笔记记录
Chapter 4 | Trees and Graphs--判断有向图两节点之间是否存在路径
wenqian 'blog
07-24 8654
4.2  Given a directed graph, design an algorithm to find out whether thereis a route between two nodes.
java 判断一个图中任意两点是否存在可达路径
成君的博客
02-25 1772
假设存在图，如下: 判断图中任意两点是否存在路径？ 思路: 使用图的 BFS/DFS 算法思想搜索整张图，从 1 位置出发保存所有可达的节点到集合中，若已存在则 return，直到所有可达的点都搜索到。 按照这个思路开始准备点测试数据。 先构建合适的结构体 class Node { Node up; Node down; Node left; Node right; int value; Node(int value) { this.value = va...
两点间有路径吗？ (20 分)
duududuud的博客
12-13 1526
对于给定的无向图以及图中的两个顶点，计算两个顶点所在的连通分量中的顶点数，并且判断这两个顶点之间是否有路径。 输入格式: 第一行是不超过20的正整数N，表示图有N个顶点，顶点的编号即0~N-1； 接下来N行，是N*N的邻接矩阵，矩阵的元素间用空格分隔； 最后一行是用空格隔开的两个顶点编号v和w 输出格式: 第一行输出v所在的连通分量的顶点数 第二行输出w所在的连通分量的顶点数 第三行，若v和w之间有路径，则输出Yes，否则输出No 注意：当v和w是同一个顶点时，认为v和w之间是有路径的。
无向图的邻接表存储与输出实现
本文主要介绍了如何使用邻接表来存储和输出无向图，并提供了相关的C++代码实现。 在图的表示方法中，邻接表是一种高效的数据结构，尤其适用于处理稀疏图（边的数量远小于顶点数量的平方）。无向图指的是图中的边...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ZShiJ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值