【数据结构】——图的深度优先搜索和广度优先搜索

最新推荐文章于 2024-04-29 17:23:39 发布
最新推荐文章于 2024-04-29 17:23:39 发布
阅读量5k 收藏 12
点赞数 2
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/atwdy/article/details/119204981
版权

关于邻接矩阵和邻接表

下面都以此图进行遍历：
在这里插入图片描述

1.深度优先搜索

深度优先搜索，Depth First Search，简称DFS。

对于一个连通图，深度优先遍历的过程：

  1. 从图中一个顶点 v v v 出发并访问 v v v 。
  2. 找到刚访问顶点的第一个未被访问的邻接点并访问，并继续以该邻接点作为刚访问过的顶点，重复此步骤直到刚访问过的结点没有未被访问的邻接点为止。
  3. 返回上一个访问过的且还有未被访问邻接点的顶点，继续访问这个顶点的下一个未被访问的邻接点。
  4. 重复2, 3，直到图中所有顶点都被访问。

它的思想是从一个顶点 v v v 开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个结点，然后从另一条路开始走到底，这种尽量往深处走的概念即是深度优先的概念。类似树的先序遍历。

邻接矩阵的深度优先遍历

对上面这个图深度优先遍历的一个顺序为：ABDHECFG。深度优先遍历的顺序不唯一，因为顶点B的第一个邻接点既可以认为是顶点D，也可以认为是顶点E。

java代码：

public class DFS_AM {
	char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
	int[][] matrix = new int[8][8];

	// 创建邻接矩阵
	private void creatMartix() {
		matrix[locate('A')][locate('B')] = matrix[locate('B')][locate('A')] = 1;
		matrix[locate('B')][locate('D')] = matrix[locate('D')][locate('B')] = 1;
		matrix[locate('B')][locate('E')] = matrix[locate('E')][locate('B')] = 1;
		matrix[locate('D')][locate('H')] = matrix[locate('H')][locate('D')] = 1;
		matrix[locate('E')][locate('H')] = matrix[locate('H')][locate('E')] = 1;
		matrix[locate('A')][locate('C')] = matrix[locate('C')][locate('A')] = 1;
		matrix[locate('C')][locate('F')] = matrix[locate('F')][locate('C')] = 1;
		matrix[locate('C')][locate('G')] = matrix[locate('G')][locate('C')] = 1;
		matrix[locate('F')][locate('G')] = matrix[locate('G')][locate('F')] = 1;
	}

	private int locate(char v) {
		int i = 0;
		for (; i < vertex.length; i++) {
			if (v == vertex[i])
				break;
		}
		return i;
	}

	// 顶点访问标记，visited[i]=false表示顶点vertex[i]未被访问，反之表示已经访问过，初始默认值false
	boolean[] visited = new boolean[vertex.length];

	private void dfs(char v) {
		// 访问第一个顶点
		System.out.print(v + " ");
		// 标记该顶点被访问过
		visited[locate(v)] = true;
		for (int j = 0; j < matrix.length; j++) {
			// 找到刚访问顶点的一个未被访问过的邻接点
			if (matrix[locate(v)][j] == 1 && visited[j] == false) {
				// 以该邻接点作为新的顶点递归访问
				dfs(vertex[j]);
			}
		}
	}

	public static void main(String[] args) {
		DFS_AM am = new DFS_AM();
		am.creatMartix();
		am.dfs('A');
	}
}
邻接表的深度优先遍历
public class DFS_AL {
	class VertexNode {
		char verName;
		EdgeNode next;

		public VertexNode(char verName) {
			this.verName = verName;
		}
	}

	class EdgeNode {
		int index;
		EdgeNode next;

		public EdgeNode(int index) {
			this.index = index;
		}
	}

	VertexNode[] vertex = { new VertexNode('A'), 
							new VertexNode('B'), 
							new VertexNode('C'), 
							new VertexNode('D'),
							new VertexNode('E'), 
							new VertexNode('F'), 
							new VertexNode('G'), 
							new VertexNode('H') };

	private int locate(char v) {
		int index = 0;
		for (; index < vertex.length; index++) {
			if (v == vertex[index].verName)
				break;
		}
		return index;
	}

	// 创建邻接表
	private void creatList() {
		vertex[locate('A')].next = new EdgeNode(locate('B'));
		vertex[locate('A')].next.next = new EdgeNode(locate('C'));

		vertex[locate('B')].next = new EdgeNode(locate('A'));
		vertex[locate('B')].next.next = new EdgeNode(locate('D'));
		vertex[locate('B')].next.next.next = new EdgeNode(locate('E'));

		vertex[locate('C')].next = new EdgeNode(locate('A'));
		vertex[locate('C')].next.next = new EdgeNode(locate('F'));
		vertex[locate('C')].next.next.next = new EdgeNode(locate('G'));

		vertex[locate('D')].next = new EdgeNode(locate('B'));
		vertex[locate('D')].next.next = new EdgeNode(locate('H'));

		vertex[locate('E')].next = new EdgeNode(locate('B'));
		vertex[locate('E')].next.next = new EdgeNode(locate('H'));

		vertex[locate('F')].next = new EdgeNode(locate('C'));
		vertex[locate('F')].next.next = new EdgeNode(locate('G'));

		vertex[locate('G')].next = new EdgeNode(locate('C'));
		vertex[locate('G')].next.next = new EdgeNode(locate('F'));

		vertex[locate('H')].next = new EdgeNode(locate('D'));
		vertex[locate('H')].next.next = new EdgeNode(locate('E'));
	}

	boolean[] visited = new boolean[vertex.length];

	private void dfs(char v) {
		// 访问第一个顶点
		System.out.print(v + " ");
		// 标记
		visited[locate(v)] = true;
		// 找到访问顶点的一个邻接点
		EdgeNode node = vertex[locate(v)].next;

		while (node != null) {
			// 如果这个邻接点没有被访问，作为新顶点递归访问
			if (visited[node.index] == false) {
				dfs(vertex[node.index].verName);
			}
			// 遍历作为底层顶点的所有邻接点
			node = node.next;
		}
	}

	public static void main(String[] args) {
		DFS_AL al = new DFS_AL();
		al.creatList();
		al.dfs('A');
	}
}
深度优先遍历的时间复杂度及空间复杂度分析

时间复杂度
遍历图时，对图中的每个顶点最多调用一次dfs方法，某个顶点被标记访问过，就不再从它出发调用。因此遍历图的过程其实是对每个顶点查找其邻接点的过程。对于一个含有 n 个顶点和 e 条边的图：

  • 邻接矩阵因为对每个顶点 v 都要通过遍历一次一维数组 matrix[v][ ]找到它的所有邻接点，对应的时间复杂度 O ( n ) Ο(n) O(n)，所以总的时间复杂度 O ( n 2 ) Ο(n^2) O(n2)。
  • 邻接表因为本身存储的就是有相连关系的邻接点，所以查找所有顶点的邻接点的时间复杂度为 O ( e ) Ο(e) O(e)。又因为对每个顶点都要进行一次查找，所以总的时间复杂度 O ( n + e ) Ο(n+e) O(n+e)。

空间复杂度
都包括标记数组的空间和递归过程中开辟的系统空间栈。

2.广度优先搜索

广度优先搜索，Breadth First Search，简称BFS。

对一个连通图进行广度优先遍历的步骤是：

  1. 从图中的一个顶点 v v v 出发并访问。
  2. 访问顶点 v v v 的所有邻接点。
  3. 按照邻接点的访问顺序访问邻接点的所有邻接点。
  4. 重复步骤3，直到图中所有的顶点都被访问。

可以看出广度优先遍历是从图中的某个顶点出发，以这个顶点为中心由内往外一层一层的完成遍历，类似树的层序遍历。

因为根据算法先被访问的顶点的邻接点也先被访问，所以遍历过程需要借助队列来保存访问过的顶点。

邻接矩阵的广度优先遍历

上图的一个广度优先遍历序列为：ABCDEFGH。广度优先遍历得到的序列也不唯一，因为对一个顶点的所有邻接点进行访问的时候这些邻接点的先后访问顺序可以不同。

import java.util.LinkedList;
import java.util.Queue;

public class BFS_AM {
	char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
	int[][] matrix = new int[8][8];

	// 创建邻接矩阵
	private void creatMartix() {
		matrix[locate('A')][locate('B')] = matrix[locate('B')][locate('A')] = 1;
		matrix[locate('B')][locate('D')] = matrix[locate('D')][locate('B')] = 1;
		matrix[locate('B')][locate('E')] = matrix[locate('E')][locate('B')] = 1;
		matrix[locate('D')][locate('H')] = matrix[locate('H')][locate('D')] = 1;
		matrix[locate('E')][locate('H')] = matrix[locate('H')][locate('E')] = 1;
		matrix[locate('A')][locate('C')] = matrix[locate('C')][locate('A')] = 1;
		matrix[locate('C')][locate('F')] = matrix[locate('F')][locate('C')] = 1;
		matrix[locate('C')][locate('G')] = matrix[locate('G')][locate('C')] = 1;
		matrix[locate('F')][locate('G')] = matrix[locate('G')][locate('F')] = 1;
	}

	private int locate(char v) {
		int i = 0;
		for (; i < vertex.length; i++) {
			if (v == vertex[i])
				break;
		}
		return i;
	}

	boolean[] visited = new boolean[vertex.length];
	// 辅助队列，保存访问过的顶点
	Queue<Character> q = new LinkedList<>();

	private void bfs(char v) {
		// 访问第一个顶点
		System.out.print(v + " ");
		// 访问标记
		visited[locate(v)] = true;
		// 访问过的顶点入队
		q.add(v);
		while(!q.isEmpty()) {
			char c =  q.remove();
			for(int i=0;i<matrix.length;i++) {
				// 访问出队顶点的所有未被访问过的邻接点
				if(matrix[locate(c)][i]==1 && visited[i]==false) {
					System.out.print(vertex[i]+" ");
					visited[i]=true;
					q.add(vertex[i]);
				}
			}
		}
	}

	public static void main(String[] args) {
		BFS_AM am = new BFS_AM();
		am.creatMartix();
		am.bfs('A');
	}
}
邻接表的广度优先遍历
import java.util.LinkedList;
import java.util.Queue;

public class BFS_AL {
	class VertexNode {
		char verName;
		EdgeNode next;

		public VertexNode(char verName) {
			this.verName = verName;
		}
	}

	class EdgeNode {
		int index;
		EdgeNode next;

		public EdgeNode(int index) {
			this.index = index;
		}
	}

	VertexNode[] vertex = { new VertexNode('A'), 
							new VertexNode('B'), 
							new VertexNode('C'), 
							new VertexNode('D'),
							new VertexNode('E'), 
							new VertexNode('F'), 
							new VertexNode('G'), 
							new VertexNode('H') };

	private int locate(char v) {
		int index = 0;
		for (; index < vertex.length; index++) {
			if (v == vertex[index].verName)
				break;
		}
		return index;
	}

	// 创建邻接表
	private void creatList() {
		vertex[locate('A')].next = new EdgeNode(locate('B'));
		vertex[locate('A')].next.next = new EdgeNode(locate('C'));

		vertex[locate('B')].next = new EdgeNode(locate('A'));
		vertex[locate('B')].next.next = new EdgeNode(locate('D'));
		vertex[locate('B')].next.next.next = new EdgeNode(locate('E'));

		vertex[locate('C')].next = new EdgeNode(locate('A'));
		vertex[locate('C')].next.next = new EdgeNode(locate('F'));
		vertex[locate('C')].next.next.next = new EdgeNode(locate('G'));

		vertex[locate('D')].next = new EdgeNode(locate('B'));
		vertex[locate('D')].next.next = new EdgeNode(locate('H'));

		vertex[locate('E')].next = new EdgeNode(locate('B'));
		vertex[locate('E')].next.next = new EdgeNode(locate('H'));

		vertex[locate('F')].next = new EdgeNode(locate('C'));
		vertex[locate('F')].next.next = new EdgeNode(locate('G'));

		vertex[locate('G')].next = new EdgeNode(locate('C'));
		vertex[locate('G')].next.next = new EdgeNode(locate('F'));

		vertex[locate('H')].next = new EdgeNode(locate('D'));
		vertex[locate('H')].next.next = new EdgeNode(locate('E'));
	}

	boolean[] visited = new boolean[vertex.length];
	Queue<Character> q = new LinkedList<>();

	private void bfs(char v) {
		// 访问第一个顶点
		System.out.print(v + " ");
		// 访问标记
		visited[locate(v)] = true;
		q.add(v);
		while (!q.isEmpty()) {
			char c = q.remove();
			// 找到访问顶点的第一个邻接点
			EdgeNode node = vertex[locate(c)].next;
			while (node != null) {
				// 邻接点存在访问并修改访问标记，并且将访问过的邻接点入队
				if (visited[node.index] == false) {
					System.out.print(vertex[node.index].verName + " ");
					visited[locate(vertex[node.index].verName)] = true;
					q.add(vertex[node.index].verName);
				}
				// 寻找访问顶点的下一个邻接点
				node = node.next;
			}
		}
	}

	public static void main(String[] args) {
		BFS_AL al = new BFS_AL();
		al.creatList();
		al.bfs('A');
	}
}
广度优先遍历的时间复杂度及空间复杂度分析

时间复杂度
广度优先遍历每个顶点最多进入一次队列，与深度优先的区别仅是对不同顶点邻接点的访问顺序不同，所以广度优先的时间复杂度与深度优先相等。

  • 对于邻接矩阵，广度优先的时间复杂度 O ( n 2 ) Ο(n^2) O(n2)。
  • 对于邻接表，广度优先的时间复杂度 O ( n + e ) Ο(n+e) O(n+e)。

空间复杂度
与深度优先相比少用了递归时占用的系统空间栈，多了一个辅助队列。

算法与数据结构【30天】集训营——图的遍历之深度优先搜索、广度优先搜索（28）
迷茫与徘徊只会让你陷入绝境，欢迎私信博主，带你开始提升变现价值！
11-20 814
总而言之，深度搜索我们可以理解为栈操作，广度搜索我们可以理解为队列操作。
【数据结构】图的遍历（深度优先搜索、广度优先搜索）及简单路径问题（C语言）
热门推荐
weixin_51450101的博客
02-17 1万+
图的遍历就是从图中的某个顶点出发，按某种方法对图中所有顶点访问且仅访问一次。图的遍历算法是求解图的连通性问题、拓扑排序和关键路径等算法的基础。 对于图的遍历，通常有两种方法，即深度优先搜索和广度优先搜索。这两种遍历方法对于无向图和有向图均适用。图的深度优先搜索和广度优先搜索结果均不唯一。
数据结构知识整理 - 遍历图 - 深度优先搜索
春雪阁
11-27 391
主要内容 深度优先搜索 以邻接矩阵为存储结构的深度优先搜索遍历 以邻接表为存储结构的深度优先搜索遍历   图的遍历算法是实现图的其他算法的基础，图的遍历方式有两种：深度优先搜索遍历和广度优先搜索遍历。 深度优先搜索遍历类似于树的先序遍历（根节点→左子树→右子树），借助了栈结构以实现递归；广度优先搜索遍历则类似于层次遍历，借助于队列结构实现。 因为图的任意两个顶点都有可能存在联系，所以在...
图的遍历之 深度优先搜索和广度优先搜索
Code-lover's Learning Notes
08-18 2958
深度优先搜索的图文介绍1. 深度优先搜索介绍图的深度优先搜索(Depth First Search)，和树的先序遍历比较类似。它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所
深度优先搜索和广度优先搜索（数据结构）
ker的博客
02-19 3221
图的两种遍历方式基本概念深度优先搜索邻接矩阵表示图的深度优先搜索遍历广度优先搜索 基本概念 图的遍历定义： 从已给的连通图中某一顶点出发，沿着一些边访遍图中所有的顶点，且使每个顶点仅被访问一次，就叫做图的遍历，它是图的基本运算。 遍历实质：找每个顶点的邻接点的过程。 图的特点: 图中可能存在回路，且图的任一顶点都可能与其它顶点想通，在访问完某个顶点之后可能会沿着某些边又回到了曾经访问过的顶点...
图的深度优先搜索和广度优先搜索
LIMao_link
08-20 184
图的深度优先和广度优先 图的深度优先搜索(Depth First Search): 深度优先遍历,从初始访问的结点出发,初始访问的结点可能有多个邻接点,深度优先的策略就是首先访问第一个邻接节点,然后再以这个被访问邻接节点作为初始的节点,访问他的第一个邻接结点,可以这样子理解,每次在访问完当前节点后,首先访问当前节点的第一个邻接结点 我们可以看到,这样的访问策略是优先往纵向挖掘深入,而不是对一个邻接结点的所有 邻接结点进行访问, 很显然,这是一个递归的过程 设计的基本思路: 初始访问结点v,并结点v已经
【C 数据结构-图】3. 深度优先搜索、广度优先搜索
最新发布
普罗米修斯的博客
04-29 1912
文章目录【 1. DFS 深度优先搜索 】1.1 基本原理1.2 C 实现【 2. BFS 广度优先搜索 】2.1 基本原理2.2 C 实现 对存储的图中的顶点进行遍历搜索，常用的遍历方式有两种：深度优先搜索和广度优先搜索。 【 1. DFS 深度优先搜索 】 1.1 基本原理 深度优先搜索的过程 类似于树的先序遍历，首先从例子中体会深度优先搜索。例如下图是一个无向图，采用深度优先算法遍历这个图的过程为： 首先任意找一个未被遍历过的顶点，例如从 V1 开始，由于 V1 率先访问过了，所以，需要标记
数据结构与算法——图的深度优先和广度优先遍历 实验报告及代码
weixin_45791919的博客
09-13 919
(1)建立邻接矩阵表示的图 (2)实现邻接矩阵表示的图的深度优先遍历、广度优先遍历
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
在压缩包文件"数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历_1602077415"中，包含了关于这些主题的详细资料，可能包括理论解释、代码示例和练习题，帮助读者深入理解和掌握图的存储...
[数据结构]图的深度优先搜索（DFS）和广度优先搜索（BFS）（通俗易懂）
IT博客-wusheng_z
04-15 626
一、深度优先搜索（DFS，Depth First Search） 深度优先搜索的主要思想：首先从一个未走过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点；当没有被访问过的顶点时，则回到上一个顶点，继续访问别的未被访问过的顶点，直到所有的顶点都被访问过。（不撞南墙不回头） DFS遍历图解过程如下： 1、DFS邻接矩阵核心代码实现（可以链表实现，以下是数组实现）： bool boo...
数据结构与算法--图的深度优先搜索 (DFS)
李嘉图呀李嘉图的博客
04-02 4297
深度优先搜索即是 从起点出发，从规定的方向中选择一个不断往前走，走到头为止，然后尝试另一种方向直到最后的终点。 DFS解决的是连通性问题，即从A是否能到达B。采用DFS进行遍历的话，必须依赖栈，后进先出。 假设有一个图，里面有A、B、C、D、E、F、G、H 8 个顶点，对这个图进行深度优先的遍历 第一步选择一个起始顶点，例如从顶点 A 开始。把 A 压入栈，标记它为访问过（用红色标记），并输出到结果中。 第二步 寻找与 A 相连并且还没有被...
图的深度优先遍历算法
weixin_34370347的博客
12-22 935
前言 图的遍历与前面文章中的二叉树遍历还是存在很大区别的。所谓图的遍历指的是从图中的某一个顶点出发访问图中的其余顶点，并且需要保证每个顶点只被访问一次。由于图比二叉树复杂得多，所以前面二叉树的遍历算法在图中是行不通的。因为对于任意一个顶点来讲，都可能与其余的顶点发生连接。如果不对访问的顶点做一些处理，出发重复访问的几率是很高的。因此，...
图的搜索---深度优先搜索和广度优先搜索
鱼儿往上游的博客
07-12 548
确定从一个顶点能到达哪些顶点是在图上经常执行的一种操作。人们可能需要知道在地图上哪些路可以从一个 城镇到达其他城镇，或者从一个机场到其他机场可以走哪条航线。 在图上执行这些操作都用到了查找算法。图上可以执行两种基础查找：深度优先（depth-first）搜索和广度优先 （breadth-first）搜索。本小节会研究这两种算法
数据结构之图
The_yja_of_Oier的博客
07-11 849
定义 图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系。 用法 ...
【经典算法】图的深度优先搜索和广度优先搜索
wenqian 'blog
07-23 1万+
前面学习了图的邻接表存储，
【图】图的深度搜索和广度搜索
weixin_42596089的博客
05-24 3759
具体来说，BFS会先访问起始顶点，然后依次访问与起始顶点直接相邻的所有顶点，接着访问与这些顶点直接相邻的未被访问过的顶点，以此类推，直到找到目标顶点或者遍历完整张图。图的深度优先遍历（Depth First Search，DFS）是一种遍历图的算法，其基本思想是从起始顶点开始，不断访问邻接顶点，直到无法继续访问为止，然后回溯到之前的顶点，继续访问其未被访问过的邻接顶点。在实现过程中，可以使用栈来存储待访问的顶点，每次访问一个顶点时，将其所有未被访问过的邻接顶点压入栈中，然后从栈中弹出一个顶点进行访问。
数据结构—图的深度优先搜索
Miss Z的博客
09-12 1938
图的遍历
图的遍历---深度优先搜索+广度优先搜索
weixin_52847003的博客
11-25 871
图的遍历
AI数据结构与算法——深度优先搜索与广度优先搜索
04-27
深度优先搜索（Depth-First Search，DFS）和广度优先搜索（Breadth-First Search，BFS）都是图搜索算法，用于遍历或搜索图中的节点。 DFS是一种递归算法，从起始节点开始，依次遍历所有相邻的节点，直到找到目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值