图的遍历
遍历，即是对图中订点的访问。一个图有那么多个结点，如何遍历这些结点，则可根据搜索路径的不同，将遍历图的方法分为 2 种：
- 深度优先遍历 (Depth First Search)
- 广度优先遍历 (Broad First Search)
深度优先遍历
基本思想
- DFS 类似于树的先序遍历
- 首先以一个未被访问过的顶点作为起始顶点，初始访问结点可能有多个邻接结点，DFS 的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问该邻接结点的第一个邻接结点；重复此步骤，直至刚访问过的顶点没有未被访问的邻接点为止 // 使劲往里钻
- 简述：每次都在访问完当前结点后，首先访问当前结点的第一个邻接结点
- 特点：这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问
- 当 当前结点没有未访问过的邻接顶点了 时，则返回前一个访问过的仍有未被访问邻接点的顶点，继续访问该顶点的下一个未被访问邻接点，直至所有的顶点都被访问过 // 不撞南墙不回头
- 所以需要回溯，一般都设置一个数组，用来记录顶点是否访问到，如果已访问到就不执行DFS算法，如果未被访问过就执行DFS算法
- 显然，深度优先搜索是一个递归的过程
算法步骤
- 访问 [初始结点 v]，并标记 [结点 v] 为已访问
- 查找 [结点 v] 的 [第一个邻接结点 w]
- 若 w 存在，则继续执行 step4；若 w 不存在，则回到 step1，从 [v 的下一个邻接结点] 继续
- 若 w 未被访问，对 w 进行 DFS 递归 (即把 w 当做另一个 v，然后进行 step1,2,3)
- 当 w 递归回溯回来后，继续查找 [结点 v] [继 w 之后的下一个邻接结点]，再转到 step3
代码实现
// DFS 重载: 遍历所有结点
public void DFS() {
// 初始化辅助标记数组
for (int i = 0; i < isVisited.length; i++) isVisited[i] = false;
// 对每个结点 DFS
for (int i = 0; i < getNumOfVertex(); i++)
if (! isVisited[i]) DFS(i);
}
// 对 结点v 深度优先遍历
private void DFS(int v) {
// 1. 访问结点 v, 并为 v 标记为已访问
System.out.print(getVertexValue(v) + " → ");
isVisited[v] = true;
// 2. 查找 v 的第一个临接结点 w
int w = getFirstNeighbor(v);
// 3. w 存在
while (w != -1) {
// 4. 对 w 进行 DFS [递归]
if (! isVisited[w]) DFS(w);
// 5. [回退至此] 找继 w 之后的下一个邻接结点
w = getNextNeighbor(v, w);
}
}
广度优先遍历
基本思想
- BFS 类似于树的层次遍历过程
- 广度优先遍历需要借助一个队列来存放每一层的结点，以便按这个顺序再去访问这些结点的邻接结点
算法步骤
- 访问 [初始结点 v]，并将 [结点 v] 标记为“已访问”
- [结点 v] 入队列
- 当队列非空时，继续执行；否则算法结束
- 出队，取得 [队头结点 u]
- 查找 [结点 u] 的 [第一个邻接结点 w]
- 若 [结点 u] 的 [邻接结点 w] 存在，则循环执行以下 3 个步骤；否则，到 step3
- 若 [结点w] 尚未被访问，则访问 [结点 w] 并标记为“已访问”
- [结点 w] 入队列
- 查找 [结点 u] 继 [邻接结点 w] 后的 [下一个邻接结点 w]，转到 step6
代码实现
// BFS重载: 遍历所有结点
public void BFS() {
// 初始化辅助标记数组
for (int i = 0; i < isVisited.length; i++) isVisited[i] = false;
// 对每个结点BFS
for (int i = 0; i < vertexList.size(); i++)
if (! isVisited[i]) BFS(i);
}
// 对 结点v 进行广度优先遍历
private void BFS(int v) {
// 0. 创建队列来存放每一层的结点
int u; // 队列头结点
int w; // 邻接结点
// 队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点
LinkedList<Integer> queue = new LinkedList<>();
// 1. 访问结点 v，并将 v 标记为已访问
System.out.print(getVertexValue(v) + " → ");
isVisited[v] = true;
// 2. 将 v 入队
queue.addLast(v);
// 3. 队头元素出队，然后将队头元素的全部邻接结点入队
while (! queue.isEmpty()) { // 当队列非空时, 继续执行; 否则算法结束
// 4. 取出队列头结点 u
u = queue.removeFirst();
// 5. 查找 u 的第一个邻接结点 w
w = getFirstNeighbor(u);
// 6. 若 u 的邻接结点 w 存在
while (w != -1) {
if (! isVisited[w]) {
System.out.print(getVertexValue(w) + " → ");
isVisited[w] = true;
queue.addLast(w);
}
// 查找队列头结点 u 继当前邻接结点 w 后的下一个邻接结点 w
w = getNextNeighbor(u, w);
}
}
}
DFS & BFS
代码汇总
public class Graph {
private ArrayList<String> vertexList; // 存储顶点的集合
private int[][] edges; // 存储图对应的临接矩阵
private int numOfEdges; // 表示边的数目
private boolean[] isVisited;// 记录某个顶点是否被访问
public static void main(String[] args) {
Graph graph = new Graph(8);
// String[] vertexs = {"A", "B", "C", "D", "E"};
String[] vertexs = {"1", "2", "3", "4", "5", "6", "7", "8"};
// 添加顶点
for (String vertex : vertexs) graph.insertVertex(vertex);
/*
// 添加边: A-B A-C B-C B-D B-E
graph.insertEdge(0, 1, 1);
graph.insertEdge(0, 2, 1);
graph.insertEdge(1, 2, 1);
graph.insertEdge(1, 3, 1);
graph.insertEdge(1, 4, 1);
*/
// 更新关系
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();
System.out.println("DFS: ");
graph.DFS(); // 1 → 2 → 4 → 8 → 5 → 3 → 6 → 7
System.out.println("
BFS: ");
graph.BFS(); // 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8
}
public Graph(int n) {
vertexList = new ArrayList<>();
edges = new int[n][n];
numOfEdges = 0;
isVisited = new boolean[n];
}
// 返回 index结点 的 {第一个临接结点} 的索引
public int getFirstNeighbor(int v) {
for (int j = 0; j < vertexList.size(); j++)
if (edges[v][j] == 1) return j;
return -1;
}
// 根据 v1 的 {前一个临接结点v2} 的索引来获取其 {下一个临接结点的索引}
public int getNextNeighbor(int v, int w) {
for (int j = w + 1; j < vertexList.size(); j++)
if (edges[v][j] == 1) return j;
return -1;
}
// ---------------------------------------------------------------
// DFS重载: 遍历所有结点
// 对 结点v 深度优先遍历
// BFS重载: 遍历所有结点
// 对 结点v 进行广度优先遍历
// ---------------------------------------------------------------
// 插入顶点
public void insertVertex(String vertex) {
vertexList.add(vertex);
}
// 返回顶点的个数
public int getNumOfVertex() {
return vertexList.size();
}
// 返回图中边的个数
public int getNumOfEdges() {
return numOfEdges;
}
// 返回顶点i对应的数据
public String getVertexValue(int index) {
return vertexList.get(index);
}
// 返回v1和v2的权值
public int getWeigth(int v1, int v2) {
return edges[v1][v2];
}
/**
* 添加边
* @param v1 第几个顶点(从0开始)
* @param v2 第v1个顶点 与 第v2个顶点 的直连状况
* @param weight 直连为1, 反之为0
*/
public void insertEdge(int v1, int v2, int weight) {
// ∵ 是无向图
edges[v1][v2] = weight;
edges[v2][v1] = weight;
numOfEdges++;
}
// 显示图对应的矩阵
public void showGraph() {
System.out.print(" ");
for (String value : vertexList)
System.out.print(value + " ");
System.out.println();
int index = 0;
for (int[] links : edges) {
System.out.print(vertexList.get(index++)+" ");
for (int i = 0; i < links.length; i++)
System.out.print(links[i] + " ");
System.out.println();
}
}
}