图的遍历-----深度优先遍历（dfs）,广度优先遍历（bfs）【java详解】

简单介绍：什么是深度、广度优先遍历？

深度优先搜索（DFS，Depth First Search）：

大致图解：

广度优先搜索（BFS，Breadth First Search）：

大致图解：

一.图的创建（邻接矩阵）

图的创建完整代码：

运行结果：

二.图的深度优先遍历（DFS）:

遍历思想：

算法步骤：

访问初始结点v：

查找结点v的第一个邻接结点w：

深度搜索算法：

编辑

三.图的广度优先遍历（BFS）:

广度优先算法：

深度优先遍历 && 广度优先遍历的区别：

测试用例：

小结：

简单介绍：什么是深度、广度优先遍历？

图的遍历是指，从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历。遍历过程中得到的顶点序列称为图遍历序列。

图的遍历过程中，根据搜索方法的不同，又可以划分为两种搜索策略：

深度优先搜索（DFS，Depth First Search）
广度优先搜索（BFS，Breadth First Search）

深度优先搜索（DFS，Depth First Search）：

遍历思想：：首先从图中某个顶点v0出发，访问此顶点，标记已访问的顶点，然后依次从v0相邻的顶点出发深度优先遍历，直至图中所有与v路径相通的顶点都被访问了；若此时尚有顶点未被访问，则从中选一个顶点作为起始点，重复上述过程，直到所有的顶点都被访问。

大致图解：

广度优先搜索（BFS，Breadth First Search）：

遍历思想：首先，从图的某个顶点v0出发，访问了v0之后，依次访问与v0相邻的未被访问的顶点，然后分别从这些顶点出发，广度优先遍历，直至所有的顶点都被访问完。

大致图解：

一.图的创建（邻接矩阵）

图的遍历基础是我们首先得有个图，这里我们创建一个图，用邻接矩阵的方法。这里我们创建一个如下图所示的图（左边是图，右边是图所对应的表示方法）：

图的创建完整代码：

import java.util.*;
public class Graph {private ArrayList<String> vertexList;//一个一维数组用于存储顶点的信息private int[][] edges;//一个二维数组用于存储对应边的信息private int numOfEdges;//记录边的个数private boolean[] isVisited;//判断顶点是否被访问//测试public static void main(String[] args){String vertexs[] = {"A","B","C","D","E"};Graph graph = new Graph(5);for(String vertex : vertexs){graph.insertVertex(vertex);}//插入的节点展示：System.out.println("插入的节点展示：");for(String vertex : vertexs){System.out.print(vertex+" ");}System.out.println();                 //  A B C D Egraph.insertEdge(0,1,1);              //A 0 1 1 0 0graph.insertEdge(0,2,1);              //B 1 0 1 1 1graph.insertEdge(1,2,1);              //C 1 1 0 0 0graph.insertEdge(1,3,1);              //D 0 1 0 0 0graph.insertEdge(1,4,1);              //E 0 1 0 0 0//创建的图展示：System.out.println("创建的图展示：");graph.showGraph();//边个数System.out.println("边个数:"+graph.numOfEdges);}//构造器public Graph(int n){vertexList = new ArrayList<String>(n);edges = new int[n][n];numOfEdges = 0;}//图的创建和展示--》方法//展示图public void showGraph(){for(int[] link : edges){System.out.println(Arrays.toString(link));}}//插入顶点public void insertVertex(String vertex){vertexList.add(vertex);}//插入边public void insertEdge(int v1,int v2,int weight){edges[v1][v2] = 1;edges[v2][v1] = 1;numOfEdges++;}
//图的常见方法//得到顶点个数public int getNumOfVertex(){return vertexList.size();}//通过索引得到对应的顶点public String gerValueByIndex(int i){return vertexList.get(i);}//得到对应边的权重public int getWeight(int v1,int v2){return edges[v1][v2];}
}

运行结果：

二.图的深度优先遍历（DFS）:

遍历思想：

深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点，可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
显然，深度优先搜索是一个递归的过程

算法步骤：

访问初始结点v，并标记结点v为已访问。
查找结点v的第一个邻接结点w。
若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。
若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
查找结点v的w邻接结点的下一个邻接结点，转到步骤3。

还是以上面创建的图为例：

访问初始结点v：

//1.得到第一个邻接点的下标public int getFirstNeifhbor(int index){for(int j = 0;j < vertexList.size();j++){if(edges[index][j] > 0){return j;}}return -1;}

查找结点v的第一个邻接结点w：

//2.根据前一个邻接点的下标获取下一个邻接点public int getNextNeighbor(int v1,int v2){for(int j = v2 + 1;j < vertexList.size();j++){if(edges[v1][j] > 0){return j;}}return -1;}

深度搜索算法：

//深搜遍历算法//first stepprivate void dfs(boolean[] isVisited,int i){System.out.print(getValueByIndex(i)+"->");isVisited[i] = true;int w = getFirstNeifhbor(i);while(w != -1){if(!isVisited[w]){dfs(isVisited,w);}w = getNextNeighbor(i,w);}}
//second steppublic void dfs(){isVisited = new boolean[vertexList.size()];for(int i = 0;i < vertexList.size();i++){if(!isVisited[i]){dfs(isVisited,i);}}}

遍历结果：

三.图的广度优先遍历（BFS）:

基本思想：

图的广度优先搜索(Broad First Search) 。类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

算法步骤：

访问初始结点v并标记结点v为已访问。
结点v入队列
当队列非空时，继续执行，否则算法结束。
出队列，取得队头结点u。
查找结点u的第一个邻接结点w。
若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤： 6.1若结点w尚未被访问，则访问结点w并标记为已访问。 6.2 结点w入队列 6.3查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

广度优先算法：

//对一个结点进行广度优先遍历的方法
private void bfs(boolean[] isVisited, int i) {int u ; // 表示队列的头结点对应下标int w ; // 邻接结点w//队列，记录结点访问的顺序LinkedList queue = new LinkedList();//访问结点，输出结点信息System.out.print(getValueByIndex(i) + "=>");//标记为已访问isVisited[i] = true;//将结点加入队列queue.addLast(i);while( !queue.isEmpty()) {//取出队列的头结点下标u = (Integer)queue.removeFirst();//得到第一个邻接结点的下标 w w = getFirstNeighbor(u);while(w != -1) {//找到//是否访问过if(!isVisited[w]) {System.out.print(getValueByIndex(w) + "=>");//标记已经访问isVisited[w] = true;//入队queue.addLast(w);}//以u为前驱点，找w后面的下一个邻结点w = getNextNeighbor(u, w); //体现出我们的广度优先}}} 
//遍历所有的结点，都进行广度优先搜索
public void bfs() {isVisited = new boolean[vertexList.size()];for(int i = 0; i < getNumOfVertex(); i++) {if(!isVisited[i]) {bfs(isVisited, i);}}
}

遍历结果：

深度优先遍历 && 广度优先遍历的区别：

这里由于上面的图比较简单，看不出深度和广度优先遍历的区别，我在举一个图的栗子：

测试用例：

 public static void main(String[] args){int n = 8;  //结点的个数String Vertexs[] = {"1", "2", "3", "4", "5", "6", "7", "8"};//创建图对象Graph graph = new Graph(n);//循环的添加顶点for(String vertex: Vertexs) {graph.insertVertex(vertex);}//更新边的关系graph.insertEdge(0, 1, 1);graph.insertEdge(0, 2, 1);graph.insertEdge(1, 3, 1);graph.insertEdge(1, 4, 1);graph.insertEdge(3, 7, 1);graph.insertEdge(4, 7, 1);graph.insertEdge(2, 5, 1);graph.insertEdge(2, 6, 1);graph.insertEdge(5, 6, 1);//显示一把邻结矩阵System.out.println("图的创建：");graph.showGraph();//测试一把，我们的dfs遍历是否okSystem.out.println("深度优先遍历：");graph.dfs(); // A->B->C->D->E [1->2->4->8->5->3->6->7]System.out.println();System.out.println("广度优先遍历：");graph.bfs(); // A->B->C->D-E [1->2->3->4->5->6->7->8]}

运行结果：

小结：

图的深度优先遍历（Depth First Search，DFS）和广度优先遍历（Breadth First Search，BFS）是两种常用的图遍历算法，它们的主要区别如下：

遍历顺序：

DFS：从起始节点开始，沿着一条路径尽可能深入地遍历，直到无法继续深入为止，然后回溯到前一个节点，再选择另一条路径继续遍历，直到遍历完所有节点。
BFS：从起始节点开始，先遍历其所有相邻节点，然后再依次遍历这些相邻节点的相邻节点，以此类推，直到遍历完所有节点。

数据结构：

DFS：通常使用栈（Stack）数据结构来实现，通过递归或显式栈来保存遍历路径。
BFS：通常使用队列（Queue）数据结构来实现，通过将节点按照遍历顺序依次加入队列中。

遍历顺序的特点：

DFS：深度优先遍历更加注重深度，会优先探索离起始节点较远的节点，可能会在较深的层级上找到目标节点。
BFS：广度优先遍历更加注重广度，会优先探索离起始节点较近的节点，可能会在较浅的层级上找到目标节点。