广度优先算法
对于无向连通图，广度优先搜索是从图的某个顶点v0出发，在访问v0之后，依次搜索访问v0的各个未被访问过的邻接点w1，w2，…。然后顺序搜索访问w1的各未被访问过的邻接点，w2的各未被访问过的邻接点…。即从v0开始，由近至远，按层次依次访问与v0有路径相通且路径长度分别为1，2，…的顶点，直至连通图中所有顶点都被访问一次。
广度优先搜索在搜索访问一层时，需要记住已被访问的顶点，以便在访问下层顶点时，从已被访问的顶点出发搜索访问其邻接点。所以在广度优先搜索中需要设置一个队列Queue，使已被访问的顶点顺序由队尾进入队列。在搜索访问下层顶点时，先从队首取出一个已被访问的上层顶点，再从该顶点出发搜索访问它的各个邻接点。
用java实现的深度优先算法代码如下：
import java.util.ArrayList;
import java.util.List;
/**
* 队列
*
* @author Thief
*
* @param <E>
*/
public class Queue<E> {
private List<E> queue = new ArrayList<E>();
/**
* 入队
*
* @param e
*/
public void enqueue(E e) {
queue.add(e);
}
/**
* 出队
*
* @param e
* 队首元素
*/
public E dequeue() {
E e = isEmpty() ? null : queue.get(0);
if (e != null) {
queue.remove(0);
}
return e;
}
/**
* 判断当前队列是否为空
*
* @return
*/
public boolean isEmpty() {
return queue.isEmpty();
}
}
/**
* 边
*
* @author Thief
*
*/
public class Edge {
public Edge(String vertexA, String vertexB) {
super();
this.vertexA = vertexA;
this.vertexB = vertexB;
}
/**
* 顶点A
*/
private String vertexA;
/**
* 顶点B
*/
private String vertexB;
/**
* 该边是否已经被访问
*/
boolean isVisited = false;
public String getVertexA() {
return vertexA;
}
public void setVertexA(String vertexA) {
this.vertexA = vertexA;
}
public String getVertexB() {
return vertexB;
}
public void setVertexB(String vertexB) {
this.vertexB = vertexB;
}
public boolean isVisited() {
return isVisited;
}
public void setVisited(boolean isVisited) {
this.isVisited = isVisited;
}
}
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 图
*
* @author Thief
*
*/
public class Graph {
/**
* 顶点
*/
private List<String> vertexList = new ArrayList<String>();
/**
* 边
*/
private Map<String, List<Edge>> edgeMap = new HashMap<String, List<Edge>>();
/**
* 向图中添加顶点
*
* @param vertex
* 顶点名字
* @throws Exception
* 当顶点已经存在时抛出异常
*/
public void addVertex(String vertex) throws Exception {
if (vertexList.contains(vertex)) {
throw new Exception("该顶点已经存在！");
} else {
vertexList.add(vertex);
}
}
/**
* 向图中添加边
*
* @param vertexName_A
* 顶点A的名字
* @param vertexName_B
* 顶点B的名字
* @throws Exception
* 顶点不存在或边已经存在时抛出异常
*/
public void addEdge(String vertexA, String vertexB) throws Exception {
if (!vertexList.contains(vertexA) || !vertexList.contains(vertexB)) {
throw new Exception("顶点不存在！");
}
if (containsEdge(vertexA, vertexB)) {
throw new Exception("边已经存在");
}
if (edgeMap.containsKey(vertexA)) {
List<Edge> list = edgeMap.get(vertexA);
list.add(new Edge(vertexA, vertexB));
} else {
List<Edge> list = new ArrayList<Edge>();
list.add(new Edge(vertexA, vertexB));
edgeMap.put(vertexA, list);
}
if (edgeMap.containsKey(vertexB)) {
List<Edge> list = edgeMap.get(vertexB);
list.add(new Edge(vertexB, vertexA));
} else {
List<Edge> list = new ArrayList<Edge>();
list.add(new Edge(vertexB, vertexA));
edgeMap.put(vertexB, list);
}
}
/**
* 判断图中该边是否已经存在
*
* @param vertexA
* 顶点A
* @param vertexB
* 顶点B
* @return 如果存在返回true，否则返回false
*/
private boolean containsEdge(String vertexA, String vertexB) {
boolean isExist = false;
if (edgeMap.containsKey(vertexA)) {
List<Edge> list = edgeMap.get(vertexA);
if (list.contains(new Edge(vertexA, vertexB))) {
isExist = true;
}
}
return isExist;
}
/**
* 广度优先搜索
*
* @param startVertex
* 起点
*/
public void BFS(String startVertex) {
Queue<String> queue = new Queue<String>();
queue.enqueue(startVertex);
System.out.println("搜索开始。。。");
System.out.print(startVertex);
while (!queue.isEmpty()) {
String vertex = queue.dequeue();
if (edgeMap.containsKey(vertex)) {
for (Edge item : edgeMap.get(vertex)) {
if (!item.isVisited) {
System.out.print(" --> ");
System.out.print(item.getVertexB());
item.isVisited = true;
for (Edge item2 : edgeMap.get(item.getVertexB())) {
if (item2.getVertexB().equals(vertex)) {
item2.isVisited = true;
break;
}
}
queue.enqueue(item.getVertexB());
}
}
}
}
System.out.println();
System.out.println("搜索结束。。。");
}
}
测试代码如下：
public class Test {
public static void main(String[] args) {
Graph graph = new Graph();
try {
graph.addVertex("A");
graph.addVertex("B");
graph.addVertex("C");
graph.addVertex("D");
graph.addVertex("E");
graph.addVertex("F");
graph.addVertex("G");
graph.addEdge("A", "B");
graph.addEdge("B", "C");
graph.addEdge("B", "D");
graph.addEdge("A", "E");
graph.addEdge("E", "F");
graph.addEdge("A", "G");
graph.BFS("A");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
执行结果如下：
