【數據結構與算法】圖論-你曾虐我千百遍，我卻待你如初戀

作爲數據結構中最難的一個結構，圖。可以說是折磨了筆者整個大學時光。本想着終於可以擺脫了，誰能想到陰差陽錯的，要去做這個DAG。

基礎概念

有向無環圖

有向無環圖指的是一個沒有迴路的有向圖，簡單的說就是沒有撤退可言。在圖論中，如果一個人有向圖無法從某個頂點出發，經過若干條邊回到該頂點，則這個圖是一個有向無環圖（DAG圖）。那麼現在一個小的問題來了。什麼是有向圖？什麼是圖？

圖

圖G由頂點集V和邊集E組成，記爲G=(V,E)，其中V(G)表示圖G中頂點的有限非空集；E(G)表示圖G中頂點之間的關係(邊)的集合。

概念這玩意從來是讓人看的。我知道大家有人肯定沒看懂。但這個沒關係，我來解釋就好了。先看下面的這張圖:

現在我們再來看這個概念，什麼叫頂點集，圖中的 A,B,C,D,E,F ,這就是一個頂點集，也就是一個V的集合。集合內的元素是A,B,C,D,E,F。再來看什麼叫做邊集。我們可以看到，A->B,是不是有一個連線，去連接AB？這條線就是邊。邊組成的集合，我們稱爲邊集。也就是說，一個E的集合。集合內元素是 AB,AC,BE,EF,EG 組成的集合。

這就是圖的概念。圖的概念理解後，現在就是有哪些圖了。一般我們會根據圖是否是閉合的，分爲有環圖和無環圖。無環圖就是指，無論你從哪個頂點走，你都不會回來的。根據我們的邊的是否有方向分爲有向圖和無向圖。這裏我們討論有向圖。

有向圖

前面說了圖的概念，現在來看有向圖。由於有向圖的邊是有方向性的，所以我們在表示有向圖的時候，需要注意我們的方向不要錯了。前面的舉的例子，就是一個有向圖，而且是無環的。

相關術語

這裏的關於圖的術語，會比較多，遇到了參考下就好了，一般用用就會了。

• 頂點：圖中的一個點
• 邊：連接兩個頂點的線段叫做邊，edge
• 相鄰的：一個邊的兩頭的頂點稱爲是相鄰的頂點
• 度數：由一個頂點出發，有幾條邊就稱該頂點有幾度，或者該頂點的度數是幾，degree
• 路徑：通過邊來連接，按順序的從一個頂點到另一個頂點中間經過的頂點集合
• 簡單路徑：沒有重複頂點的路徑
• 環：至少含有一條邊，並且起點和終點都是同一個頂點的路徑
• 簡單環：不含有重複頂點和邊的環
• 連通的：當從一個頂點出發可以通過至少一條邊到達另一個頂點，我們就說這兩個頂點是連通的
• 連通圖：如果一個圖中，從任意頂點均存在一條邊可以到達另一個任意頂點，我們就說這個圖是個連通圖
• 無環圖：是一種不包含環的圖
• 稀疏圖：圖中每個頂點的度數都不是很高，看起來很稀疏
• 稠密圖：圖中的每個頂點的度數都很高，看起來很稠密
• 二分圖：可以將圖中所有頂點分爲兩部分的圖、
  在 有向圖 中，我們一般還會有這樣的術語：
• 出度：由一個頂點出發的邊的總數
• 入度：指向一個頂點的邊的總數

接着，由於有向圖的方向性，一條邊的出發點稱爲頭，指向點稱爲尾。

• 有向路徑：圖中的一組頂點可以滿足從其中任意一個頂點出發，都存在一條有向邊指向這組頂點中的另一個。

• 有向環：至少含有一條邊的起點和終點都是同一個頂點的一條有向路徑。

• 簡單有向環：一條不含有重複頂點和邊的環。

• 路徑或環的長度就是他們包含的邊數。

算法實現

這裏我使用的是Java語言。僅供大家參考。
首先看我的程序的基本結構：

大家看到這個結構圖，也能知道DAGGraph裏面是什麼，所以這個接口我就不貼出了。BFS和 DFS是我的兩個內部實現類，目前DFS還處於編寫狀態，但是怎麼寫，筆者還不確定。如果網友有思路可以和我交流一下。
AbsDGraph.java

/**
 * @author Mr.Sun
 * @version v.1.0
 * @title AdjacencyListDGraph
 * @description 鄰接鏈表實現的有向圖
 * @date 2020/3/23 9:38
 */
public abstract class AbsDGraph<V> {
    private static Logger log = Logger.getLogger(AbsDGraph.class);
    /**
     * 構建一個頂點列表
     */
    protected List<VRoot> vRootList ;

    public List<VRoot> getVRootList() {
        return vRootList;
    }

    public void setVRootList(List<VRoot> vRootList) {
        this.vRootList = vRootList;
    }
    /**
     * 獲取根節點
     *
     * @param v
     * @return
     */
    public VRoot getVRoot(V v) {
        if (v != null) {
            for (VRoot vRoot : vRootList) {
                if (vRoot.root != null && v.equals(vRoot.root)) {
                    return vRoot;
                }
            }
        }
        return null;
    }

    /**
     * 判斷節點是否存在
     *
     * @param v
     * @param vIterator
     * @return
     */
    public boolean vinList(V v, Iterator<V> vIterator) {
        if (v != null && vIterator != null) {
            while (vIterator.hasNext()) {
                V next = vIterator.next();
                if (next != null && v.equals(next)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 刪除頂點
     * @param v
     * @return
     */
    public VRoot removeRoot(V v) {
        if (v != null) {
            for (VRoot vRoot : vRootList) {
                if (vRoot.root != null && v.equals(vRoot.root)){
                    vRootList.remove(vRoot);
                    return vRoot;
                }
            }
        }
        return null;
    }

    public void removeRootEdge(V v){
        if (v != null ){
            for (VRoot vRoot : vRootList) {
                vRoot.removeEdge(v);
            }
        }
    }
}

DGraph.java

/**
 * @author Mr.Sun
 * @version v.1.0
 * @title DGraph
 * @description
 * @date 2020/3/23 14:29
 */
public class DGraph<V> extends AbsDGraph<V> implements DAGGraph<V> {
    private static Logger log = Logger.getLogger(DGraph.class);
    public DGraph(){
        List<VRoot> vRootList = new LinkedList<VRoot>();
        setVRootList(vRootList);
    }
    @Override
    public int add(V v) {
        int index = -1;
        if (v != null) {
            VRoot vRoot = new VRoot(v);
            getVRootList().add(vRoot);
            index = getVRootList().indexOf(vRoot);
        }
        return index;
    }

    @Override
    public void add(Edge<V> e) {
        if (e != null) {
            VRoot vRoot = getVRoot(e.getStart());
            if (vRoot != null) {
                vRoot.addEdge(e);
            } else {
                System.out.println(System.out.printf("error: can not find v: %s", e.getStart()));
            }
        }
    }

    @Override
    public V remove(V v) {
        VRoot vRoot = removeRoot(v);
        if (vRoot != null) {
            removeRootEdge(v);
            return (V) vRoot.root;
        }
        return null;
    }

    @Override
    public Edge<V> remove(Edge<V> e) {
        if (e != null) {
            VRoot vRoot = getVRoot(e.getStart());
            if (vRoot != null) {
                return vRoot.removeEdge(e.getEnd());
            }
        }
        return null;
    }

    @Override
    public V get(int index) {
        if (index >= 0 || index < getVRootList().size()) {
            VRoot vRoot = getVRootList().get(index);
            if (vRoot != null) {
                return (V) vRoot.root;
            }
        }
        return null;
    }

    @Override
    public Edge<V> get(int start, int end) {
        V v1 = get(start);
        V v2 = get(end);

        if (v1 != null && v2 != null) {
            VRoot vRoot = getVRoot(v1);
            if (vRoot != null) {
                return vRoot.getEdge(v2);
            }
        }
        return null;
    }

    @Override
    public Iterator<V> iterator(int type, V root) {
        Iterator<V> vIterator = null;
        if (type == TRAVERSAL_TYPE_BFS) {
            vIterator = new BFS(root);
        }else if (type == TRAVERSAL_TYPE_DFS){
            vIterator = new DFS(root);
        }
        return vIterator;
    }

    @Override
    public boolean convertDAG() {
        return false;
    }

    /**
     * 廣度遍歷（隊列實現）
     */
    private class BFS implements Iterator<V> {
        /**
         * 已經訪問過的頂點列表
         */
        private List<V> vList = null;
        /**
         * 待訪問的頂點隊列
         */
        private Queue<V> vQueue = null;

        public BFS(V root) {
            this.vList = new LinkedList<V>();
            this.vQueue = new LinkedList<V>();
            // 初始節點進入隊列
            vQueue.offer(root);
        }

        @Override
        public boolean hasNext() {
            if (vQueue.size() > 0) {
                return true;
            }
            return false;
        }

        @Override
        public V next() {
            V poll = vQueue.poll();
            if (poll != null) {
                VRoot vRoot = getVRoot(poll);
                if (vRoot != null) {
                    List<Edge<V>> list = vRoot.getRootEdgeList();
                    for (Edge<V> vEdge : list) {
                        V end = vEdge.getEnd();
                        if (!vinList(end, vList.iterator()) && !vinList(end, vQueue.iterator())) {
                            vQueue.offer(end);
                        }
                    }
                }
                vList.add(poll);
            }
            return poll;
        }

    }

    private class DFS implements Iterator<V> {

        /**
         * 已經訪問過的頂點列表
         */
        private List<V> vList = null;
        /**
         * 待訪問的頂點隊列
         */
        private Stack<V> vStack = null;

        public DFS(V root){
            this.vList = new LinkedList<V>();
            this.vStack = new Stack<V>();
            // 初始節點進入棧
            vStack.push(root);
        }
        @Override
        public boolean hasNext() {
            if (vStack.size() > 0) {
                return true;
            }
            return false;
        }

        @Override
        public V next() {

            return null;
        }
    }
}

這裏面，我會用到一個頂點類 VRoot.java

/**
 * @author Mr.Sun
 * @version v.1.0
 * @title VRoot
 * @description
 * @date 2020/3/23 10:40
 */
public class VRoot<V> extends AbsDGraph {
    private static Logger log = Logger.getLogger(VRoot.class);
    /**
     * 當前頂點
     */
    public V root;

    /**
     * 以此點爲起點的邊的集合
     */
    public List<Edge<V>> rootEdgeList;

    public VRoot(V root) {
        this.root = root;
        this.rootEdgeList = new LinkedList<Edge<V>>();
        System.out.println(System.out.printf("the VRoot construct: %s ", root));

    }

    public List<Edge<V>> getRootEdgeList() {
        return rootEdgeList;
    }

    @Override
    public String toString() {
        return "VRoot{" +
                "root=" + root +
                ", rootEdgeList=" + rootEdgeList +
                '}';
    }

    /**
     * 添加邊
     *
     * @param e
     * @return
     */
    public void addEdge(Edge<V> e) {
        if (getEdge(e.getEnd()) == null) {
            rootEdgeList.add(e);
        }else {
            System.out.println("edge is exit .");
        }

    }

    /**
     * 獲取邊
     *
     * @param end
     * @return
     */
    public Edge<V> getEdge(V end) {
        Edge<V> temp = null;
        if (end != null) {
            for (Edge<V> vEdge : rootEdgeList) {
                if (vEdge.getEnd() != null && end.equals(vEdge.getEnd())) {
                    temp = vEdge;
                    break;
                }
            }
        }
        return temp;
    }

    /**
     * 刪除邊
     * @param end
     * @return
     */
    public Edge<V> removeEdge(V end) {
        if (end != null) {
            for (Edge<V> vEdge : rootEdgeList) {
                if (vEdge != null && end.equals(vEdge.getEnd())) {
                    rootEdgeList.remove(end);
                    return vEdge;
                }
            }
        }
        return null;
    }
}

表是邊的類： Edge.java ,這裏面是對Edge做的一個簡單的封裝，相關方法大家看就好了。

    /**
     * 定義邊的起點
     */
    private V start ;
    /**
     * 定義邊的終點
     */
    private V end ;
    /**
     * 定義權值
     */
    private double weight ;

這裏我在貼一下我的測試主類:

TestGraph.java

        DGraph dGraph = new DGraph();
        System.out.println("添加端點");
        dGraph.add("1");
        dGraph.add("2");
        dGraph.add("3");
        dGraph.add("4");
        dGraph.add("5");
        dGraph.add("6");
        dGraph.add("7");
        dGraph.add("8");
        System.out.println("添加邊");
        dGraph.add(new Edge<String>("1" , "2"));
        dGraph.add(new Edge<String>("1" , "3"));
        dGraph.add(new Edge<String>("2" , "4"));
        dGraph.add(new Edge<String>("2" , "5"));
        dGraph.add(new Edge<String>("4" , "6"));
        dGraph.add(new Edge<String>("5" , "7"));
        dGraph.add(new Edge<String>("4" , "8"));

        Iterator<String> iterator = dGraph.iterator(DAGGraph.TRAVERSAL_TYPE_BFS, "1");

        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next + " ");
        }

        Iterator<String> iterator1 = dGraph.iterator(DAGGraph.TRAVERSAL_TYPE_BFS, "2");
        while (iterator1.hasNext()){
            String next = iterator1.next();
            System.out.println(next + " ");
        }

        Edge edge = dGraph.get(0, 1);
        System.out.println(edge);

基本上一個廣度優先遍歷的圖的創建到使用，我都貼出來了。其中關於深度遍歷這塊筆者還在糾結這個怎麼去確定左右孩子（就是孩子的順序，有可能不止兩個孩子）的問題。這塊筆者還沒想明白。後面筆者在進行補充。

結論

筆者也是因爲工作需要，纔來看這個圖方面的知識的。必須要承認一點，就是筆者在大學時代對於數據結構與算法沒有好好的去學習，現在想起來，還是比較想罵自己的。如果看這篇文章裏面有正在學習數據結構的朋友呢，還是建議好好學這門課，其實還是挺有意思的。