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

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

深度优先搜索（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);
	}
}

运行结果：1 2 4 8 5 3 6 7

广度优先搜索是按层次遍历整个图，当前层访问完成后再进行下一层的访问，这里需要用到队列结构

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);
	}
}

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

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