深度优先搜索和广度优先搜索

对于图结构的遍历，有两种方式：深度优先搜索和广度优先搜索



深度优先搜索（DFS）：
1）从起点开始，设为已被访问；
2）然后依次搜索起点的每一个邻接点；
3）如果该邻接点未被访问过，则递归把该节点作为起点继续进行深度优先搜索；
4）如果当前点已没有未访问过的邻接节点则递归回溯到上层
直到遍历完途中所有联通的节点



对于上图的搜索过程：
1 → 2 → 4 → 8 → 5（该点已没有未访问的邻接点，递归回溯，回溯过程5 → 8 → 4 → 2 → 1，然后从1的另一个邻接点开始，继续搜索） → 3 → 6 → 7

算法实现：

public class dfs {
public static int[][] graph = {
{0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,0,0,0},
{0,1,0,0,1,1,0,0,0},
{0,1,0,0,0,0,1,1,0},
{0,0,1,0,0,0,0,0,1},
{0,0,1,0,0,0,0,0,1},
{0,0,0,1,0,0,0,1,0},
{0,0,0,1,0,0,1,0,0},
{0,0,0,0,1,1,0,0,0}
};
public static boolean[] visited = new boolean[9];
public static void dfs(int index){
visited[index] = true;
System.out.print(index+"\t");
for(int i=1;i<9;i++)
if(graph[index][i]!=0){
if(visited[i] == false ){
dfs(i);
}
}
}
public static void main(String[] args){

for(int i=0;i<9;i++) visited[i] = false;
dfs(1);
}
}

运行结果：124
8 5
367

广度优先搜索是按层次遍历整个图，当前层访问完成后再进行下一层的访问，这里需要用到队列结构
1）首先起始节点入队
2）当队列不为空，将队首的所有为访问邻接节点入队，队首出队
3）当队列为空时，搜索过程结束

对于上图的搜索过程：

1 （第一层结束，队列{2,3}）→ 2 → 3（第二层结束） → 4 → 5 → 6 → 7（第三层结束） → 8（完成 队列为空）

算法实现：

import java.util.PriorityQueue;
import java.util.Queue;

public class bfs {
private static int[][] graph = {
{0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,0,0,0},
{0,1,0,0,1,1,0,0,0},
{0,1,0,0,0,0,1,1,0},
{0,0,1,0,0,0,0,0,1},
{0,0,1,0,0,0,0,0,1},
{0,0,0,1,0,0,0,1,0},
{0,0,0,1,0,0,1,0,0},
{0,0,0,0,1,1,0,0,0}
};
private static boolean[] visited = new boolean[9];
private static void bfs(int index){
queue.add(new Integer(index));
visited[index] = true;
while(!queue.isEmpty()){
System.out.print(queue.element()+"\t");
for(int i=1;i<=8;i++){
if(graph[queue.element()][i] != 0){
if(visited[i] == false){
queue.offer(new Integer(i));
visited[i] = true;
}
}
}
queue.remove();
}

}
private static Queue<Integer> queue = new PriorityQueue<Integer>();
public static void main(String[] args){
for(int i=1 ; i < 9;i++) visited[i] = false;
bfs(1);
}
}

深度优先搜索一般使用递归实现，实现简单，当搜索深度较小时，比较适用此方法，但是当搜索深度比较大时，由于系统堆栈大小限制，容易产生堆栈溢出。

广度优先搜索一般没有回溯操作，所以运行速度要比深度优先快一些，但是一般需要存储所有节点，占的存储空间比深度优先搜索大得多，所以必须考虑溢出和节省内存空间的问题。