图的广度优先遍历实现

最新推荐文章于 2023-08-25 01:24:53 发布
最新推荐文章于 2023-08-25 01:24:53 发布
阅读量2.4k 收藏 14
点赞数 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.史
关注
专栏目录
图的深度、广度优先遍历（c语言）
12-20
本程序方便的实现了图的深度、广度优先遍历。是数据结构中的一部分，现与大家分享
彻底学懂BFS广度优先遍历（最全解）
最新发布
2301_80636070的博客
09-04 3254
广度优先遍历（Breadth-First Search，BFS）是一种图形搜索算法，从图的某一特定顶点出发，首先访问其所有邻接顶点，然后再依次访问这些邻接顶点的邻接顶点，如此一层一层地向外扩展，直到访问完所有顶点。在二叉树等数据结构中，BFS 通常按照从根节点开始，一层一层地横向遍历节点。
图的广度优先遍历概念和实现
yulio1234的博客
08-31 1067
广度优先遍历是按层次遍历，和树的广度优先遍历很像。给定一个顶点，一层一层的往外遍历。可以想象成一组人在向各个方向走迷宫，当遇到路口时等待其他人走到这一层路口，然后分裂成更多的人走这个迷宫。 广度优先遍历是通过队列实现的。/** * 广度优先遍历 * @author yuli * */ public class BreadthFirstSearch implements Paths{
【数据结构】图的广度优先遍历
每天进步一点丶的博客
03-20 1581
文章目录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 3053
【经典算法实现 31】图的遍历 --- 广度优先遍历算法一、 广度优先遍历算法1.1 实现思路1.2 广度优先遍历算法代码实现二、完整代码2.1 运行结果 本文接着 《【经典算法实现 30】图的创建 — 十字链表法》， 《【经典算法实现 31】图的遍历 — 深度优先遍历算法》 本文，我们来实现图的广度优先遍历算法。 先上图 一、 广度优先遍历算法 深度优先遍历算法 与 广度优先遍历算法 最大的区别在于， 深度优先遍历算法 使用的栈，后进先出 广度优先遍历算法 使用的是队列，先进先出 1.1 实现
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
无向图建立、深度优先遍历和广度优先遍历实现算法 本文将详细介绍无向图的建立、深度优先遍历和广度优先遍历的实现算法。这些算法是数据结构中非常重要的内容，掌握它们对后续学习和应用非常重要。 一、无向图的...
C++实现图的邻接表存储和广度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接表存储和广度优先遍历方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6...
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
这个递归版本的实现有问题，因为它会导致栈溢出（Maximum call stack size exceeded），因为广度优先遍历不适合递归实现。 - **非递归版本**： ```javascript function wideTraversal(selectNode) { var nodes...
js代码-二叉树广度优先遍历
07-16
二叉树的广度优先遍历在很多场景下都有用处，如查找最近公共祖先、实现图的层次遍历等。例如，在查找二叉树中两个节点的最近公共祖先时，可以先通过BFS找到这两个节点，然后找出它们在遍历过程中第一次同时出现的父...
建立图的邻接矩阵或邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历.doc
10-10
"建立图的邻接矩阵或邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历" 本文档主要介绍了图的存储方式，包括邻接矩阵和邻接表两种存储方法，并在此基础上实现了图的深度优先遍历和广度优先遍历。 一、图...
图的深度优先遍历与广度优先遍历(C语言实现)
10-17
数据结构中的图结构，其中最重要的两个遍历算法——深度优先遍历与广度优先遍历
图的遍历（深度优先和广度优先遍历算法）
04-18
图作为较为复杂的数据结构，对图的操作首先应该了解图的深度优先和广度优先搜索遍历算法！
PIPIOJ 1397:图的遍历——广度优先搜索
已归档
02-28 886
题目描述： 广度优先搜索遍历类似于树的按层次遍历的过程。其过程为：假设从图中的某顶点v出发，在访问了v之后依次访问v的各个未曾被访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作为起始点。重复上述过程，直至图中所有顶点都被访问到为止。 在本题中，读入一个无向图的邻接矩阵（即数组表示），建立无向图并按照以上描述中的算法遍历所有
（bfs）广度优先 实现图的遍历
zhenaoxi1077的博客
05-17 411
参考书： 《啊哈算法第五章：图的遍历》 《第一节。深度优先和广度优先究竟是啥》——广度优先 实现图的遍历 广度优先算法实现图的遍历代码如下： #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 897
广度优先周游二叉树(层序遍历)是用队列来实现的，从二叉树的第一层（根结点）开始，自上至下逐层遍历；在同一层中，按照从左到右的顺序对结点逐一访问。 按照从根结点至叶结点、从左子树至右子树的次序访问二叉树的结点。算法：     1初始化一个队列，并把根结点入列；     2根节点入队     3循环直到队列空       3.1  q=队列头元素出队       3.2  访问q的数据域
【数据结构】图-图的遍历_广度优先遍历（动态图解、c++、java）
扑腾的江鱼复习仓库
03-27 4621
URLeisure的图的遍历_广度优先遍历“完美”复习资料。
数据结构--图的广度优先遍历
qq_42338744的博客
10-19 1157
C语言 图的广度优先遍历 BFS算法
数据结构--图的遍历（广度优先遍历、深度优先遍历）
m0_61402375的博客
08-25 1250
然后依次访问W1、W2、....Wi的所有未访问过的邻接顶点，再从这些访问过的顶点出发，访问他们所有未被访问过的邻接顶点，直至图中的所有顶点都被访问过为止。而对于有向图则不是这样，因为一个连通的有向图，分为强连通的和非强连通的，它的连通子图也分为强连通分量和非强连通分量，非强连通分量一次调用BFS（G，i）或DFS（G，i）无法访问到该连通分量的所有顶点。图的遍历是指从图中的某一顶点出发，按照某种搜索方法，沿着图中的边对图中的所有顶点访问一次，且仅访问一次。需要注意的是，同一个图的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Mr.史

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

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

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

打赏作者

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

抵扣说明：

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

余额充值