广度优先和深度优先算法的实现

图的存储

图的存储有两种方式

• 邻接矩阵
• 邻接表

图的相关算法

• BFS（广度优先搜索 Breadth-first search）

  应用：

  • 最短路径
  • 二分图的判断

• DFS（深度优先搜索 Depth-firs search）

  应用：

  • 中序遍历
  • 拓扑排序

以下算法的实现使用的邻接表的存储方式

BFS

算法思想

1. 从任意顶点出发
2. 访问其所有相邻顶点，将这些顶点保存到一个队列中
3. 从队列中取出一个顶点，重复1-2
4. 直到队列为空，BFS结束

实现代码

public class GraphBFS {

    private int V;
    private LinkedList<Integer>[] adj;

    public GraphBFS(int v) {
        V = v;
        adj = new LinkedList[v];
        for (int i = 0; i < v; i++) {
            adj[i] = new LinkedList<>();
        }
    }

    /**
     * 添加一条边，v->w的边
     * @param v 指向顶点
     * @param w 被指向顶点
     */
    void addEdge(int v,int w) {
        adj[v].add(w);
    }

    /**
     * 广度优先搜索
     * @param s 开始的顶点
     */
    void BFS(int s) {
        boolean[] visited = new boolean[V];
        // 创建一个队列
        LinkedList<Integer> queue = new LinkedList<>();
        visited[s] = true;
        queue.add(s);
        while(queue.size()!=0){
            // 打印当前顶点
            s = queue.poll();
            System.out.print(s + " ");
            // 访问当前顶点所有相邻的顶点
            for (int n : adj[s]) {
                // 如果当前顶点未被访问过，则添加到队列中
                if (!visited[n]) {
                    visited[n] = true;
                    queue.add(n);
                }
            }
        }
    }

    public static void main(String[] args) {
        GraphBFS g = new GraphBFS(5);
        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);
        g.addEdge(2, 4);

        System.out.println("Following is Breadth First Traversal " + "(starting from vertex 2)");

        g.BFS(2);
    }
}

DFS

算法思想

1. 从任意顶点出发
2. 遍历当前顶点所有的相邻顶点
3. 遇到未访问过的相邻顶点，那么就访问当前顶点的所有相邻顶点
4. 重复2-3，直到所有顶点访问完毕

代码实现

public class GraphDFS {

    private LinkedList<Integer>[] adj;
    private boolean[] visited;

    public GraphDFS(int v) {
        adj = new LinkedList[v];
        visited = new boolean[v];
        for (int i = 0; i < v; i++) {
            adj[i] = new LinkedList<>();
        }
    }

    /**
     * 添加一条边，v->w的边
     * @param v 指向顶点
     * @param w 被指向顶点
     */
    void addEdge(int v,int w) {
        adj[v].add(w);
    }

    /**
     * 深度优先搜索
     * @param vertex 开始的顶点
     */
    void DFS(int vertex) {
        visited[vertex] = true;
        System.out.print(vertex+" ");
        for (Integer w : adj[vertex]) {
            if (!visited[w]) {
                DFS(w);
            }
        }
    }

    public static void main(String[] args) {
        GraphDFS g = new GraphDFS(4);
        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);

        System.out.println("Following is Depth First Traversal " + "(starting from vertex 2)");

        g.DFS(2);
    }
}