第四章--无向图广度优先搜索算法

public class BreadthFirstPaths {
    private boolean[] marked;// 保存被标记的顶点
    private int[] edgeTo;// 保存起点到与之连通的顶点之间的最短路径
    private final int s;// 起点

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

    public void bfs(Graph G, int s) {
        Queue<Integer> queue = new Queue<Integer>();
        marked[s] = true;
        queue.enqueue(s);
        while (!queue.isEmpty()) {
            int v = queue.dequeue();
            // 遍历与顶点s直接相连的点
            for (int w : G.adj(v)) {
                if (!marked[w]) {
                    marked[w] = true;// 标记
                    edgeTo[w] = v;// 保存最短路径的结点
                    queue.enqueue(w);
                }
            }
        }
    }





    public boolean hasPathTo(int v) {
        return marked[v];
    }
    //和深度优先搜索算法一样，也是将edgeTo数组转成一个stack来表示路径。
    public Iterable<Integer> pathTo(int v) {
        if (!hasPathTo(v))
            return null;
        Stack<Integer> path = new Stack<Integer>();
        for (int x = v; x != s; x = edgeTo[x]) {
            path.push(x);
        }
        path.push(s);
        return path;
    }
}

Queue

import java.util.Iterator;

public class Queue<Item> implements Iterable<Item> {

    private Node first;// 头部
    private Node last;// 尾部
    private int N;// 记录元素数目

    private class Node {
        Item item;
        Node next;
    }

    public void enqueue(Item item) {
        Node oldlast = last;
        last = new Node();
        last.item = item;
        last.next = null;

        if (isEmpty()) {
            first = last;
        } else {
            oldlast.next = last;
        }

        N++;
    }

    public Item dequeue() {
        Item item = first.item;
        first = first.next;

        if (isEmpty()) {
            last = null;
        }
        N--;
        return item;
    }

    public boolean isEmpty() {
        return N == 0;
    }

    public int size() {
        return N;
    }

    public Iterator<Item> iterator() {

        return new listIterator();
    }

    private class listIterator implements Iterator<Item> {

        private Node current = first;

        public boolean hasNext() {
            return current != null;
        }

        public Item next() {
            Item item = current.item;
            current = current.next;
            return item;
        }

    }
}