图的遍历 c++

最新推荐文章于 2024-08-03 13:29:25 发布
最新推荐文章于 2024-08-03 13:29:25 发布
阅读量676 收藏
点赞数 8
分类专栏： 数据结构和算法 文章标签： c++ 广度优先 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74311500/article/details/134621622
版权

一、任务目标

以邻接表为存储结构，实现连通有向图的深度优先和广度优先遍历两个遍历算法。以输入的第一个结点为起点开始遍历。

二、思路分析和代码展示

1.创建图相应的存储结构

邻接表的存储形式如下：
在这里插入图片描述
AdjList：数据域存放的是依次输入的顶点名称，此处为字符类型，指针域存放该顶点邻接的第一个顶点（按照输入顺序）的地址（即下一个结点的地址）。
ArcNode：数据域存放的是相应AdjList顶点所邻接的顶点在AdjList数组中对应的下标，指针域存放的则是下一个邻接顶点的地址

struct ArcNode {
	int adjVex; // 顶点下标
	ArcNode * nextArc; // 指针域 
}; 

typedef struct {
	char vex; // 顶点名 
	ArcNode * firstArc; // 第一条边 
}AdjList[MVNum];

struct ALGraph {
	AdjList vexs; // 顶点数组 
	int vexNum, arcNum; // 顶点总数 和 边总数 
};

此处用邻接表描述图包括了三个部分：顶点数组、顶点总数、边总数

2.创建邻接表

// 创建邻接表 
void CreateAL(ALGraph &G, char a, char b) {
	for(int i = 0; i < G.vexNum; i++) {
		if(G.vexs[i].vex == a) {
			for(int j = 0; j < G.vexNum; j++) {
				if(G.vexs[j].vex == b) {
					// 创建新结点 
					ArcNode * temp = new ArcNode;
					temp->adjVex = j;
					temp->nextArc = NULL;
					// 遍历对应链表 
					ArcNode * p = G.vexs[i].firstArc;
					if(p != NULL) {
						while(p->nextArc != NULL) {
							p = p->nextArc;
						}
						p->nextArc = temp;
					} else {
						G.vexs[i].firstArc = temp;  
					}
				}
			}
		}
	}
}

以上代码目的在于通过输入一条边的两个顶点，实现每个顶点和其邻接点之间的连接：
因为是有向图，所以通过第一个输入的顶点a确定其在AdjList中的位置，再确定第二个输入的顶点b在AdjList中的下标，填充创建的新结点的数据域。
在以上过程中设置一个遍历指针p，用于寻找到a所对应的链表的尾部，实现新结点的尾插。

3.生成有向图

// 生成有向图
void CreateUDN(ALGraph &G) {
	cout<<"请输入顶点个数：";
	cin>>G.vexNum;
	cout<<"请输入顶点名称：";
	char c;
	for(int i = 0; i < G.vexNum; i++) {
		cin>>c;
		G.vexs[i].vex = c; 
		G.vexs[i].firstArc = NULL;
	}
	cout<<"请输入边数：";
	cin>>G.arcNum;
	cout<<"请输入边："<<endl;
	char v1, v2;
	for(int i = 0; i < G.arcNum; i++) {
		cin>>v1>>v2;
		CreateAL(G, v1, v2);
	}
}

4.打印邻接表

// 打印邻接表 
void PrintAL(ALGraph G) {
	for(int i = 0; i < G.vexNum; i++) {
		ArcNode * temp = G.vexs[i].firstArc;
		cout<<G.vexs[i].vex;
		while(temp != NULL) {
			cout<<"-->"<<temp->adjVex;
			temp = temp->nextArc;
		}
		cout<<endl;
	}
}

生成图后，打印相应的邻接表用于检验

5.遍历图

在这里插入图片描述
例图情况下的深度优先和广度优先遍历结果如上

5.1 深度优先遍历图
// 深度优先
void DFS(ALGraph G, int i, bool visited[]) {
	ArcNode * p;
	// 访问顶点
	cout<<G.vexs[i].vex<<" ";
	visited[i] = true; // 标记为已访问
	for(p = G.vexs[i].firstArc; p != NULL; p = p->nextArc) {
		if(!visited[p->adjVex]) { // 如果没被访问过 
			DFS(G, p->adjVex, visited); // 递归 来到AdjList再次开始
		}
	}	 
} 

// 深度优先遍历有向图
void DFSTraverse(ALGraph G, bool visited[]) {
	// 初始化全部顶点的访问情况 使用数组 
	for(int i = 0; i < G.vexNum; i++) {
		visited[i] = false;
	}
	for(int i = 0; i < G.vexNum; i++) { // 防止有连通分量 非连通图 
		if(!visited[i]) {
			// 如果顶点未被访问 则从该顶点开始遍历（说明属于一个连通分量）
			DFS(G, i, visited); 
		}
	}
}
5.2 广度优先遍历图

使用广度优先遍历图，需要用到队列。利用其可以弹出队头的特性，在同一层顶点被访问完后开启下一层的访问。

// 队列存储结构 
struct QueueNode {
	int adjVex;
	QueueNode * next;
};

// 队列 
struct Queue {
	QueueNode * head;
	QueueNode * tail;
};

// 初始化队列
void InitQueue(Queue* &Q) {  
	Q->head = NULL;
	Q->tail = NULL;
} 

// 向队列中插入元素 （插入在队尾） 
void QueuePush(Queue* &Q, int x) {
	// 创建新结点 
	QueueNode * temp = new QueueNode;
	temp->adjVex = x;
	temp->next = NULL;
	if(Q->head == NULL) {
		Q->head = Q->tail = temp; // 队列为空时 头尾指针共同指向第一个放入的结点 
	} else {
		Q->tail->next = temp;
		Q->tail = Q->tail->next; // tail后移 
	}
} 

// 弹出队头元素
int QueuePopHead(Queue* &Q) {
	int head = Q->head->adjVex;
	QueueNode * temp = Q->head;
	Q->head = Q->head->next; // head后移
	delete temp; // 清除该空间 
	return head;
}

// 广度优先
void BFS(ALGraph G, int i, bool visited[], Queue*& Q) {
    ArcNode * p = G.vexs[i].firstArc;
    cout<<G.vexs[i].vex<<" ";
    visited[i] = true; // 标记为已访问
    QueuePush(Q, i);   // 将对应下标放入队列中
    while (Q->head != NULL) { // 如果队列非空
        int head = QueuePopHead(Q); // 取出队头元素
        p = G.vexs[head].firstArc;
        while (p != NULL) { // 用于遍历每个AdjList中元素对应的链表
            if (!visited[p->adjVex]) {
                cout<<G.vexs[p->adjVex].vex<<" ";
                visited[p->adjVex] = true; // 标记为访问 但是不弹出
                QueuePush(Q, p->adjVex);
            }
            p = p->nextArc; // p后移
        }
    }
}

// 广度优先遍历有向图
void BFSTraverse(ALGraph G, bool visited[]) {
    // 初始化全部顶点的访问情况 使用数组
    for (int i = 0; i < G.vexNum; i++) {
        visited[i] = false;
    }
    for (int i = 0; i < G.vexNum; i++) {
        if (!visited[i]) {
            // 如果顶点未被访问 则从该顶点开始遍历（说明属于一个连通分量）
            Queue * Q = new Queue; // 创建队列
            InitQueue(Q); // 初始化队列
            BFS(G, i, visited, Q);
        }
    }
}

以另一简单例子解析以上代码实现的流程如下：
在这里插入图片描述

6.完整代码

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

struct ArcNode {
	int adjVex; // 顶点下标
	ArcNode * nextArc; // 指针域 
}; 

typedef struct {
	char vex; // 顶点名 
	ArcNode * firstArc; // 第一条边 
}AdjList[MVNum];

struct ALGraph {
	AdjList vexs; // 顶点数组 
	int vexNum, arcNum; // 顶点总数 和 边总数 
};

// 队列存储结构 
struct QueueNode {
	int adjVex;
	QueueNode * next;
};

// 队列 
struct Queue {
	QueueNode * head;
	QueueNode * tail;
};

// 初始化队列
void InitQueue(Queue* &Q) { 
	Q->head = NULL;
	Q->tail = NULL;
} 

// 向队列中插入元素 （插入在队尾） 
void QueuePush(Queue* &Q, int x) {
	// 创建新结点 
	QueueNode * temp = new QueueNode;
	temp->adjVex = x;
	temp->next = NULL;
	if(Q->head == NULL) {
		Q->head = Q->tail = temp; // 队列为空时 头尾指针共同指向第一个放入的结点 
	} else {
		Q->tail->next = temp;
		Q->tail = Q->tail->next; // tail后移 
	}
} 

// 弹出队头元素
int QueuePopHead(Queue* &Q) {
	int head = Q->head->adjVex;
	QueueNode * temp = Q->head;
	Q->head = Q->head->next; // head后移
	delete temp; // 清除该空间 
	return head;
}

// 创建邻接表 
void CreateAL(ALGraph &G, char a, char b) {
	for(int i = 0; i < G.vexNum; i++) {
		if(G.vexs[i].vex == a) {
			for(int j = 0; j < G.vexNum; j++) {
				if(G.vexs[j].vex == b) {
					// 创建新结点 
					ArcNode * temp = new ArcNode;
					temp->adjVex = j;
					temp->nextArc = NULL;
					// 遍历对应链表 
					ArcNode * p = G.vexs[i].firstArc;
					if(p != NULL) {
						while(p->nextArc != NULL) {
							p = p->nextArc;
						}
						p->nextArc = temp;
					} else {
						G.vexs[i].firstArc = temp; 
					}
				}
			}
		}
	}
} 

// 生成有向图
void CreateUDN(ALGraph &G) {
	cout<<"请输入顶点个数：";
	cin>>G.vexNum;
	cout<<"请输入顶点名称：";
	char c;
	for(int i = 0; i < G.vexNum; i++) {
		cin>>c;
		G.vexs[i].vex = c; 
		G.vexs[i].firstArc = NULL;
	}
	cout<<"请输入边数：";
	cin>>G.arcNum;
	cout<<"请输入边："<<endl;
	char v1, v2;
	for(int i = 0; i < G.arcNum; i++) {
		cin>>v1>>v2;
		CreateAL(G, v1, v2);
	}
}  

// 打印邻接表 
void PrintAL(ALGraph G) {
	for(int i = 0; i < G.vexNum; i++) {
		ArcNode * temp = G.vexs[i].firstArc;
		cout<<G.vexs[i].vex;
		while(temp != NULL) {
			cout<<"-->"<<temp->adjVex;
			temp = temp->nextArc;
		}
		cout<<endl;
	}
}


// 深度优先
void DFS(ALGraph G, int i, bool visited[]) {
	ArcNode * p;
	// 访问顶点
	cout<<G.vexs[i].vex<<" ";
	visited[i] = true; // 标记为已访问
	for(p = G.vexs[i].firstArc; p != NULL; p = p->nextArc) {
		if(!visited[p->adjVex]) { // 如果没被访问过 
			DFS(G, p->adjVex, visited); // 递归 
		}
	}	 
} 

// 深度优先遍历有向图
void DFSTraverse(ALGraph G, bool visited[]) {
	// 初始化全部顶点的访问情况 使用数组 
	for(int i = 0; i < G.vexNum; i++) {
		visited[i] = false;
	}
	for(int i = 0; i < G.vexNum; i++) { // 防止有连通分量 非连通图 
		if(!visited[i]) {
			// 如果顶点未被访问 则从该顶点开始遍历（说明属于一个连通分量）
			DFS(G, i, visited); 
		}
	}
} 

// 广度优先
void BFS(ALGraph G, int i, bool visited[], Queue*& Q) {
    ArcNode * p = G.vexs[i].firstArc;
    cout<<G.vexs[i].vex<<" ";
    visited[i] = true; // 标记为已访问
    QueuePush(Q, i);   // 将对应下标放入队列中
    while (Q->head != NULL) {
        int head = QueuePopHead(Q);
        p = G.vexs[head].firstArc;
        while (p != NULL) {
            if (!visited[p->adjVex]) {
                cout<<G.vexs[p->adjVex].vex<<" ";
                visited[p->adjVex] = true;
                QueuePush(Q, p->adjVex);
            }
            p = p->nextArc; // p后移
        }
    }
}

// 广度优先遍历有向图
void BFSTraverse(ALGraph G, bool visited[]) {
    // 初始化全部顶点的访问情况 使用数组
    for (int i = 0; i < G.vexNum; i++) {
        visited[i] = false;
    }
    for (int i = 0; i < G.vexNum; i++) {
        if (!visited[i]) {
            // 如果顶点未被访问 则从该顶点开始遍历（说明属于一个连通分量）
            Queue * Q = new Queue; // 创建队列
            InitQueue(Q); // 初始化队列
            BFS(G, i, visited, Q);
        }
    }
}

int main() {
	ALGraph G;
	CreateUDN(G);
	cout<<"打印邻接表："<<endl;
	PrintAL(G);
	bool visited[G.vexNum];
	cout<<"深度优先遍历有向图："<<endl; 
	DFSTraverse(G, visited);
	cout<<endl;
	cout<<"广度优先遍历有向图："<<endl;
	BFSTraverse(G, visited);
	return 0;
}

三、运行结果

1、
在这里插入图片描述
验证该例结果如下：
在这里插入图片描述
2、
在这里插入图片描述
验证该例结果如下：
在这里插入图片描述

imp.ytz
关注
专栏目录
二叉树的遍历 C++
yhz_xi的博客
07-21 1030
二叉树的遍历包括前序遍历、中序遍历、后序遍历三种基本方式， 二叉树的遍历概念代码递归遍历1. 先序遍历2. 中序遍历3. 后序遍历非递归遍历1. 先序遍历2. 中序遍历3. 后序遍历 概念 二叉树的遍历: 是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。 遍历规则： 先序遍历： 优先输出根节点，而后遍历左子树，最后右子树； 中序遍历： 首先遍历左子树，而后访问根节点，再遍历右子树； 后序遍历：先后序遍历右子树，而后左子树，最后访问根节点。 性质： 已知前序遍历
c++二叉树遍历
clayhell的博客
09-02 1707
非递归实现。
C++数据结构：图
weixin_43908419的博客
11-28 1482
本文介绍了图这种数据结构
图的遍历（c++代码）
10-29
图的遍历，根据矩阵输出该图深度和广度的遍历结果。
图的遍历C++（DFS+BFS）
最新发布
Sunnyside_______的博客
08-03 466
使用这两种方法之一，您可以遍历图中的所有节点，并根据需求执行特定的操作。请注意，这些示例代码仅表示了图的遍历方法，您可以根据实际需求进行修改和扩展。在C++中，可以使用多种方法对图进行遍历，其中最常见的方法是深度优先搜索（DFS）和广度优先搜索（BFS）。
C++ 图的遍历
cat_fish_rain的博客
07-03 1311
。请思考树以前是怎么遍历的，此处可以直接用来遍历图吗？为什么？问题：如何防止节点被重复遍历。
C++实现图的遍历！！！
08-25
1）创建一个图； 2）图的深度优先遍历的递归算法； 3）图的深度优先遍历的迭代算法； 4）图的广度优先遍历算法。
C++实现图的遍历
01-08
C++实现的图，可以对图进行深度优先和广度优先搜索
c++数据结构：图的遍历
qq_45303986的博客
10-21 2139
设图中的所有顶点都未被访问，则深度优先遍历搜索可从图中的某个顶点P出发，访问该顶点，然后依次从v的未访问的邻接点出发深度优先遍历图，直到所有和P有路径相通的节点都被访问。邻接矩阵的深度优先遍历的时间复杂度：O（n^2）邻接表的深度优先遍历的时间复杂度：O（n+e）
满二叉树的前序遍历C++实现
06-05
因此，满二叉树的前序遍历、中序遍历和后序遍历均可以通过递归方式实现。 以前序遍历为例，满二叉树的前序遍历顺序为：根、左、右。 在具体实现过程中，我们可以通过构造一个满二叉树，然后进行前序遍历来获取遍历...
数据结构 图的遍历 C++实现.pdf
05-20
《数据结构：图的遍历 C++实现》 在计算机科学中，数据结构是组织和管理数据的重要方式，而图是一种复杂的数据结构，用于表示对象之间的关系。本实验报告主要探讨了图的邻接表存储结构及其在C++中的遍历算法实现，...
c++程序图的遍历（深度优先，广度优先）
09-25
非常好十分经典的c++程序遍历结构，有深度优先和广度优先搜索，希望能帮助各位，
C++图的遍历
05-30
大二时写的一个课程设计，进行图的遍历，输出最近节点等
C++模板实现的图的遍历算法
08-11
基于C++模板，用邻接矩阵的方式，实现了基本的Graph(map)的构建，并实现了深度优先搜索和广度优先搜索，同时加入了测试用的数据读入和写入函数，便于调试和在本代码基础上进行进一步扩充。
数据结构|图的构建及遍历 c++
yanyanyanzi111的博客
09-15 2322
邻接矩阵（数组）和临接表（链表）邻接矩阵：dfs 深度搜索：按照一条路一直走到头再找另一条路（），构造辅助数组visited[]；递归算法邻接表：bfs 广度搜索：看到分叉口就搜索，像二叉树的非递归算法层搜索一样，使用队列，构造辅助数组visited[]；图一 邻接矩阵图二 邻接表图三 邻接表说明。
图的遍历 C++
若风
11-22 961
#include #include using namespace std; const int MaxSize = 5; template class MGraph { public: MGraph(T a[], int b[][MaxSize],int n,int e); //构造函数，建立具有n个顶点e条边的图 void dfsTraverse(int v); //深度优先遍
算法：C++实现图的遍历
Viko0422的博客
11-04 5511
目录 图的遍历 深度优先搜索法 广度优先搜索法 代码及注释部分 图的遍历，属于数据结构中的内容。指的是从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。图的遍历操作和树的遍历操作功能相似。图的遍历是图的一种基本操作，图的许多其它操作都是建立在遍历操作的基础之上。 由于图结构本身的复杂性，所以图的遍历操作也较复杂，主要表现在以下四个方面： ① 在图结构中，没有一个“自然”的首结点，图中任意一个顶点都可作为第一个被访问的结点。 ② 在非连通图中，从一个顶点出发，只能够访问它...
图的遍历（C++）
m0_51427295的博客
08-30 281
图的遍历 题目 AC代码 #include<iostream> #include<vector> using namespace std; int A[100100]; vector<int> G[100100]; void fds(int a,int b) { if(A[a]) return; A[a]=b; for(int i=0;i<G[a].size();i++) { fds(G[a][i],b); } } int main() { in
C++实现图 - 02 图的遍历（DFS、BFS）
Newin2020的博客
06-03 2889
数据结构与算法专栏 —— C++实现深度优先搜索 ，简称为 DFS 。事实上，我们在树的遍历中早已涉及 DFS ，层、前序遍历、中序遍历和后序遍历都属于深度优先遍历的方式，因为这些遍历方式本质上都归结于栈。为了方便大家理解，我们还是以画图的方式来呈现（我们从结点 1 开始遍历）： 1、从结点 1 的第一个相邻结点即结点 2 开始遍历，先遍历哪个点一般取决于存储边的时候是以什么方式进行。 2、以相同的方式继续沿结点的第一个相邻结点即结点 2 遍历，就这样一直往前递归遍历直至无法继续向前。 3、同上，往结
遍历c++ list
10-19
遍历C++ list可以使用迭代器来实现。迭代器是一种类似于指针的对象，可以用来遍历容器中的元素。对于单纯的list<>类型，可以使用list<int>::iterator来定义迭代器，然后使用begin()和end()函数来获取list的起始和结束位置，使用迭代器来遍历list中的元素。对于嵌套类型的list<list<>>，需要定义两个迭代器，一个用于遍历外层list，另一个用于遍历内层list。具体实现可以参考上面提供的代码示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值