图的广度优先遍历及应用
简介
上一篇 我们实现了图的深度优先遍历及各种应用，使用广度优先遍历也是可以实现的。
从顶点0开始遍历，结果为0->1->3->2->6->4->5。
代码实现
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* 图的广度优先遍历
*/
public class GraphBFS {
/**
* 每个顶点是否已访问过
*/
private boolean[] visited;
/**
* 要遍历的图
*/
private Graph graph;
/**
* 遍历结果
*/
private List<Integer> levelOrder;
public GraphBFS(Graph graph) {
this.graph = graph;
int v = graph.V();
visited = new boolean[v];
levelOrder = new ArrayList<>();
bfs();
}
private void bfs() {
//图中可能有多个联通子图，所有顶点都需要遍历
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < graph.V(); i++) {
queue.add(i);
while (!queue.isEmpty()) {
int poll = queue.poll();
if (visited[poll]) {
continue;
}
visited[poll] = true;
levelOrder.add(poll);
graph.adj(poll).forEach(queue::add);
}
}
}
public Iterable<Integer> levelOrder() {
return levelOrder;
}
public static void main(String[] args) {
GraphBFS graphDFS = new GraphBFS(new AdjSet("g.txt"));
System.out.println(graphDFS.levelOrder());
}
}
深度优先遍历是通过递归实现的，当然也可以通过栈实现，广度优先遍历只能通过队列来实现，类似二叉树的层序遍历。
应用
联通分量
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* 求一个图的连通分量和每个连通子图的具体顶点（迭代实现）
*/
public class GraphCC {
/**
* 每个顶点是否已访问过
*/
private boolean[] visited;
/**
* 每个顶点所在的连通分量索引 两个顶点的索引相等表示在同一个连通子图中
*/
private int[] connectedComponents;
private Graph graph;
/**
* 连通分量
*/
private int connectedComponentCount;
public GraphCC(Graph graph) {
this.graph = graph;
int v = graph.V();
visited = new boolean[v];
connectedComponents = new int[v];
for (int i = 0; i < v; i++) {
if (!visited[i]) {
bfs(i);
connectedComponentCount++;
}
}
}
private void bfs(int rootV) {
Queue<Pair> queue = new LinkedList<>();
queue.add(new Pair(rootV, connectedComponentCount));
while (!queue.isEmpty()) {
Pair pair = queue.poll();
int v = pair.v;
if (visited[v]) {
continue;
}
visited[v] = true;
connectedComponents[v] = pair.connectedComponentCount;
graph.adj(v).forEach(w -> queue.add(new Pair(w, pair.connectedComponentCount)));
}
}
private static class Pair {
private int v;
private int connectedComponentCount;
Pair(int v, int connectedComponentCount) {
this.v = v;
this.connectedComponentCount = connectedComponentCount;
}
}
public int connectedComponentCount() {
return connectedComponentCount;
}
public Iterable<Iterable<Integer>> connectedComponentList() {
List<Iterable<Integer>> connectedComponentList = new ArrayList<>();
for (int i = 0; i < connectedComponentCount; i++) {
connectedComponentList.add(new ArrayList<>());
}
for (int i = 0; i < connectedComponents.length; i++) {
((List<Integer>) connectedComponentList.get(connectedComponents[i])).add(i);
}
return connectedComponentList;
}
public boolean isConnected(int v, int w) {
graph.validateVertex(v);
graph.validateVertex(w);
return connectedComponents[v] == connectedComponents[w];
}
public static void main(String[] args) {
GraphCC graphCC = new GraphCC(new AdjSet("g.txt"));
System.out.println(graphCC.connectedComponentCount());
System.out.println(graphCC.connectedComponentList());
System.out.println(graphCC.isConnected(4, 6));
System.out.println(graphCC.isConnected(3, 5));
System.out.println(graphCC.isConnected(3, 7));
}
}
使用一个新的数据结构 Pair 来保存当前节点和当前节点的连通分量索引。
环检测
import java.util.LinkedList;
import java.util.Queue;
/**
* 图中检测环（迭代实现）
*/
public class GraphCircle {
private boolean[] visited;
private Graph graph;
/**
* 是否存在环
*/
private boolean existsCircle;
public GraphCircle(Graph graph) {
this.graph = graph;
int v = graph.V();
visited = new boolean[v];
existsCircle = existsCircle();
}
public boolean isExistsCircle() {
return existsCircle;
}
private boolean existsCircle() {
int v = graph.V();
//多个连通子图有一个存在环就可以
for (int i = 0; i < v; i++) {
if (!visited[i]) {
if (existsCircle(i)) {
return true;
}
}
}
return false;
}
private boolean existsCircle(int rootV) {
Queue<Pair> queue = new LinkedList<>();
queue.add(new Pair(rootV, rootV));
while (!queue.isEmpty()) {
Pair pair = queue.poll();
int v = pair.v;
if (visited[v]) {
continue;
}
visited[v] = true;
for (Integer w : graph.adj(v)) {
if (w != pair.preV && visited[w]) {
return true;
}
queue.add(new Pair(w, v));
}
}
return false;
}
private static class Pair {
private int v;
private int preV;
Pair(int v, int preV) {
this.v = v;
this.preV = preV;
}
}
public static void main(String[] args) {
GraphCircle graphCircle = new GraphCircle(new AdjSet("g.txt"));
System.out.println(graphCircle.isExistsCircle());
}
}
二分图检测
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
/**
* 检测图是否为二分图（将图中顶点分为两个不相交子集，每条边都分别连接两个集合中的顶点），迭代实现
*/
public class GraphHalf {
private boolean[] visited;
//每个顶点的颜色 -1未染色 0蓝色 1绿色
private int[] colors;
private Graph graph;
/**
* 是否为二分图
*/
private boolean half;
public GraphHalf(Graph graph) {
this.graph = graph;
int v = graph.V();
visited = new boolean[v];
colors = new int[v];
Arrays.fill(colors, -1);
half = half();
}
private boolean half() {
int v = graph.V();
for (int i = 0; i < v; i++) {
if (!visited[i]) {
if (!half(i)) {
return false;
}
}
}
return true;
}
private boolean half(int rootV) {
Queue<Pair> queue = new LinkedList<>();
queue.add(new Pair(rootV, -1));
while (!queue.isEmpty()) {
Pair pair = queue.poll();
int v = pair.v;
if (visited[v]) {
continue;
}
visited[v] = true;
colors[v] = getColor(pair.preColor);
for (Integer w : graph.adj(v)) {
if (isSameColor(v, w)) {
return false;
}
queue.add(new Pair(w, colors[v]));
}
}
return true;
}
private static class Pair {
private int v;
private int preColor;
Pair(int v, int preColor) {
this.v = v;
this.preColor = preColor;
}
}
public boolean isHalf() {
return half;
}
/**
* 根据前一个顶点的颜色获取当前顶点的颜色
*/
private int getColor(int preColor) {
//前一个顶点为蓝色，此顶点为绿色，前一个顶点未染色或为绿色，此顶点为蓝色
if (preColor == 0) {
return 1;
}
return 0;
}
/**
* 判断顶点v和顶点w颜色是否相同
*/
private boolean isSameColor(int v, int w) {
//如果顶点未染色也表示颜色不相同
if (colors[v] == -1 || colors[w] == -1) {
return false;
}
return colors[v] == colors[w];
}
public static void main(String[] args) {
GraphHalf graphCircle = new GraphHalf(new AdjSet("g.txt"));
System.out.println(graphCircle.isHalf());
}
}
路径问题
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* 图中两个顶点的路径（单源，不适用任意两点），迭代实现
*/
public class GraphRoute {
private boolean[] visited;
//源顶点
private int source;
private Graph graph;
//记录每个顶点的上一个顶点
private int[] pre;
public GraphRoute(Graph graph, int source) {
graph.validateVertex(source);
this.source = source;
this.graph = graph;
int v = graph.V();
visited = new boolean[v];
pre = new int[v];
Arrays.fill(pre, -1);
bfs();
}
private void bfs() {
Queue<Pair> queue = new LinkedList<>();
queue.add(new Pair(source, source));
while (!queue.isEmpty()) {
Pair pair = queue.poll();
int v = pair.v;
if (visited[v]) {
continue;
}
visited[v] = true;
pre[v] = pair.preV;
graph.adj(v).forEach(w -> queue.add(new Pair(w, v)));
}
}
private static class Pair {
private int v;
private int preV;
Pair(int v, int preV) {
this.v = v;
this.preV = preV;
}
}
public boolean isConnectTo(int w) {
graph.validateVertex(w);
return visited[w];
}
public Iterable<Integer> route(int w) {
graph.validateVertex(w);
List<Integer> route = new ArrayList<>();
if (!isConnectTo(w)) {
return route;
}
int preV = w;
while (true) {
route.add(preV);
if (preV == source) {
break;
}
preV = pre[preV];
}
Collections.reverse(route);
return route;
}
public static void main(String[] args) {
GraphRoute graphRoute = new GraphRoute(new AdjSet("g.txt"), 0);
System.out.println(graphRoute.route(6));
System.out.println(graphRoute.route(7));
}
}
通过组合单源路径可以实现求任意两点之间的路径
/**
* 图中两个顶点的路径（多源，适用任意两点），最短路径
*/
public class MultiGraphRoute {
private Graph graph;
private GraphRoute[] graphRoutes;
public MultiGraphRoute(Graph graph) {
int v = graph.V();
this.graph = graph;
graphRoutes = new GraphRoute[v];
for (int i = 0; i < v; i++) {
graphRoutes[i] = new GraphRoute(graph, i);
}
}
/**
* 从v到w的路径
*/
public Iterable<Integer> route(int v, int w) {
graph.validateVertex(v);
graph.validateVertex(w);
return graphRoutes[v].route(w);
}
public static void main(String[] args) {
MultiGraphRoute graphRoute = new MultiGraphRoute(new AdjSet("g.txt"));
System.out.println(graphRoute.route(0, 6));
System.out.println(graphRoute.route(5, 2));
System.out.println(graphRoute.route(2, 5));
System.out.println(graphRoute.route(8, 5));
}
}
以求顶点0到顶点6之间的路径为例，深度优先遍历结果为0->1->2->3->4->5->6。
广度优先遍历结果为0->2->6。广度优先遍历求的路径就是两点之间的最短路径，
- 离顶点0的距离为0的顶点：0
- 离顶点0的距离为1的顶点：1,3
- 离顶点0的距离为2的顶点：6,2,4
- 离顶点0的距离为3的顶点：5
广度优先遍历就是按照距离来遍历的，先遍历的顶点距离肯定更小。
