无向图的Depth-first search和Breadth-first Search

1. Depth-first search和Breadth-first search有什么用?
从它们的名字中可以看出，这两者都是图的搜索算法。不同于树的搜索，图搜索的基本思路是遍历每一个vertex，直到找到我们想要的结果。这两个算法实际上都是遍历。前面我们建立起了图结构，我们可以直接知道每个vertex相邻近的vertex有哪些，但是不能直接知道任意两个vertex之间是什么关系（比如它们之间的路径啊，是不是相连啊等等）。基于Depth-first search和Breadth-first search算法，我们可以高效地解决这一问题。

2. Depth-first search的应用一：查找路径。
给定一个源头vertex（假设叫s），和任意一个vertex，他们之间的连接路径是怎样的？为了解决这一问题，我们可以用Depth-first search算法。思路如下：首先新建两个数组，一个boolean类型，叫marked，用来记录vertex是不是被检验过（为了避免重复）；一个int类型，叫edgeTo，用于记录某vertex上面连接着啥玩意儿。在遍历与s相关vertex的同时（即Depth-first search），我们顺便操作一下这两个数组。这样结束的时候，所有路径信息都被记录在edgeTo数组里面，我们可以从非常方便的查找某vertex到s的路径信息。代码如下：
public class DepthFirstPath{
private boolean[] marked;
//edgeTo数组，用于记录路径信息。
private int[] edgeTo;
private final int s;

public DepthFirstPath(Graph G, int s)
{
this.s = s;
//初始化marked以及edgeTo数组，长度就是G图内vertex的个数。
marked = new boolean[G.V()];
edgeTo = new int[G.V()];
dfs(G, s);
}

private void dfs(Graph G, int v)
{
marked[v] = true;
for(int w : G.adj(v))
if(!marked[w])
{
//这个便是dfs的顺便操作，在遍历相关vertex的同时，
//顺便操作了edgeTo数组。
edgeTo[w] = v;
dfs(w);
}
}

public boolean hasPath(int v)
//未被标记（marked值为false），说明该vertex跟s不相连，自然没有path。
{ return marked[v]; }

public Iterable path(int v)
{
if(!hasPath(v)) return null;
Stack<Integer> path = new Stack<>();
for(int x = v; x != s; x = edgeTo[x])
//路径信息提取出来，保存到stack里面。
path.push(x);
path.push(s);
return path;
}
}
3. Breadth-first search的应用一：查找路径。
Breadth-first search也是一种遍历所有元素的算法。从它的名字中就可以看出，这种算法是讲究宽度，而不是深度。Depth-first search是沿某一支不断深入下去，到头了就再回到上一节点再往下找。而Breadth-first search是很多支一起，一层层的往下进展的。当然也可以顺便操作edgeTo数组，记录路径信息。public class BreadthFirstPaths
{
private int[] edgeTo;
private boolean[] marked[];
private int s;

public BreadthFirstPaths(Graph G, int s)
{
maeked = new boolean[G.V()];
edgeTo = new int[G.V()];
this.s = s;
bfs(s);
}

private void bsf(Graph G, int s)
{
marked[s] = true;
Queue<Integer> queue = new Queue<>();
queue.enqueue(s);
while(!queue.isEmpty())
{
int v = queue.dequeue();
for(int w : G.adj())
if(!marked[w])
{
queue.enqueue(w);
edgeTo[w] = v;
marked[w] = true;
}
}
}

public boolean hasPathTo(int v)
{ return marked[v]; }

public Iterable<Integer> pathTo(int v)
{
if(!hasPathTo(v)) return null;
Stack<Integer> path = new Stack<>();
for(int x = v; x != s; x = edgeTo[v])
path.push(x);
path.push(s);
return path;
}
}                                                
4. Depth-first search的应用二：相连的vertex。

任意给出一些vertex，如何判断它们是否相连？Depth-first search算法可以以解决这个问题，代码如下：public class CC
{
//ID数组代替edgeTo数组，相连接的vertex的ID值一致。
private int[] ID;
private boolean[] marked;
private int count;

public CC(Graph G)
{
ID = new int[G.V()];
marked = new boolean[G.V()];
for(int s = 0; s < G.V(); s++)
if(!marked[s])
{
dfs(G, s);
count++;
}
}

private void dfs(Graph G, int v)
{
marked[v] = true;
ID[v] = count;
for(int w : G.adj[v])
if(!marked[w])
{
dfs(w);
}
}

//判断两个vertex是否相连，就是看它们的ID是否一致。
public boolean connected(int v, int w)
{ return ID[v] == ID[w]; }
}