C++构造无向图，邻接表，深度优先遍历，广度优先遍历

已于 2022-12-18 14:37:57 修改
阅读量2.5k 收藏 60
点赞数 7
文章标签： c++ 链表 开发语言 数据结构 算法
于 2022-12-15 17:58:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44757691/article/details/128333329
版权

目录

定义无向图邻接表

构造无向图

打印邻接表

无向图邻接表深度优先遍历（DFS）

无向图邻接表广度优先遍历（BFS）

测试

 完整代码

定义无向图邻接表

#define MVnum 100 //最大定点数

//边（弧）的结点结构定义
struct ArcNode
{
	int adjvex; //该边所指向的顶点的位置
	ArcNode* nextarc; //指向下一条边的指针
};

//顶点的结点结构定义
struct VexNode
{
	string data; //顶点信息
	ArcNode* fristarc; //指向第一条依附该顶点的边的指针
};

//图的结构定义
struct ALGraph
{
	VexNode vertices[MVnum]; //邻接表数组
	int vexnum, arcnum; //图的当前总顶点数和总边数
};

构造无向图

             (1)输入总顶点数和总边数。
             (2)建立顶点表
                        依次输入点的信息存入顶点表中
                        使每个表头结点的指针域初始化为NULL
             (3)创建邻接表
                         依次输入每条边依附的两个顶点
                         确定两个顶点的序号i和j,建立边结点
                         将此边结点分别插入到vi和vj,对应的两个边链表的头部

//声明
int LocateVex(ALGraph G, string u);

//采用邻接表构建无向图
bool CreateUDG(ALGraph& G)
{
	//1.输入总顶点数和总边数
	cout << "请输入顶点数：" << endl;
	cin >> G.vexnum;
	cout << "请输入边数：" << endl;
	cin >> G.arcnum;

	//2.建立顶点表
	cout << "请输入顶点信息：" << endl;
	for (int i = 0; i < G.vexnum; i++)
	{
		cin >> G.vertices[i].data; //输入顶点值
		G.vertices[i].fristarc = NULL; //初始化表头结点的指针域
	}

	//3.创建邻接表
	cout << "请输入一条边所依附的两个顶点：" << endl;
	for (int k = 0; k < G.arcnum; k++)
	{
		string v1, v2;
		cin >> v1 >> v2; //输入一条边所依附的两个顶点
		int i = LocateVex(G, v1);
		int j = LocateVex(G, v2);

		ArcNode* p1 = new ArcNode; //生成新的边结点
		p1->adjvex = j; //邻接点序号为j
		p1->nextarc = G.vertices[i].fristarc;
		G.vertices[i].fristarc = p1; //将新结点p1插入顶点vi的边表头部

		ArcNode* p2 = new ArcNode; //生成另一个对称的新的边结点
		p2->adjvex = i; //邻接点序号为i
		p2->nextarc = G.vertices[j].fristarc;
		G.vertices[j].fristarc = p2; //将新结点p2插入顶点vj的边表头部
	}
	return true;
}

//在图G中查找顶点u，存在返回顶点表中的下标，否则返回-1
int LocateVex(ALGraph G, string u)
{
	for (int i = 0; i < G.vexnum; i++)
	{
		if (G.vertices[i].data == u)
		{
			return i;
		}
	}
	return -1;
}

打印邻接表

//打印
void PrintVex(ALGraph G)
{
	for (int i = 0; i < G.vexnum; i++)
	{
		cout << G.vertices[i].data << ": ";
		while (G.vertices[i].fristarc)
		{
			cout << G.vertices[i].fristarc->adjvex<<" ";
			G.vertices[i].fristarc = G.vertices[i].fristarc->nextarc;
		}
		cout << endl;
	}
}

无向图邻接表深度优先遍历（DFS）

1、在访问图中某一起始顶点v后，由v出发，访问它的任一邻接顶点w1；

2、再从w1出发，访问与w1邻接但还未被访问过的顶点w2;

3、然后再从w2出发，进行类似的访问，...

4、如此进行下去，直至到达所有的邻接顶点都被访问过的顶点u为止。接着，退回一步，退到前一次刚访问过的顶点，看是否还有其它没有被访问的邻接顶点。

5、如果有，则访问此顶点，之后再从此顶点出发，进行与前述类似的访问;

6、如果没有，就再退回一步进行搜索。重复上述过程，直到连通图中所有顶点都被访问过为止。

bool visited[MVnum]; //深度优先访问标志数组，初始为false;

//无向图邻接表深度优先遍历
void DFS(ALGraph G, int v)
{
	//访问第v个顶点，并置访问标志数组为true
	cout << G.vertices[v].data << " ";
	visited[v] = true;
	ArcNode *p = G.vertices[v].fristarc; //p指向v的边链表的第一个边结点
	while (p)//边结点非空
	{
		int w = p->adjvex;//表示w是v的邻接点
		if (!visited[w]) //如果w为访问，则递归调用DFS
		{
			DFS(G, w);
		}
		p = p->nextarc; //p指向下一边结点
	}
}

无向图邻接表广度优先遍历（BFS）

1、从图的一结点出发，首先依次访问该结点的所有邻接结点v1,v2......vn再按这些顶点被访问的先后次序依次访问与它们相邻的所有未被访问的顶点。

2、重复此过程，直至所有顶点均被访问为止。

bool visited1[MVnum]; //广度优先访问标志数组，初始为false;

//无向图邻接表广度优先遍历
void BFS(ALGraph G, int v)
{
	//访问第v个顶点，并置访问标志数组为true
	cout << G.vertices[v].data << " ";
	visited1[v] = true;
	queue<int>Q; //创建队列Q
	Q.push(v); //v进队
	while (!Q.empty()) //队列非空
	{
		int p = Q.front(); //将队头元素赋给p
		Q.pop(); //删除队顶元素
		ArcNode* arc = G.vertices[p].fristarc; //arc指向p的边链表的第一个边结点
		while (arc) //边结点非空
		{
			if (!visited1[arc->adjvex]) //判断边结点arc中指向顶点的位置是否被访问
			{
				cout << G.vertices[arc->adjvex].data << " ";//输出边结点arc记录位置的顶点值
				visited1[arc->adjvex] = true; //标记为true
				Q.push(arc->adjvex); //边结点arc指向顶点中的位置入队
			}
			arc = arc->nextarc; //arc指向下一边结点
		}
		
	}
}

测试

int main()
{
	ALGraph G;
	CreateUDG(G); //构造无向图邻接表
	cout << "图G的邻接表为：" << endl;
	PrintVex(G); //打印邻接表
	int v = 0;
	cout << "深度优先遍历为：" << endl;
	DFS(G, v);
	cout << endl;
	cout << "广度优先遍历为：" << endl;
	BFS(G, v);
	cout << endl;

	system("pause");
	return 0;
}

 

 完整代码

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

#define MVnum 100 //最大定点数

//边（弧）的结点结构定义
struct ArcNode
{
	int adjvex; //该边所指向的顶点的位置
	ArcNode* nextarc; //指向下一条边的指针
};

//顶点的结点结构定义
struct VexNode
{
	string data; //顶点信息
	ArcNode* fristarc; //指向第一条依附该顶点的边的指针
};

//图的结构定义
struct ALGraph
{
	VexNode vertices[MVnum]; //邻接表数组
	int vexnum, arcnum; //图的当前总顶点数和总边数
};

bool visited[MVnum]; //深度优先访问标志数组，初始为false;

bool visited1[MVnum]; //广度优先访问标志数组，初始为false;

//声明
int LocateVex(ALGraph G, string u);

//采用邻接表构建无向图
bool CreateUDG(ALGraph& G)
{
	//1.输入总顶点数和总边数
	cout << "请输入顶点数：" << endl;
	cin >> G.vexnum;
	cout << "请输入边数：" << endl;
	cin >> G.arcnum;

	//2.建立顶点表
	cout << "请输入顶点信息：" << endl;
	for (int i = 0; i < G.vexnum; i++)
	{
		cin >> G.vertices[i].data; //输入顶点值
		G.vertices[i].fristarc = NULL; //初始化表头结点的指针域
	}

	//3.创建邻接表
	cout << "请输入一条边所依附的两个顶点：" << endl;
	for (int k = 0; k < G.arcnum; k++)
	{
		string v1, v2;
		cin >> v1 >> v2; //输入一条边所依附的两个顶点
		int i = LocateVex(G, v1);
		int j = LocateVex(G, v2);

		ArcNode* p1 = new ArcNode; //生成新的边结点
		p1->adjvex = j; //邻接点序号为j
		p1->nextarc = G.vertices[i].fristarc;
		G.vertices[i].fristarc = p1; //将新结点p1插入顶点vi的边表头部

		ArcNode* p2 = new ArcNode; //生成另一个对称的新的边结点
		p2->adjvex = i; //邻接点序号为i
		p2->nextarc = G.vertices[j].fristarc;
		G.vertices[j].fristarc = p2; //将新结点p2插入顶点vj的边表头部
	}
	return true;
}

//在图G中查找顶点u，存在返回顶点表中的下标，否则返回-1
int LocateVex(ALGraph G, string u)
{
	for (int i = 0; i < G.vexnum; i++)
	{
		if (G.vertices[i].data == u)
		{
			return i;
		}
	}
	return -1;
}

//打印
void PrintVex(ALGraph G)
{
	for (int i = 0; i < G.vexnum; i++)
	{
		cout << G.vertices[i].data << ": ";
		while (G.vertices[i].fristarc)
		{
			cout << G.vertices[i].fristarc->adjvex<<" ";
			G.vertices[i].fristarc = G.vertices[i].fristarc->nextarc;
		}
		cout << endl;
	}
}

//无向图邻接表深度优先遍历
void DFS(ALGraph G, int v)
{
	//访问第v个顶点，并置访问标志数组为true
	cout << G.vertices[v].data << " ";
	visited[v] = true;
	ArcNode *p = G.vertices[v].fristarc; //p指向v的边链表的第一个边结点
	while (p)//边结点非空
	{
		int w = p->adjvex;//表示w是v的邻接点
		if (!visited[w]) //如果w为访问，则递归调用DFS
		{
			DFS(G, w);
		}
		p = p->nextarc; //p指向下一边结点
	}
}

//无向图邻接表广度优先遍历
void BFS(ALGraph G, int v)
{
	//访问第v个顶点，并置访问标志数组为true
	cout << G.vertices[v].data << " ";
	visited1[v] = true;
	queue<int>Q; //创建队列Q
	Q.push(v); //v进队
	while (!Q.empty()) //队列非空
	{
		int p = Q.front(); //将队头元素赋给p
		Q.pop(); //删除队顶元素
		ArcNode* arc = G.vertices[p].fristarc; //arc指向p的边链表的第一个边结点
		while (arc) //边结点非空
		{
			if (!visited1[arc->adjvex]) //判断边结点arc中指向顶点的位置是否被访问
			{
				cout << G.vertices[arc->adjvex].data << " ";//输出边结点arc记录位置的顶点值
				visited1[arc->adjvex] = true; //标记为true
				Q.push(arc->adjvex); //边结点arc指向顶点中的位置入队
			}
			arc = arc->nextarc; //arc指向下一边结点
		}
		
	}
}

int main()
{
	ALGraph G;
	CreateUDG(G); //构造无向图邻接表
	cout << "图G的邻接表为：" << endl;
	PrintVex(G); //打印邻接表
	int v = 0;
	cout << "深度优先遍历为：" << endl;
	DFS(G, v);
	cout << endl;
	cout << "广度优先遍历为：" << endl;
	BFS(G, v);
	cout << endl;

	system("pause");
	return 0;
}

Daydreamer_cl
关注
  • 7
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
09-03
主要介绍了C++实现图的邻接矩阵存储和广度、深度优先遍历,实例分析了C++实现图的遍历技巧,非常具有实用价值,需要的朋友可以参考下
邻接表创建无向图（C++、广度优先遍历、路径寻找）
m0_51742786的博客
08-20 2294
无向图
6-2 邻接表存储图的广度优先遍历 （20 分）
葉蕖的博客
11-12 6269
试实现邻接表存储图的广度优先遍历。 函数接口定义： void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) ); 其中LGraph是邻接表存储的图，定义如下： /* 邻接点的定义 */ typedef struct AdjVNode *PtrToAdjVNode; struct AdjVNode{ Vertex AdjV; ...
C++演示无向图的广度遍历和深度遍历
m0_52646742的博客
12-28 3060
一个小白写的~~~~直接上报告和代码 【问题描述】 写程序演示无向图的遍历操作。 【基本要求】 以邻接表为存储结构，用递归算法实现连通无向图的深度优先和广度优先遍历。 借助于堆栈，用非递归算法实现深度优先遍历。 【设计思路】 我的设计思路大致分三步： 第一步生成邻接表： 关于邻接表，我定义了一个简单的结点Node，它包含了自身的值int类型的data，和链接下一个结点的Node*类型的link。 将输入的点直接的联系用邻接表储存，我用函数bool Creat(int line, int po
c++ 由无向图构造邻接表，实现深度优先遍历、广度优先遍历。
ata69104的博客
05-23 2091
/* 首先，根据用户输入的顶点总数和边数，构造无向图，然后以用户输入的顶点 为起始点，进行深度优先、广度优先搜索遍历，并输出遍历的结果。 */ #include <stdlib.h> #include <iostream> #define MVNum 100 //最大的顶点数 using namespace std; /*—...
7-1 图的先深搜索+7-2 图的先广搜索
Funing7的博客
11-10 2041
图的基本搜索算法DFS，BFS实现
数据结构之邻接表及广度优先遍历
C2395850595的博客
06-01 4426
邻接表是图的一种最主要存储结构（相当于图的压缩存储）,用来描述图上的每一个点。图的邻接表存储方法跟树的孩子链表示法相类似，是一种顺序分配和链式分配相结合的存储结构。如这个表头结点所对应的顶点存在相邻顶点，则把相邻顶点依次存放于表头结点所指向的单向链表中。表结点存放的是邻接顶点在数组中的索引。对于无向图来说，使用邻接表进行存储也会出现数据冗余，表头结点A所指链表中存在一个指向C的表结点的同时，表头结点C所指链表也会存在一个指向A的表结点。广度优先搜索遍历类似于树的按层次遍历，对于用邻接表做存储结构的图，从某个
广度优先遍历（邻接表，邻接矩阵）
q322359的博客
10-21 7295
广度优先遍历（邻接表，邻接矩阵）
c/c++ 图, 创建邻接表, 邻接表的深/广度优先遍历
DL猿
10-24 5098
邻接矩阵 深度广度优先遍历
C++数据结构之图的存储结构——邻接矩阵和邻接表实现无向图
m0_56398315的博客
08-15 7852
本文通过两种方式：1.邻接矩阵2.邻接表 构建无向图，其中对邻接表构建无向图有详细的介绍、流程图、和相关代码图示。
C++实现图的邻接表存储和广度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接表存储和广度优先遍历方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6...
C++无向图深度优先和广度优先遍历（编译可运行）.rar
07-12
以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。 注： 1.代码共182行。 2.代码经过多次编译运行，无错误。
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
在本文中，我们使用C++语言来实现无向图的建立、深度优先遍历和广度优先遍历。我们的实现算法主要包括以下几个部分： 1. 无向图的建立 2. 深度优先遍历 3. 广度优先遍历 在建立无向图时，我们使用邻接矩阵来表示图...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
邻接表储存图实现广度优先遍历（C++）
最新发布
qq_74156152的博客
11-11 2578
通过给出的图的顶点和边的信息，构建无向图的邻接表存储结构。在此基础上，从A顶点开始，对无向图进行广度优先遍历，输出遍历序列。（1）从测试数据读入顶点和边信息，建立无向图邻接表存储结构；（2）把构建好的邻接表输入显示；（3）从A顶点开始，编写BFS广度优先遍历算法；（4）输出广度优先遍历序列。
C++算法篇：DFS超详细解析（1）--- 无向图基本概念
Xunlan_博客
10-19 4315
文章目录一、DFS是什么？二、DFS的基本框架三、DFS-tree 一、DFS是什么？     DFS(Depth First Search) ，即 深度优先搜索 ，是一种遍历图的方式，对于下图（设从u开始访问） 若先访问了v点： 则下一步会访问v的子节点w点： 发现无路可走，则回溯回v，再回到u，之后前往x。 总结一下，dfs会在搜索到新点时优先访问以改点为起点的子节点，并在所有子节点访问完成后回溯，可以看出，dfs和递归殊途同归。 相反地，有BFS(Breath First Search)广度优先搜索，
C++构造无向图，邻接矩阵，深度优先遍历，广度优先遍历
qq_44757691的博客
12-14 5960
define MVNum 100 //最大顶点数//定义无向图邻接矩阵{//顶点表//邻接矩阵//图的当前定点数和边数};
【创】C/C++无向图的创建-邻接表表示法& DFS & BFS
ChristinaXinny的博客
05-28 2286
创建一个邻接表表示法表示的无向图 算法如下： 按照输入顺序，依次将顶点存入顶点表中，使每个表头结点的指针域初始化为NULL。 创建邻接表（假设顶点信息唯一） 1 根据输入的一条边的两个顶点u和v，确定u和v在顶点表中的位置i和j 2 分别为u和v生成一个新的边结点pu和pv， 3 将其adjvex域分别赋值为j和i 4 分别将其插入顶点u和v的边链表头部（头插） 5 重复2.1-2.4直至所有边处理完毕 输入要求 输入有三部分组成 第一部分是2个整数n和m，表示图的定点数和边数 第二部分是由空格分割n个
【数据结构C/C++】图操作之邻接矩阵与邻接表的深度优先遍历
热门推荐
Zhangsama1的博客
11-28 1万+
邻接表： 邻接矩阵，也就是使用二维数组用来存放每个顶点与对应边的关系，例如两个顶点存在边，那么就将这个二维数组对应的下标设置为一个非0值。如下图： 无向图情况： 有向图情况： 邻接矩阵是一种不错的图存储结构，但是对于边数使用较少的图，比较浪费存储空间， 比如下面这种情况： 而学习线性表的时候我们都知道顺序存储结构浪费空间，所以引出了链式存储结构来节约空间。 因此，同样的我们可以对弧或边使用链式存储结构来避免空间浪费的问题。 于是我们引出了新的图存储结构，邻接表。
基于邻接表的无向图的广度优先遍历c++代码
05-05
以下是基于邻接表的无向图的广度优先遍历的C代码： ```c #include <stdio.h> #include <stdlib.h> #define MAXV 1000 // 顶点数的最大值 typedef struct node *node_pointer; struct node{ int vertex; // 邻接点在顶点表中的下标 node_pointer next; // 下一个邻接点 }; typedef struct graph *graph_pointer; struct graph{ node_pointer adj_list[MAXV]; int nvertices; // 图中顶点数 }; int visited[MAXV]; void bfs(graph_pointer G, int start){ int queue[MAXV], front = -1, rear = -1; node_pointer ptr; int v; queue[++rear] = start; visited[start] = 1; while(front != rear){ v = queue[++front]; printf("%d ", v); // 访问顶点v // 将顶点v的邻接点加入队列中 for (ptr = G->adj_list[v]; ptr != NULL; ptr = ptr->next){ if(!visited[ptr->vertex]){ queue[++rear] = ptr->vertex; visited[ptr->vertex] = 1; } } } } int main(){ graph_pointer G; int i, j, n, m, v1, v2; printf("输入顶点数和边数："); scanf("%d%d", &n, &m); G = (graph_pointer)malloc(sizeof(struct graph)); G->nvertices = n; // 初始化邻接表 for (i = 1; i <= n; i++){ G->adj_list[i] = NULL; } // 建立邻接表 for (i = 1; i <= m; i++){ printf("输入一条边的两个顶点："); scanf("%d%d", &v1, &v2); node_pointer new_node1 = (node_pointer)malloc(sizeof(struct node)); node_pointer new_node2 = (node_pointer)malloc(sizeof(struct node)); new_node1->vertex = v2; new_node1->next = G->adj_list[v1]; G->adj_list[v1] = new_node1; new_node2->vertex = v1; new_node2->next = G->adj_list[v2]; G->adj_list[v2] = new_node2; } // 广度优先遍历图 printf("广度优先遍历的结果："); for (i = 1; i <= n; i++){ visited[i] = 0; } bfs(G, 1); return 0; } ``` 代码中，我们定义了一个结构体 `graph` 来存储邻接表，其中 `adj_list` 数组存储每个顶点的邻接点链表，`nvertices` 存储图中的顶点数。`node` 结构体用于定义邻接点，其中 `vertex` 存储邻接点在顶点表中的下标，`next` 存储下一个邻接点的指针。我们还定义了一个 `visited` 数组，用于标记每个顶点是否已经遍历过。 在 `main()` 函数中，我们首先从用户输入中读入图的顶点数和边数，然后利用 `malloc()` 动态分配 `graph` 结构体的存储空间。接着，我们初始化邻接表，将每个顶点的邻接点指针初始化为 `NULL`。然后，我们读入每一条边，并且根据边的两个顶点建立邻接表。最后，我们调用 `bfs()` 函数进行广度优先遍历，从顶点 `1` 开始遍历整个图。 `bfs()` 函数中，我们使用 `queue` 数组来存储待遍历的顶点，`front` 和 `rear` 分别指向队列的头和尾。我们首先将起始顶点 `start` 加入队列中，并标记为已访问。然后，我们不断从队列中取出一个顶点 `v`，访问该顶点，并将其邻接点加入队列中（如果邻接点尚未访问过）。这一过程一直持续到队列为空。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值