广度优先搜索

/**
 * 算法思想:
 *          1.将起点放入队列,弹出队列
 *          2.将起点的所有邻接点加入队列
 *          3.将队列中的第一个顶点弹出,将其所有邻接点加入队列............直到队列为空
 *
 */
public class BreadthFirstSearch {
    private boolean[] marked;
    private int[] edgeTo;//从起点到一个顶点的已知路径上的最后一个点
    private final int s;//起点
    private int[] ord;//起点到某一顶点的距离

    public BreadthFirstSearch(Graphics G,int s){
        marked = new boolean[G.v()];
        edgeTo = new int[G.v()];
        ord = new int[G.v()];
        this.s = s;
        bfs(G,s);
    }

    private void bfs(Graphics G, int v) {
        Queue<Integer> queue= new Queue<Integer>();
        marked[s] = true;//标记起点
        queue.enqueue(s);//将其加入队列
        ord[s] = 0;
        while(!queue.isEmpty()){
            int v = queue.dequeue();//从队列中删去下一个顶点
            for(int w:G.adj(v)){
                if(!marked[w]){
                    edgeTo[w] = v;//保存最短路径的最后一条边
                    marked[w] = true;//标记它，因为最短路径已知
                    ord[w] = ord[v] + 1;//s到w的最短距离
                    queue.enqueue(w);//并将它加入队列中
                }
            }
        }

    }

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

    public Vector path(int v){//求s到v的最短路径
        Stack stack = null;
        int p = v;

        while(p != s){
            stack.push(p);
            p = edgeTo[p];
        }
        Vector vec = new Vector();
        vec.clear();
        while(!stack.empty()){
            vec.add(stack.peek());
            stack.pop();
        }

        return vec;
    }

    public int length(int v){//s到v的距离
        return ord[v];  
    }
}