图的存储、构造、遍历、应用（代码+注释+图片说明）

置顶 已于 2024-03-18 20:15:26 修改
阅读量820 收藏 7
点赞数 5
分类专栏： 数据结构与算法 文章标签： 图论 算法 数据结构
于 2023-01-24 22:34:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigBbug/article/details/128758387
版权

一、图的存储模式（这里讲述两种常用的）

（1）邻接矩阵

//邻接矩阵
#define inf 0x7fffffff
vector<bool> visit;

typedef char VertexType;//图的顶点类型
typedef int ArcType;//边的权值类型

typedef struct {
	vector<VertexType> vex;//顶点表
	vector<vector<ArcType>> arc;//邻接矩阵 边表
	int vexNum, arcNum;//当前顶点数 边数
}MGraph;

（2）邻接表

//邻接表
#define MVNum 100//最大顶点数
vector<bool> visit;

typedef char VerTexType;
typedef int OtherInfo;

typedef struct ArcNode {
	int adjvex;//所指向的顶点的位置
	struct ArcNode* nextarc;//指向下一条边的指针
	OtherInfo info;//和边相关的其他信息
	ArcNode(int i) :adjvex(i), nextarc(NULL), info(NULL) {};
}ArcNode;

typedef struct VNode {
	VerTexType data;//顶点信息
	ArcNode* firstarc;//指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum];//AdjList表示邻接表类型

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

二、图的两种构造方式

（1）邻接矩阵构造

#include<iostream>
#include<vector>
#include <algorithm>
#include<iterator>
using namespace std;
#define inf 0x7fffffff

typedef char VertexType;//图的顶点类型
typedef int ArcType;//边的权值类型

typedef struct {
	vector<VertexType> vex;//顶点表
	vector<vector<ArcType>> arc;//邻接矩阵 边表
	int vexNum,arcNum;//当前顶点数 边数
}MGraph;

//构造无向网：无向图权值为0或1即可
//			  有向网只赋值G[i][j]
void create_Graph(MGraph& G) {
	cin >> G.vexNum >> G.arcNum;//图的顶点数和边数

	//顶点信息
	G.vex.resize(G.vexNum);
	for (int i = 0; i < G.vexNum; i++) cin >> G.vex[i];

	//初始化边信息
	vector<vector<ArcType>> arc(G.vexNum,vector<ArcType>(G.vexNum,inf));//赋值为无穷大
	G.arc = arc;

	//边信息
	VertexType vex1, vex2;
	int weight;
	for (int k = 0; k < G.arcNum; k++) {
		cin >> vex1 >> vex2 >> weight;//两顶点 权值
		int i = find(G.vex.begin(), G.vex.end(), vex1)-G.vex.begin();//vex1 vex2在图中的位置
		int j = find(G.vex.begin(), G.vex.end(), vex2) - G.vex.begin();
		G.arc[i][j] = G.arc[j][i] = weight;//权值
	}

}

int main() {
	MGraph G;
	create_Graph(G);
	return 0;
}

（2）邻接表构造

#include<iostream>
using namespace std;
#define MVNum 100//最大顶点数

typedef char VerTexType;
typedef int OtherInfo;

typedef struct ArcNode {
	int adjvex;//所指向的顶点的位置
	struct ArcNode* nextarc;//指向下一条边的指针
	OtherInfo info;//和边相关的其他信息
	ArcNode(int i) :adjvex(i), nextarc(NULL), info(NULL) {};
}ArcNode;

typedef struct VNode {
	VerTexType data;//顶点信息
	ArcNode* firstarc;//指向第一条依附该顶点的边的指针
}VNode,AdjList[MVNum];//AdjList表示邻接表类型

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

//创建无向图
void CreateUDG(ALGraph& G){
	cin >> G.vexnum >> G.arcnum;//输入图的顶点数 边数
	for (int i = 0; i < G.vexnum; i++) {//建立顶点表
		cin >> G.vertices[i].data;//输入顶点值
		G.vertices[i].firstarc = NULL;//初始化表头节点的指针域
	}
	VerTexType vex1, vex2;
	for (int k = 0; k < G.arcnum; k++) {//输入各边 构造邻接表
		cin >> vex1 >> vex2;//输入一条边依附的两个顶点
		int i = Locate(G, vex1);
		int j = Locate(G, vex2);
		ArcNode* p1 = new ArcNode(j);//生成新节点头插入边表
		p1->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p1;
		ArcNode* p2 = new ArcNode(i);
		p2->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p2;
	}

}

//找下标
int Locate(ALGraph G, VerTexType vex) {
	for (int i = 0; i < G.vexnum; i++) {
		if (G.vertices[i].data = vex) return i;
	}
	return -1;
}

int main() {
	ALGraph G;
	CreateUDG(G);
	return 0;
}

三、图的遍历（BFS、DFS）

这里给出一个无向图：
在这里插入图片描述

（1）邻接矩阵深度、广度优先遍历

#include<iostream>
#include<vector>
#include <algorithm>
#include<iterator>
#include<queue>
using namespace std;
 
//邻接矩阵
#define inf 0x7fffffff
vector<bool> visit;

typedef char VertexType;//图的顶点类型
typedef int ArcType;//边的权值类型

typedef struct {
	vector<VertexType> vex;//顶点表
	vector<vector<ArcType>> arc;//邻接矩阵 边表
	int vexNum, arcNum;//当前顶点数 边数
}MGraph;

//构造无向网：无向图权值为0或1即可
//			  有向网只赋值G[i][j]
void CreateUDG(MGraph& G) {
	cin >> G.vexNum >> G.arcNum;//图的顶点数和边数

	//顶点信息
	G.vex.resize(G.vexNum);
	for (int i = 0; i < G.vexNum; i++) cin >> G.vex[i];

	//初始化边信息
	vector<vector<ArcType>> arc(G.vexNum, vector<ArcType>(G.vexNum, inf));//赋值为无穷大
	G.arc = arc;

	//边信息
	VertexType vex1, vex2;
	int weight;
	for (int k = 0; k < G.arcNum; k++) {
		cin >> vex1 >> vex2 >> weight;//两顶点 权值
		int i = find(G.vex.begin(), G.vex.end(), vex1) - G.vex.begin();//vex1 vex2在图中的位置
		int j = find(G.vex.begin(), G.vex.end(), vex2) - G.vex.begin();
		G.arc[i][j] = G.arc[j][i] = weight;//权值
	}

}

//从顶点出发 深度优先遍历图
void DFS(MGraph G,int v) {
	cout << G.vex[v]<<" ";
	visit[v] = true;
	for (int i = 0; i < G.vexNum; i++) {
		if (G.arc[v][i] != inf && !visit[i]) {//查找尚未访问的邻节点
			DFS(G,i);
		}
	}
}

//深度优先遍历
void DFSTraverse(MGraph G) {
	visit.resize(0);//这里两次resize是为了保证初始化为false
	visit.resize(G.vexNum);//初始化访问节点数组
	for (int i = 0; i < G.vexNum; i++) {//这里for循环的是防止该图不是连通图
		if (!visit[i]) DFS(G, i);
	}
}

//广度优先遍历
void BFS(MGraph G) {
	visit.resize(0);//这里两次resize是为了保证初始化为false
	visit.resize(G.vexNum);//初始化访问节点数组
	queue<VertexType>Q;
	for (int i = 0; i < G.vexNum; i++) {//这里for循环的意义同样是防止是非连通图
		if (!visit[i]) {//如果节点未被访问
			Q.push(G.vex[i]);//添加节点
			visit[i] = true;
			while (!Q.empty()) {
				cout << Q.front()<< " ";
				int k = find(G.vex.begin(), G.vex.end(), Q.front()) - G.vex.begin();
				Q.pop();
				for (int j = 0; j < G.vexNum; j++) {
					if (!visit[j]&&G.arc[k][j]!=inf) {
						Q.push(G.vex[j]);
						visit[j] = true;
					}
				}
			}
		}
	}
}
int main() {
	MGraph G;
	CreateUDG(G);
	cout << "DFS：";
	DFSTraverse(G);
	puts("");
	cout << "BFS：";
	BFS(G);
	return 0;
}

这里带权值：

5 5
A B C D E
A B 1
A C 1
B D 1
B E 1
D E 1
DFS：A B D E C
BFS：A B C D E

（2）邻接表深度、广度优先遍历

#include<iostream>
#include<vector>
#include<queue>
using namespace std;

//邻接表
#define MVNum 100//最大顶点数
vector<bool> visit;

typedef char VerTexType;
typedef int OtherInfo;

typedef struct ArcNode {
	int adjvex;//所指向的顶点的位置
	struct ArcNode* nextarc;//指向下一条边的指针
	OtherInfo info;//和边相关的其他信息
	ArcNode(int i) :adjvex(i), nextarc(NULL), info(NULL) {};
}ArcNode;

typedef struct VNode {
	VerTexType data;//顶点信息
	ArcNode* firstarc;//指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum];//AdjList表示邻接表类型

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

//找下标
int Locate(ALGraph G, VerTexType vex) {
	for (int i = 0; i < G.vexnum; i++) {
		if (G.vertices[i].data == vex) return i;
	}
	return -1;
}

//创建无向图
void CreateUDG(ALGraph& G) {
	cin >> G.vexnum >> G.arcnum;//输入图的顶点数 边数
	for (int i = 0; i < G.vexnum; i++) {//建立顶点表
		cin >> G.vertices[i].data;//输入顶点值
		G.vertices[i].firstarc = NULL;//初始化表头节点的指针域
	}
	VerTexType vex1, vex2;
	for (int k = 0; k < G.arcnum; k++) {//输入各边 构造邻接表
		cin >> vex1 >> vex2;//输入一条边依附的两个顶点
		int i = Locate(G, vex1);
		int j = Locate(G, vex2);
		ArcNode* p1 = new ArcNode(j);//生成新节点头插入边表
		p1->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p1;
		ArcNode* p2 = new ArcNode(i);
		p2->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p2;
	}

}

//从顶点出发 深度优先遍历图
void DFS(ALGraph G,int v) {
	cout << G.vertices[v].data << " ";
	visit[v] = true;
	ArcNode* p = G.vertices[v].firstarc;
	while (p->nextarc) {//查找尚未访问的邻节点
		if (!visit[p->adjvex]) DFS(G, p->adjvex);
		p = p->nextarc;
	}
}

//深度优先遍历图
void DFSTraverse(ALGraph G) {
	visit.resize(0);//这里两次resize是为了保证初始化为false
	visit.resize(G.vexnum);//初始化访问节点数组
	for (int i = 0; i < G.vexnum; i++) {//这里for循环的意义也是防止图为非连通图
		if (!visit[i]) DFS(G, i);
	}
}

//广度优先遍历
void BFS(ALGraph G) {
	visit.resize(0);//这里两次resize是为了保证初始化为false
	visit.resize(G.vexnum);//初始化访问节点数组
	queue<VerTexType> Q;//队列存储节点
	for (int i = 0; i < G.vexnum; i++) {//这里for循环的意义同样是防止是非连通图
		if (!visit[i]){
			Q.push(G.vertices[i].data);//添加节点
			visit[i] = true;
			while (!Q.empty()) {
				cout << Q.front() << " ";
				int k = Locate(G, Q.front());
				Q.pop();
				ArcNode* p = G.vertices[k].firstarc;
				while (p->nextarc) {//查找尚未访问的邻节点入队列
					if (!visit[p->adjvex]) {
						Q.push(G.vertices[p->adjvex].data);
						visit[p->adjvex] = true;
					}
					p = p->nextarc;
				}
			}
		}
	}
	
}

int main() {
	ALGraph G;
	CreateUDG(G);
	cout << "DFS：";
	DFSTraverse(G);
	puts("");
	cout << "BFS：";
	BFS(G);
	return 0;
}

这里没带权值：

5 5
A B C D E
A B
A C
B D
B E
D E
DFS：A C B E D
BFS：A C B E D

四、图的应用（最小生成树、最短路径、拓扑排序、关键路径）

1.最小生成树

一个连通图的生成树是指一个极小连通子图，它含有图中的全部顶点，但只有足以构成一棵树的 n-1 条边。在一个连通网的所有生成树中，各边代价之和最小的那棵生成树称为该连通网 最小代价生成树（MST），简称为 最小生成树。利用普里姆（Prim）算法和克鲁斯卡尔（Kruscal）算法可以生成一个连通网的最小代价生成树，它们都是基于贪心算法策略。

1.1 普里姆（Prim）算法

（1）基本步骤

假设N=(V,{E})是连通网，TE为最小代价生成树中边的集合。
① 初始U={u0}（u0∈V），TE=空集；
② 在所有u∈U，v∈V-U的边中选一条代价最小的边（u0,v0）并入集合TE，同时将v0并入U；
③ 重复②，直到U=V为止，此时必然存在n-1条边。

通俗点说就是：从一个顶点出发，在保证不形成回路的前提下，每找到并添加一条最短的边，就把当前形成的连通分量当做一个整体或者一个点看待，然后重复“找最短的边并添加”的操作。

这里有兄弟问过我为什么不需要判断环，哥们，咱动动脑子想想，形成环要什么条件？这里是两个集合，要形成环，两个顶点必须在一个集合里面，Prim算法显然不是的。

示例：在这里插入图片描述

（2）代码实现+注释
#include<iostream>
#include<vector>
using namespace std;
#define inf 0x7fffffff

typedef char VertexType;//图的顶点类型
typedef int ArcType;//边的权值类型

typedef struct {
	vector<VertexType> vex;//顶点表
	vector<vector<ArcType>> arc;//邻接矩阵 边表
	int vexNum, arcNum;//当前顶点数 边数
}MGraph;

//构造无向网：无向图权值为0或1即可
//			  有向网只赋值G[i][j]
void CreateUDG(MGraph& G) {
	cin >> G.vexNum >> G.arcNum;//图的顶点数和边数

	//顶点信息
	G.vex.resize(G.vexNum);
	for (int i = 0; i < G.vexNum; i++) cin >> G.vex[i];

	//初始化边信息
	vector<vector<ArcType>> arc(G.vexNum, vector<ArcType>(G.vexNum, inf));//赋值为无穷大
	G.arc = arc;

	//边信息
	VertexType vex1, vex2;
	int weight;
	for (int k = 0; k < G.arcNum; k++) {
		cin >> vex1 >> vex2 >> weight;//两顶点 权值
		int i = find(G.vex.begin(), G.vex.end(), vex1) - G.vex.begin();//vex1 vex2在图中的位置
		int j = find(G.vex.begin(), G.vex.end(), vex2) - G.vex.begin();
		G.arc[i][j] = G.arc[j][i] = weight;//建立对称弧
	}

}

//Prim算法生成最小生成树
//时间复杂度：O(n*n)即O(v*v)
void MiniSpanTree_Prim(MGraph G){
	int j, n = G.vexNum-1, mincost;//j用来记录下标 n用来记录循环遍历 mincost记录最小权值
	//path保存相关顶点下标 这里从v0开始 即下标零开始 解释：path[i] = j——> 第i个顶点与第j个顶点的弧 这里首先初始化所有点与顶点0的弧
	vector<int> path(G.vexNum, 0);
	//lowcost保存顶点间边的权值 这里从v0开始 即下标零开始 初始化arc[0]（将v0顶点与之组成的边的权值存入数组）lowcost[i] = w, path[i] = j 
	//即顶点i和顶点j之间弧权值为w
	//就是保存已加入树的点 距离此点的最小权值
	vector<int> lowcost(G.arc[0]);
	//初始化第一个权值为0，即v0加入生成树
	//lowcost的值为0，在这里就是此下标的顶点已经加入生成树，也相当于一个标记
	lowcost[0] = 0;
	//这里也可以写一个标记数组标记节点是否已经加入生成树中
	//如vector<int> isJoin(G.vexNum, false);
	while (n--) {
		mincost = inf;//初始化最小权值为inf(无穷大)
		for (int i = 1; i < G.vexNum; i++) {
			if (lowcost[i]!=0&&lowcost[i] < mincost) {//如果权值不为0且权值小于mincost 找除了已经存入树的顶点的最小权值
				mincost = lowcost[i];
				j = i;//记录当前下标
			}
		}
        cout<<j<<" ";
		cout << G.vex[path[j]] << " " << G.vex[j] << endl;//打印当前顶点边中权值最小边的两顶点，即新加入生成树的一条边
		lowcost[j] = 0;//将当前顶点权值设置为0 表示此顶点已经加入生成树

		//再次循环遍历，找到未加入的节点以及与下标为k的结点相连的结点的权值与前面的比较，更小则进行覆盖
		for (int i = 1; i < G.vexNum; i++) {//若下标为k顶点各边权值小于此前这些顶点未被加入生成树的边权值则覆盖原本lowcost并且建立弧关系
			//lowcost[i] = w, path[i] = j 
			//即顶点i和顶点k之间弧权值为j
			//就是保存已加入树的点 距离此点的最小权值
			if (lowcost[i] != 0&&G.arc[j][i] < lowcost[i]) {//这里lowcost[i]!=0没有实际意义 我这里加上就是提醒大家这里第i个顶点已经被加入 不会形成环 它是往外面找的
				lowcost[i] = G.arc[j][i];//将较小权值覆盖上一次权值 存入lowcost
				path[i] = j;//弧建立关系 即下标为k的顶点与顶点i联系
			}
		}

	}
}

int main() {
	MGraph G;
	CreateUDG(G);
	MiniSpanTree_Prim(G);
	return 0;
}

6 10
A B C D E F
A B 6
C D 6
B C 3
D E 2
A E 5
A F 1
B F 5
C F 6
D F 4
E F 5
A F
F D
D E
F B
B C

1.2 克鲁斯卡尔（Kruscal）算法

（1）基本步骤

假设N=(V,{E})是连通网，将N中的边按权值从小到大的顺序排列。
① 将n个顶点看成n个集合。
② 按权值从小到大的顺序选择边，所选边应满足两个顶点不在同一个顶点集合内，将该边放到生成树边的集合中，同时将该边的两个顶点所在的顶点集合合并。
③ 重复②直到所有的顶点都在同一顶点集合内。
示例：
在这里插入图片描述

（2）代码实现+注释
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

typedef char VexType;

//边存储结构
typedef struct Edge {
	int begin;//起点序号
	int end;//尾点序号
	int weight;//权值
}Edge;

//图存储结构
typedef struct EdgeGraph {
	vector<VexType> vex;//顶点信息
	vector<Edge> arc;//边信息
	int vexnum, arcnum;//顶点数 边数

}EdgrGraph;

//权值升序
bool cmp(Edge e1,Edge e2) {
	return e1.weight < e2.weight;
}

//创建网
void Create_EdgeGraph(EdgeGraph& G) {
	cin >> G.vexnum >> G.arcnum;//输入顶点数和边数
	G.vex.resize(G.vexnum);//初始化顶点数组大小
	G.arc.resize(G.arcnum);//初始化边数组大小
	for (int k = 0; k < G.vexnum; k++) {
		cin >> G.vex[k];//输入顶点信息
	}
	VexType vex1, vex2;//两顶点
	int weight;//权值
	for (int k = 0; k < G.arcnum; k++) {//保存边信息
		cin >> vex1 >> vex2 >> weight;//输入边信息：两顶点 + 权值
		G.arc[k].begin = find(G.vex.begin(), G.vex.end(), vex1) - G.vex.begin();
		G.arc[k].end = find(G.vex.begin(), G.vex.end(), vex2) - G.vex.begin();
		G.arc[k].weight = weight;
	}
}

//Kruskar算法生成最小生成树
void MiniSpanTree_Kruskal(EdgeGraph G) {
	sort(G.arc.begin(), G.arc.end(), cmp);//按照权值升序
	vector<bool> vexset(G.vexnum, false);//节点是否已经存入树中
	for (int k = 0; k < G.arcnum; k++) {
		int i = G.arc[k].begin;
		int j = G.arc[k].end;
		if (!(vexset[i]&&vexset[j])) {//两顶点不在同一集合 不会形成环
			cout << G.vex[i] << " " << G.vex[j] << endl;
			vexset[i] = vexset[j] = true;
		}
	}
}

int main() {
	EdgeGraph G;
	Create_EdgeGraph(G);
	MiniSpanTree_Kruskal(G);
	return 0;
}

6 10
A B C D E F
A B 16
B C 5
B D 6
C D 6
D E 18
A E 19
A F 21
D F 14
E F 33
B F 11
B C
B D
B F
A B
D E

在这里插入图片描述

2.最短路径

2.1 BFS算法求解单源最短路径（无权图）

（1）邻接矩阵

#include<bits/stdc++.h>
using namespace std;
#define inf 0x7fffffff

typedef char VertexType;//图的顶点类型
typedef int ArcType;//边的权值类型

typedef struct {
    vector<VertexType> vex;//顶点表
    vector<vector<ArcType>> arc;//邻接矩阵 边表
    int vexNum, arcNum;//当前顶点数 边数
}MGraph;

vector<int> path;
vector<int> d;

//BFS算法求解单源最短路径（无权连通图/所有边权值都相同的连通图）
//求顶点u到其他顶点的最短路径
void BFS_MIN_Distance(MGraph G, int u) {
    //标记访问
    vector<bool> visit(G.vexNum, false);
    //初始化path（先驱）和d（距离）
    path.resize(G.vexNum);
    d.resize(G.vexNum);
    for (int i = 0; i < G.vexNum; ++i) {
        d[i] = inf;     //初始化路径长度
        path[i] = -1;   //节点先驱
    }
    d[u] = 0;
    visit[u] = true;    //标记访问
    queue<int> q;
    q.push(u);
    while (!q.empty()) {
        //队头元素u出队
        u = q.front();
        q.pop();
        for (int j = 0; j < G.vexNum; j++) {
            if (!visit[j] && G.arc[u][j] != inf) {  //访问u尚未被访问过的邻接点
                d[j] = d[u] + 1;    //路径长度加一
                path[j] = u;        //j前驱为u
                q.push(j);       //顶点j入队
                visit[j] = true;    //设为访问标记
            }
        }
    }
}

int main() {
    MGraph G;
    CreateUDG(G);
    int u = 0;
    cin>>u;
    BFS_MIN_Distance(G, u-1);//这里u-1是因为节点从一开始，数组下标从0开始
    for(int i:d){
        cout<<i<<" ";
    }
    cout<<endl;
    for(int i:path){
        cout<<i<<" ";
    }
    return 0;
}

8 10
1 2 3 4 5 6 7 8
1 5
1 2
2 6
6 3
6 7
3 7
3 4
7 4
7 8
4 8
2
1 0 2 3 2 1 2 3 
1 -1 5 2 0 1 5 6（注意这里path整体减一是因为数组下标是从0开始的）

在这里插入图片描述
（2）邻接表

//邻接表
#define MVNum 100//最大顶点数
#define inf 0x7fffffff
vector<int> path;
vector<int> d;

typedef char VerTexType;
typedef int OtherInfo;

typedef struct ArcNode {
	int adjvex;//所指向的顶点的位置
	struct ArcNode* nextarc;//指向下一条边的指针
	OtherInfo info;//和边相关的其他信息
	ArcNode(int i) :adjvex(i), nextarc(NULL), info(NULL) {};
}ArcNode;

typedef struct VNode {
	VerTexType data;//顶点信息
	ArcNode* firstarc;//指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum];//AdjList表示邻接表类型

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


//BFS算法求解单源最短路径（无权连通图/所有边权值都相同的连通图）
//求顶点u到其他顶点的最短路径
void BFS_MIN_Distance(ALGraph G, int u) {
    //标记访问
    vector<bool> visit(G.vexnum, false);
    //初始化path（先驱）和d（距离）
    path.resize(G.vexnum);
    d.resize(G.vexnum);
    for (int i = 0; i < G.vexnum; ++i) {
        d[i] = inf;     //初始化路径长度
        path[i] = -1;   //节点先驱
    }
    d[u] = 0;
    visit[u] = true;    //标记访问
    queue<int> q;
    q.push(u);
    while (!q.empty()) {
        //队头元素u出队
        u = q.front();
        q.pop();
        ArcNode* p = G.vertices[u].firstarc;
        while(p){
            int j = p->adjvex;
            if(!visit[j]){
                d[j] = d[u] + 1;    //路径长度加一
                path[j] = u;        //j前驱为u
                q.push(j);       //顶点j入队
                visit[j] = true;    //设为访问标记
            }
            p = p->nextarc;
        }
    }

}


int main() {
    ALGraph G;
    CreateUDG(G);
    int u = 0;
    cin>>u;
    BFS_MIN_Distance(G, u-1);//这里u-1是因为节点从一开始，数组下标从0开始
    for(int i:d){
        cout<<i<<" ";
    }
    cout<<endl;
    for(int i:path){
        cout<<i<<" ";
    }
    return 0;
}

8 10
1 2 3 4 5 6 7 8
1 5
1 2
2 6
6 3
6 7
3 7
3 4
7 4
7 8
4 8
2
1 0 2 3 2 1 2 3 
1 -1 5 6 0 1 5 6 （注意这里path整体减一也是因为数组下标是从0开始的）
天皓Oo
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的存储与遍历
！
02-01 648
邻接矩阵(二维数组)即是：先用一 个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系。矩阵可以存储0或者1来表示两个顶点之间是否连通，也可以存储权值。. 用邻接矩阵存储图是能够快速知道两个顶点是否连通，缺陷是如果顶点比较多，边比较少时，矩阵中存储了大量值为0的矩阵，比较浪费空间，并且要求两个节点之间的路径不是很好求。例如：上面的邻接矩阵中，如果两个顶点之间不连通的话，用无穷大来表示。上面的是有向图，无向图的矩阵是对称的。邻接表：使用数组表示顶点的集合，使用链表表示边的关系。
java初学者完整代码+注释16
03-19
【Java初学者完整代码+注释16】这个资源针对的是正在学习Java编程语言的初学者，提供了21个课程的代码示例和详细的注释，旨在帮助他们扎实地掌握Java的基础知识。在这个系列中，我们可以学到许多重要的编程概念和...
数据结构 | 图的遍历
鷾
06-03 3207
图的基本操作，以及图的深度优先遍历、广度优先遍历的C语言实现
【ZZULI数据结构实验】之图的应用（C语言实现）
最新发布
wszhj_的博客
05-19 797
📃博客主页：💚，欢迎访问🚀🌏任尔江湖满血骨，我自踏雪寻梅香。万千浮云遮碧月，独傲天下百坚强。男儿应有龙腾志，盖世一意转洪荒。莫使此生无痕度，终归人间一捧黄。🍎🍎🍎❤️什么？你问我答案，少年你看，下一个十年又来了 💞 💞 💞。
图论--图的存储及遍历
信息学奥赛学案
07-04 1102
图的存储与遍历
图的存储及遍历
JingLuan1109的博客
12-11 127
1.)边的集合法，其记录节点数，边数， 每条边的起点和终点。简单容易理解，但有很多冗余数据，时间复杂度高，适合存储稠密图。3.)数组模拟邻接表，其只记录存有边的两点，不容易理解，但无冗余数据，时间复杂度低，适合存储稀疏图。5.)最小生成树：重点掌握Kruskal算法，用到并查集排序算法，期时间复杂度为n*logn。1.)深度优先搜索，关键操作是父亲出栈，孩子入栈，以及合法孩子的判断。2.)广度优先搜索,关键操作是父亲入栈，孩子出栈，以及合法孩子的判断。ii:方法二：动态数组实现(实现起来简单，必须掌握)
【算法】图的遍历
白晨的博客
03-27 996
本次白晨带来的是图论中最基础，但也最重要的部分——图的遍历。众所周知，图的存储方式有一般有邻接表和邻接矩阵两种，这两种存储方式的遍历方式也各不相同，但是无非也就是访问出边和入边的方式不同罢了（邻接矩阵之间访问当前行/列，邻接表则访问对应节点的链表），思想还是相同的。本文中对于邻接表的实现方法不过多介绍（以后会专门讲解我这种实现），各位只需要用自己擅长的实现即可，主要的题目中的思想。
图的遍历（c语言）
qq_51082383的博客
11-17 2985
文章目录图的遍历种类深度优先遍历算法实现广度优先遍历算法实现 图的遍历 概念:图遍历是一种用于在图中搜索顶点的技术。图的遍历也用来决定在搜索过程中访问顶点的顺序。图的遍历可以在不创建循环的情况下找到要在搜索过程中使用的边。这意味着使用图遍历，我们访问图的所有顶点而不进入循环路径。 种类 目前，只有两种 DFS (Depth First Search) 中文：深度优先遍历 BFS (Breadth First Search) 中文:广度优先遍历 深度优先遍历 方法有很多种，我这里采用访问的时候定一个主方向
基于C++、文件操作和Huffman算法实现图片压缩源码+使用说明+详细注释+sln解决方案.zip
10-27
基于C++、文件操作和Huffman算法实现图片压缩源码+使用说明+详细注释+sln解决方案.zip ——使用C++、文件操作和Huffman算法实现“图片压缩程序”。 ## 1. 核心知识 （1） 树的存储结构 （2） 二叉树的三种遍历方法...
BPlus B+树 代码与注释
05-25
而`文档BPlusTree.doc`可能包含实现B+树的源代码及其注释，对于理解和学习B+树的实际应用非常有帮助。 通过阅读这些材料，你可以深入理解B+树的工作原理，学习如何用代码实现B+树，并了解其在实际问题中的应用。这...
数据结构实验报告-图的遍历.doc
07-11
验 报 告 实验：图的遍历 一、实验目的： 1、理解并掌握图的逻辑结构和物理结构——邻接矩阵、邻接表 2、掌握图的构造方法 3、掌握图的邻接矩阵、邻接表存储方式下基本操作的实现算法 4、掌握图的深度优先遍历和广度...
图的遍历（深度优先和广度优先遍历算法）
04-18
图作为较为复杂的数据结构，对图的操作首先应该了解图的深度优先和广度优先搜索遍历算法！
一个基于 C++ 编写的学生成绩管理系统 + 源代码 + 详细文档
04-28
学生成绩管理系统是一种常见的软件应用，它用于存储、管理和分析学生的考试成绩，为教育机构提供便利的数据处理工具。本项目是用C++编程语言编写的，对于初学者来说，这是一个极好的实践案例，可以帮助理解面向对象...
图的遍历（C语言）
weixin_52044227的博客
04-29 3517
文章目录深度优先搜索概念过程算法实现 深度优先搜索 概念 深度优先搜索遍历类似于树的先序遍历，是树的先序遍历的推广 深度优先搜索所遵循的搜索策略是尽可能“深”地搜索图。讲通俗一点，深度优先搜索其实像在走迷宫，遇到一个岔路口，先选则一条路，当发现这条路是死路时，又返回岔路口选择第二条路，直至找到出口。 过程 对于一个连通图，深度优先搜索遍历过程： 1.从图中某个顶点v出发，访问v; 2.找出刚刚访问过的顶点的第一个未被访问的邻接点，访问该顶点。以该顶点为新顶点，重复该步骤，直至刚访问过的顶点没有未被访问的邻接
C语言实现数据结构代码（四）-图-图的遍历
Don-Talk的博客
12-06 2278
一、深度优先搜索遍历（DFS） 基本思想（类似于树的先序遍历）： ①首先访问出发点v，并将其标记为已访问过； ②选取与v邻接的未被访问的任意一个顶点w，访问w; ③选取与w邻接的未被访问的任一顶点访问； ④以此重复进行。 当一个顶点所有的邻接顶点都被访问过时，则依次退回到最近被访问过的顶点。 若该顶点还有其他邻接顶点未被访问，则从这些未被访问过的顶点选取一个重复上述访问过程，直至途中所有顶点都被访问过为止。 //邻接表存储的定义表示 typedef struct ArcNode..
图的存储和遍历
m0_51711089的博客
07-22 598
深度优先搜索遍历图以"深度"为关键词，沿着一条路直到无法继续前进，才退回到路径上离当前顶点最近的且有未遍历分支的岔路口，并前往访问那些未遍历的分支，直到遍历完整个图。用vector实现邻接表，在一些顶点数目较大（一般顶点个数在1000以上）的情况下，一般是使用邻接表而不是邻接矩阵才存储图。图的遍历是指按一定顺序遍历所有顶点，一般遍历方法有两种，分别是深度优先搜索和广度优先搜索。图的存储方式有两种分别是邻接矩阵和邻接表；只适用于顶点数不太大（.........
图遍历代码
TXLTF的博客
11-30 112
【代码】图遍历代码。
[手撕数据结构] 图的存储结构及遍历方式
qq_60055052的博客
05-05 1165
代码实现图的两种存储结构（邻接矩阵法与邻接表法）以及两种遍历操作（深度优先搜索 DFS 广度优先搜索 BFS）
C语言数据结构——图
weixin_45084986的博客
10-25 2312
一、图的基本概念 图是由顶点集合及顶点间的关系集合组成的一种数据结构。vertex, edge 图G的定义是： G =（V，E） 其中， V = {x|x∈某个数据元素集合} E ={ (x，y)|x，y∈V} （无向图） 或 E = { <x， y>|x，y∈V并且Path(x， y)} (有向图) 其中，（x，y）表示从 x到 y的一条双向通路，即（x，y）是无方向的； Path（x，y）表示从 x到 y的一条单向通路，即Path（x，y）是有方向的。 图的基本术语： （1）顶点和边：
图片识别基础代码c语言
05-11
以下是一个简单的基于C语言的图片识别代码示例，使用了OpenCV库： ```c #include <stdio.h> #include <stdlib.h> #include <opencv2/opencv.hpp> using namespace cv; int main(int argc, char** argv) { if (argc != 2) { printf("Usage: ./image_recognition <path_to_image>\n"); return -1; } Mat image = imread(argv[1], IMREAD_GRAYSCALE); if (image.empty()) { printf("Could not open or find the image\n"); return -1; } // Do image recognition here imshow("Image", image); waitKey(0); return 0; } ``` 这是一个简单的代码示例，它会打开一个灰度图像并展示它。你可以在“Do image recognition here”这个注释下面添加你自己的图片识别代码。注意，在实际应用中，识别图片的算法可能要比这个示例复杂得多。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值