無向環

一個含有環的無向圖如下所示，其中有兩個環，分別是 0-2-1-0 和 2-3-4-2：

要檢測無向圖中的環，可以使用深度優先搜尋。假設從頂點 0 出發，再走到相鄰的頂點 2，接著走到頂點 2 相鄰的頂點 1，由於頂點 0 和頂點 1 相鄰，並且頂點 0 被標記過了，說明我們饒了一圈，所以無向圖中存在環。雖然頂點 2 和頂點 1 相鄰，但是並不能說明存在環，因為我們就是從頂點 2 直接走到頂點 1 的，這二者只有邊的關係。演算法如下所示：

package com.zhiyiyo.graph;

import com.zhiyiyo.collection.stack.LinkStack;
import com.zhiyiyo.collection.stack.Stack;

/**
 * 無向圖中的環
 */
public class Cycle {
    private boolean[] marked;
    private Graph graph;
    private boolean hasCycle;

    public Cycle(Graph graph) {
        this.graph = graph;
        marked = new boolean[graph.V()];

        for (int v = 0; v < graph.V(); ++v) {
            if (!marked[v]) {
                dfs(v);
            }
        }
    }

    private void dfs(int s) {
        if (hasCycle()) return;

        Stack<Integer> vertexes = new LinkStack<>();
        vertexes.push(s);
        marked[s] = true;

        int lastVertex = s;
        while (!vertexes.isEmpty()) {
            int v = vertexes.pop();

            for (int w : graph.adj(v)) {
                if (!marked[w]) {
                    marked[w] = true;
                    vertexes.push(w);
                } else if (w != lastVertex) {
                    hasCycle = true;
                    return;
                }
            }

            lastVertex = v;
        }
    }

    /**
     * 圖中是否有環
     */
    public boolean hasCycle() {
        return hasCycle;
    }
}
 

有向環

有向圖

有向圖的實現方式和上一篇部落格 《如何在 Java 中實現無向圖》 中無向圖的實現方式幾乎一樣，只是在新增邊 v-w 時只在頂點 v 的連結串列上新增頂點 w，而不對頂點 w 的連結串列進行操作。如果把 LinkGraph 中成員變數的訪問許可權改成 protected，只需繼承並重寫 addEdge 方法即可：

package com.zhiyiyo.graph;


public class LinkDigraph extends LinkGraph implements Digraph {

    public LinkDigraph(int V) {
        super(V);
    }

    @Override
    public void addEdge(int v, int w) {
        adj[v].push(w);
        E++;
    }

    @Override
    public Digraph reverse() {
        Digraph digraph = new LinkDigraph(V());
        for (int v = 0; v < V(); ++v) {
            for (int w : adj(v)) {
                digraph.addEdge(w, v);
            }
        }
        return digraph;
    }
}
 

檢測演算法

一個含有有向環的有向圖如下所示，其中 5-4-3-5 構成了一個環：

這裡使用遞迴實現的深度優先搜尋來檢測有向環。假設從頂點 0 開始走，一路經過 5、4、3 這三個頂點，最終又碰到了與頂點 3 相鄰的頂點 5，這時候如果知道頂點 5 已經被訪問過了，並且遞迴函式還被壓在棧中，就說明深度優先搜尋從頂點 5 開始走，又回到了頂點 5，也就是找到了有向環。演算法如下所示：

package com.zhiyiyo.graph;

import com.zhiyiyo.collection.stack.LinkStack;
import com.zhiyiyo.collection.stack.Stack;

/**
 * 有向圖中的環
 */
public class DirectedCycle {
    private boolean[] marked;
    private boolean[] onStack;
    private int[] edgeTo;
    private Graph graph;
    private Stack<Integer> cycle;

    public DirectedCycle(Digraph graph) {
        this.graph = graph;
        marked = new boolean[graph.V()];
        onStack = new boolean[graph.V()];
        edgeTo = new int[graph.V()];

        for (int v = 0; v < graph.V(); ++v) {
            if (!marked[v]) {
                dfs(v);
            }
        }
    }

    private void dfs(int v) {
        marked[v] = true;
        onStack[v] = true;

        for (int w : graph.adj(v)) {
            if (hasCycle()) return;
            if (!marked[w]) {
                marked[w] = true;
                edgeTo[w] = v;
                dfs(w);
            } else if (onStack[w]) {
                cycle = new LinkStack<>();
                cycle.push(w);
                for (int i = v; i != w; i = edgeTo[i]) {
                    cycle.push(i);
                }
                cycle.push(w);
            }
        }

        onStack[v] = false;
    }

    /**
     * 圖中是否有環
     */
    public boolean hasCycle() {
        return cycle != null;
    }

    /**
     * 圖中的一個環
     */
    public Iterable<Integer> cycle() {
        return cycle;
    }
}