图的遍历有多种方式，但是这里从数据结构基础出发，还是只介绍基础的两种方式，深度优先遍历和广度优先遍历。
深度优先遍历
图的深度优先搜索(Depth First Search)，和树的前序遍历比较类似。
它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。
显然，深度优先搜索是一个递归的过程。一言以蔽之：“一路走到头，不撞南墙不回头”。
代码实现（邻接矩阵）：
public void DFSSelf() {
boolean[] beTraversed = new boolean[size];
beTraversed[0] = true;
System.out.print(vertexs[0] + " ");
DFSSelf(0, beTraversed);//从头节点开始
}
public void DFSSelf(int x, boolean[] beTraversed) {
int y = 0;
while (y <= size - 1) {
if (matrix[x][y] != 0 && beTraversed[y] == false) { //遍历与当前节点有边的节点
beTraversed[y] = true;
System.out.print(vertexs[y] + " ");//遍历
DFSSelf(y, beTraversed);//递归进行深度遍历
}
y++;
}
}
邻接表（思路完全一样，只是获取关系节点的方式不一样）：
public void DFS() {
boolean[] beTraversed = new boolean[size];
beTraversed[getPosition(vertexList[0].ch)] = true;
DFS(beTraversed, vertexList[0]);
}
/**
* 深度优先遍历
*
* @param beTraversed
* @param temp
*/
public void DFS(boolean[] beTraversed, Vertex temp) {
System.out.print(temp.ch + " ");
beTraversed[getPosition(temp.ch)] = true;
while (temp != null) {
if (beTraversed[getPosition(temp.ch)] == false) {
DFS(beTraversed, vertexList[getPosition(temp.ch)]);
}
temp = temp.next;
}
}
广度优先遍历
广度优先搜索算法(Breadth First Search)，又称为”宽度优先搜索”或”横向优先搜索”，简称BFS。
它的思想是：从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问，直至图中所有已被访问的顶点的邻接点都被访问到。如果此时图中尚有顶点未被访问，则需要另选一个未曾被访问过的顶点作为新的起始点，重复上述过程，直至图中所有顶点都被访问到为止。
换句话说，广度优先搜索遍历图的过程是以v为起点，由近至远，依次访问和v有路径相通且路径长度为1,2…的顶点。
代码实现（邻接矩阵）：
public void BFSSelf() {
boolean[] beTraversed = new boolean[size];
beTraversed[0] = true;
System.out.print(vertexs[0] + " ");
BFSSelf(0, beTraversed, new LinkedList<>());
}
/**
* 广度优先搜索遍历
*
* @param x
* @param beTraversed
*/
public void BFSSelf(int x, boolean[] beTraversed, LinkedList<Character> list) {
int y = 0;
while (y <= size - 1) {
if (matrix[x][y] != 0 && beTraversed[y] == false) { //依次将与当前节点有联系的节点遍历，然后入队。
beTraversed[y] = true;
System.out.print(vertexs[y] + " ");
list.add(vertexs[y]);
}
y++;
}
if (!list.isEmpty()) { //出队进行递归操作
Character node = list.pop();
int pos = getPosition(node);
BFSSelf(pos, beTraversed, list);
}
}
邻接表
public void BFS(){
boolean[] beTraversed = new boolean[size];
beTraversed[getPosition(vertexList[0].ch)] = true;
System.out.print(vertexList[0].ch+" ");
int startPos = getPosition(vertexList[0].ch);
BFS(startPos,beTraversed);
}
/**
* 广度优先搜素遍历
* @param beTraversed
*/
public void BFS(int x,boolean[] beTraversed){
Vertex temp = vertexList[x];
LinkedList<Vertex> list = new LinkedList<>();
while(temp!=null){
if(beTraversed[getPosition(temp.ch)] == false){
System.out.print(temp.ch+" ");
beTraversed[getPosition(temp.ch)] = true;
list.add(vertexList[getPosition(temp.ch)]);
}
temp = temp.next;
}
while(!list.isEmpty()){
Vertex node = list.pop();
int pos = getPosition(node.ch);
BFS(pos,beTraversed);
}
}
25
26
27
28
29
30
————————————————
版权声明：本文为CSDN博主「谜一样的Coder」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liman65727/article/details/104311866