拓扑排序

package com.example.demo.code60;


import com.example.demo.code10.queue.Queue;

/**
 * @author ming
 * @create 2022/6/10
 * @description:
 */
public class Digraph {
    //顶点数目
    private int v;
    //边的数目
    private int E;
    //邻接表
    private Queue<Integer>[] adj;
    public Digraph(int v) {
        this.v = v;
        this.E = 0;
        this.adj = new Queue[v];
        for (int i = 0; i < adj.length; i++) {
            adj[i] = new Queue<Integer>();
        }
    }
    public void addEdge(int v,int w){
        adj[v].enqueue(w);
        E++;
    }
    public int v(){
        return v;
    }
    public int E(){
        return E;
    }
    public Queue<Integer> adj(int v){
        return adj[v];
    }
    public  Digraph reverse(){
        Digraph reverseGraph = new Digraph(v);
        for (int i = 0; i < v; i++) {
            for (int integer : adj[i]) {
                reverseGraph.addEdge(integer,i);
            }
        }
        return reverseGraph;
    }
}

package com.example.demo.code60;

import com.example.demo.code10.queue.Queue;
import com.example.demo.code10.stack.Stack;

/**
 * @author ming
 * @create 2022/6/10
 * @description:
 */
public class DepthFirstOrder {
    private boolean[] marked;
    //使用栈,存储顶点序列
    private Stack<Integer> reversePost;
    //创建一个检测环对象,检测图G中是否有环
    public DepthFirstOrder(Digraph g){
        this.marked = new boolean[g.v()];
        this.reversePost = new Stack<Integer>();
        //遍历图中的每一个顶点,让每个顶点作为入口,完成一次深度优先搜索
        for (int i = 0; i < g.v(); i++) {
            if(!marked[i]){
                dfs(g,i);
            }
        }
    }
    //基于深度优先搜索,进行顶点排序
    private void dfs(Digraph g,int v) {
        marked[v] = true;
        Queue<Integer> adj = g.adj(v);
        for (Integer w : adj) {
            if(!marked[w]){
                dfs(g,w);
            }
        }
        //让顶点v进栈
        reversePost.push(v);
    }
    //获取顶点线性序列
    public Stack<Integer> reversePost(){
        return reversePost;
    }

}

``package com.example.demo.code60;

import com.example.demo.code10.queue.Queue;

/**
 * @author ming
 * @create 2022/6/10
 * @description: 有向环的检测
 */
public class DirectedCycle {
    private boolean [] marked;
    private boolean hasCycle;
    private boolean[] onStack;

    public DirectedCycle(Digraph g) {
        this.marked = new boolean[g.v()];
        this.hasCycle  = false;
        this.onStack = new boolean [g.v()];
        //找到图中每一个顶点,让每一个顶点作为入口,调用一次dfs进行搜索
        for (int i = 0; i < g.v(); i++) {
            if(!marked[i]){
                dfs(g,i);
            }
        }
    }
    private void dfs(Digraph g,int v ) {
        marked[v] = true;
        onStack[v] = true;
        Queue<Integer> adj = g.adj(v);
        for (Integer w : adj) {
            if (!marked[w]) {
                dfs(g,w);
            }
            if(onStack[w]){
                hasCycle = true;
                return ;
            }
        }
        //把当前顶点出栈
        onStack[v] = false;
    }
    public boolean hasCycle(){
        return hasCycle;
    }

}
package com.example.demo.code60;

import com.example.demo.code10.stack.Stack;

/**
 * @author ming
 * @create 2022/6/13
 * @description:
 */
public class TopoLogical {
    private Stack<Integer> order;

    public TopoLogical(Digraph g) {
        DirectedCycle cycle = new DirectedCycle(g);
        //判断g图中没有环
        if(!cycle.hasCycle()){
            DepthFirstOrder depthFirstOrder = new DepthFirstOrder(g);
            order = depthFirstOrder.reversePost();
        }
    }
    private boolean isCycle(){
        return order==null;
    }
    public Stack<Integer> order(){
        return order;
    }

    public static void main(String[] args) {
        Digraph digraph = new Digraph(6);
        digraph.addEdge(0,2);
        digraph.addEdge(0,3);
        digraph.addEdge(2,4);
        digraph.addEdge(3,4);
        digraph.addEdge(4,5);
        digraph.addEdge(1,3);
        TopoLogical logical = new TopoLogical(digraph);
        Stack<Integer> order = logical.order();
        for (Integer integer : order) {
            System.out.print(integer+"->");
        }
        
    }
}