有向图 拓扑排序 文件依赖下的编译顺序该如何确定？

有2种常用方式

1.kahn算法

2.基于深度优先的逆后序

都需要有向图中无环，否则依赖关系的顺序可能产生问题

若有 文件 a.c b.c c.c d.c 他们之间的依赖关系是

a文件被b文件依赖，b文件被c文件依赖，b文件被d文件依赖
那么哪个文件被先编译？ 被依赖的最多的那个文件（a或d）应该被先编译。 如何得到正确的编译顺序？

a.c -> b.c -> c.c

d.c ->

1.kahn

//拓扑排序
//无环有向图 是 拓扑排序的前提

//拓扑排序后，顶点所依赖的前驱节点必定都先出现再他前面（这种序列叫做 拓扑序列）
//只要满足上述条件的排序输出，都是拓扑序列（所以一个图往往会有多个拓扑序）（这种排序过程叫做 拓扑排序）
//
//拓扑排序再生活中的应用，比如任务的依赖关系，被依赖的基层任务应该先完成，比如穿几件衣服，一定是先把穿在里面的衣服穿了以后，再穿外面的外套
public class TopologicalKahn {
    Digraph dg;
    List<Integer> order;                //顶点的拓扑顺序
    int[] inDegree;

    public TopologicalKahn(Digraph dg) {
        this.dg = dg;
        //Kahn 算法，获取拓扑排序
        //1.统计所有顶点入度
        //2.将入度为0的作为起点，加入到queue
        //3.从queue中取出顶点，直到队列为空，将该顶点所指向的顶点入度-1，如果入度=0，则加入队列，循环第三步

        //存在环时：输出的顶点数量少于有向图中的顶点数量，或到最后结束循环时，还存在有入度不为0的顶点

        order = new LinkedList<>();

        //1.
        inDegree = new int[dg.v()];
        for (int u = 0; u < dg.v(); u++) {
            for (int w : dg.adj(u)) {
                inDegree[w]++;
            }
        }

        //2.队列中按 成为0入度 的顺序加入顶点
        Queue<Integer> queue = new LinkedList<>();
        for (int u = 0; u < dg.v(); u++)
            if (inDegree[u] == 0)
                queue.add(u);

        //3.
        while (!queue.isEmpty()) {
            int u = queue.remove();
            order.add(u);
            for (int w : dg.adj(u)) {
                inDegree[w]--;
                if (inDegree[w] == 0)   //若入度不为0，说明还有其他指向该点的边
                    queue.add(w);
            }
        }

        //4.若最终输出的入度为0的顶点个数小于 原来有向图中顶点个数，说明存在环
        if(order.size() < dg.v())
            order = null;

        this.dg = null;
    }

    public boolean isDAG() {                //是有向无环图吗？
        return null != order;
    }

    public Iterable<Integer> getOrder() {
        return order;
    }

    public static void main(String[] args) {
        List<String> books = new LinkedList<>();
        books.add("a.c");
        books.add("b.c");
        books.add("c.c");
        books.add("d.c");
        SymblowDigraph sd = new SymblowDigraph(books);
        sd.addEdge("a.c", "b.c");
        sd.addEdge("b.c", "c.c");
        sd.addEdge("d.c", "b.c");


        //编译时 a文件被b文件依赖，b文件被c文件依赖，b文件被d文件依赖
        //那么哪个文件被先编译？ 被依赖的最多的那个文件（a或d）应该被先编译。 如何得到正确的编译顺序？
        // a.c -> b.c -> c.c
        // d.c ->

        Digraph dg = sd.getGraph();
        TopologicalKahn top = new TopologicalKahn(dg);
        if (top.isDAG()) {
            System.out.println("拓扑序列. 文件优先编译顺序（被依赖深度高的先被编译）");
            for (int i : top.getOrder()) {
                System.out.println(" " + sd.getSymblow(i));
            }
        }
    }
}

输出

拓扑序列. 文件优先编译顺序（被依赖深度高的先被编译）
 a.c
 d.c
 b.c
 c.c

2.深度优先+逆后序

将原有向图，用深度优先，求得顶点的逆后序即可

若原图为 a->b->c<-d

先看深度优先的调用堆栈(起点从顶点a遍历到d，若碰到已经访问过的顶点，则跳过不访问，访问后需要将该顶点标记为已访问）

a

 b

  c

  c

 b

a

d

d

调用堆栈每深入一次，前面加一个空格

在说后序：指的是，从调用堆栈退出时将顶点放入队列

那上面的例子就是

a

 b

  c

  c - 1

 b - 2 

a - 3

d

d - 4

得到的序列为 cbad

然后将该顺序求逆向输出，得到  dabc

dabc就是一条符合原有向图的拓扑排序

  

//拓扑排序
//无环有向图 是 拓扑排序的前提

//拓扑排序后，顶点所依赖的前驱节点必定都先出现再他前面（这种序列叫做 拓扑序列）
//只要满足上述条件的排序输出，都是拓扑序列（所以一个图往往会有多个拓扑序）（这种排序过程叫做 拓扑排序）
//
//拓扑排序再生活中的应用，比如任务的依赖关系，被依赖的基层任务应该先完成，比如穿几件衣服，一定是先把穿在里面的衣服穿了以后，再穿外面的外套
public class Topological {
    Digraph dg;
    DirectedCycle dc;
    DFOrder dfo;　　　　　　　　　　　　　　　　　//逆有向图
    Iterable<Integer> order;                //顶点的拓扑顺序

    public Topological(Digraph dg) {
        this.dg = dg;
        dc = new DirectedCycle(dg);
        if (!dc.hasCycle()) {               //若存在环，则不计算拓扑排序
            dfo = new DFOrder(dg);
            order = dfo.reversePost();      //拓扑排序会用到深度优先
        }
        this.dg = null;
    }

    public boolean isDAG() {                //是有向无环图吗？
        return null != order;
    }

    public Iterable<Integer> getOrder() {
        return order;
    }

    public static void main(String[] args) {
        List<String> books = new LinkedList<>();
        books.add("小鱼");
        books.add("泥巴");
        books.add("赵家六");
        books.add("虾子");
        books.add("大鱼");
        books.add("牧羊犬");
        books.add("饲料");
        books.add("廉价劳动力");
        SymblowDigraph sd = new SymblowDigraph(books);
        sd.addEdge("泥巴", "虾子");
        sd.addEdge("虾子", "小鱼");
        sd.addEdge("饲料", "小鱼");
        sd.addEdge("小鱼", "大鱼");
        sd.addEdge("小鱼", "廉价劳动力");
        sd.addEdge("小鱼", "牧羊犬");
        sd.addEdge("大鱼", "牧羊犬");
        sd.addEdge("廉价劳动力", "牧羊犬");
        sd.addEdge("大鱼", "赵家六");
        sd.addEdge("牧羊犬", "赵家六");
        sd.addEdge("廉价劳动力", "赵家六");
        //泥巴被虾子吃，虾子被小鱼吃，饲料被小鱼吃，小鱼被大鱼吃，小鱼被牧羊犬吃，小鱼被廉价劳动力吃，大鱼被牧羊犬吃，大鱼被赵家六吃，廉价劳动力被牧羊犬吃，牧羊犬被赵家六吃，廉价劳动力被赵家六吃
        //那么整个食物链的低端（被依赖）到顶端的关系是？

        Digraph dg = sd.getGraph();
        Topological top = new Topological(dg);
        if (top.isDAG()) {
            System.out.println("拓扑序列. 被依赖的靠近顶行(并行被依赖的话，前后顺序不重要)");
            for (int i : top.getOrder()) {
                System.out.println(" " + sd.getSymblow(i));
            }
        }
    }
}

产生逆后序

//基于深度优先的顶点排序
public class DFOrder {
    Digraph dg;
    boolean[] marked;
    Queue<Integer> pre;             //前序
    Queue<Integer> post;            //后序
    Stack<Integer> reversePost;     //逆后序

    public DFOrder(Digraph dg) {
        this.dg = dg;
        marked = new boolean[dg.v()];
        pre = new ArrayDeque<>();
        post = new ArrayDeque<>();
        reversePost = new Stack<>();
        for (int u = 0; u < dg.v(); u++) {
            if (!marked[u]) {
                dfs(u);
            }
        }
        this.dg = null;
    }

    private void dfs(int u) {
        pre.add(u);
        marked[u] = true;
        for (int v : dg.adj(u)) {
            if (!marked[v])
                dfs(v);
        }
        post.add(u);
        reversePost.add(u);
    }

    public Iterable<Integer> pre() {
        return pre;
    }

    public Iterable<Integer> post() {
        return post;
    }

    public Iterable<Integer> reversePost() {
        List<Integer> rpList = new ArrayList<>();
        while(reversePost.size() > 0){
            rpList.add(reversePost.pop());
        }
        return rpList;
    }

    public static void main(String[] args) {
    }
}

输出：

拓扑序列. 被依赖的靠近顶行(并行被依赖的话，前后顺序不重要)
 饲料
 泥巴
 虾子
 小鱼
 大鱼
 廉价劳动力
 牧羊犬
 赵家六

2.2. 另一种基于深度优先逆后序的写法：

（可能会直白好理解一些，没有封装太多，专注在逻辑上）

//拓扑排序
//无环有向图 是 拓扑排序的前提

//拓扑排序后，顶点所依赖的前驱节点必定都先出现再他前面（这种序列叫做 拓扑序列）
//只要满足上述条件的排序输出，都是拓扑序列（所以一个图往往会有多个拓扑序）（这种排序过程叫做 拓扑排序）
//
//拓扑排序再生活中的应用，比如任务的依赖关系，被依赖的基层任务应该先完成，比如穿几件衣服，一定是先把穿在里面的衣服穿了以后，再穿外面的外套
public class TopologicalDFSAndCyc {
    Digraph dg;
    Stack<Integer> reversePostorder;  //顶点的逆后序
    LinkedList<Integer> order;        //顶点的拓扑顺序
    boolean[] inStack;
    boolean[] marked;

    public TopologicalDFSAndCyc(Digraph dg) { //拓扑排序会用到深度优先的逆后序
        this.dg = dg;
        inStack = new boolean[dg.v()];
        marked = new boolean[dg.v()];
        reversePostorder = new Stack<>();    //看是否存在环（dfs调用顺序的堆栈上出现了重复,则说明存在环,那么该引用赋为null)

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

        if (reversePostorder != null) {
            order = new LinkedList<>();
            while (!reversePostorder.isEmpty())
                order.add(reversePostorder.pop()); //将逆后序输出为正向
        }

        this.dg = null;
    }

    private void dfs(int v) {
        inStack[v] = true;
        marked[v] = true;
        for (int u : dg.adj(v)) {
            if (reversePostorder == null)   //已经检测到环存在了，跳出循环
                break;
            if (inStack[u]) {               //dfs调用轨迹上存在相同节点，说明存在环
                reversePostorder = null;
            } else if (!marked[u]) {
                dfs(u);                     //对未访问过的顶点访问
            }
        }
        if (reversePostorder != null)       //还未检测到环，则加入当前顶点到逆后序
            reversePostorder.push(v);
        inStack[v] = false;
    }

    public boolean isDAG() {                 //是有向无环图吗？(没有环存在吗？)
        return null != order;
    }

    public Iterable<Integer> getOrder() {
        return order;
    }

    public static void main(String[] args) {
        List<String> books = new LinkedList<>();
        books.add("a.c");
        books.add("b.c");
        books.add("c.c");
        books.add("d.c");
        SymblowDigraph sd = new SymblowDigraph(books);
        sd.addEdge("a.c", "b.c");
        sd.addEdge("b.c", "c.c");
        sd.addEdge("d.c", "b.c");

        //编译时 a文件被b文件依赖，b文件被c文件依赖，b文件被d文件依赖
        //那么哪个文件被先编译？ 被依赖的最多的那个文件（a或d）应该被先编译。 如何得到正确的编译顺序？
        // a.c -> b.c -> c.c
        // d.c ->

        //1.
        Digraph dg = sd.getGraph();
        TopologicalDFSAndCyc top = new TopologicalDFSAndCyc(dg);
        if (top.isDAG()) {
            System.out.println("拓扑序列. 被依赖深度高的靠近顶行");
            for (int i : top.getOrder()) {
                System.out.println(" " + sd.getSymblow(i));
            }
        }

        //2.加入一个环，看输出
        sd.addEdge("c.c", "a.c");
        dg = sd.getGraph();
        top = new TopologicalDFSAndCyc(dg);
        System.out.println("top.isDAG() " + top.isDAG());
        if (top.isDAG()) {
            System.out.println("拓扑序列. 被依赖深度高的靠近顶行");
            for (int i : top.getOrder()) {
                System.out.println(" " + sd.getSymblow(i));
            }
        }
    }
}

输出：

拓扑序列. 被依赖深度高的靠近顶行
 d.c
 a.c
 b.c
 c.c
top.isDAG() false

关于深度优先得到拓扑排序的方式有2种

1. 将原图求逆图，然后用深度优先，输出后序

2.不将原图求逆图，用深度优先，输出逆后序

举个例子

原图 a->b->c

方法1.

从a遍历到c

a<-b<-c

a

a - 1

b

b - 2

c

c - 3

输出序列为 abc

方法2.

从a遍历到c

a

 b

  c

  c - 3

 b - 2 

a - 1

输出序列 abc

所以这两种方式是一样的

从方法2的角度来看方法1，只不过是在每层深度遍历的时候，其逆序（堆栈），被先准备好的逆图搞定了后序的输出顺序

从方法1的角度来看方法2，不过是在每次深度遍历的时候，用堆栈实现了方法1用逆图实现的后序的逆