【图论】你曾虐我千百遍，我却待你如初恋

作为数据结构中最难的一个结构，图。可以说是折磨了笔者整个大学时光。本想着终于可以摆脱了，谁能想到阴差阳错的，要去做这个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);

基本上一个广度优先遍历的图的创建到使用，我都贴出来了。其中关于深度遍历这块笔者还在纠结这个怎么去确定左右孩子（就是孩子的顺序，有可能不止两个孩子）的问题。这块笔者还没想明白。后面笔者在进行补充。

结论

笔者也是因为工作需要，才来看这个图方面的知识的。必须要承认一点，就是笔者在大学时代对于数据结构与算法没有好好的去学习，现在想起来，还是比较想骂自己的。如果看这篇文章里面有正在学习数据结构的朋友呢，还是建议好好学这门课，其实还是挺有意思的。