拓扑排序（kahn算法和dfs算法）

1定义

拓扑排序（Topological Sorting）

给定一张 有向无环图 ，排出所有顶点的一个序列A，满足：
对于图中的每一条有向边（x,y）,x在序列A中都出现在y之前，则称A为该图的顶点的一个拓扑序。
如图，{2，3，1，7，5，4，6}，{2，3，5，1，7，4，6}都为合法的拓扑序

拓扑排序是可以判断有向图得中是否有环的，比如环{2，1，7}

2两种拓扑排序算法

2.1kahn算法

该算法类似于宽搜(BFS)，利用队列求解，主要思想是：向队列中压入入度为0的节点，迭代时出队节点，并遍历以该节点为起点的边，找到对应的终点，同时更新终点入度，如果恰好该终点的入度为0，则直接入队。主要利用了din数组，记录每个节点的入度。
迭代过程中，如果图为有向无环图，则迭代对访问所有节点，拓扑序长度等于节点个数，但图中有环的话，那迭代不可能遍历所有的节点（因为环会导致没有新的入度为零的节点入队）

具体实现如下

public class topoSort {
    //邻接表
    List<Integer>[] e;
    //拓扑序列
    List<Integer> tp;
    //度数组 din[i]=m 表示节点i有入度m个
    int[] din;

    public boolean getRes(){
        //有向图
        //节点数量
        int N = 7;
        //边的声明
        List<String> edge = new ArrayList<>();
        edge.add("2,1");
        edge.add("2,7");
        edge.add("1,7");
        edge.add("7,4");
        edge.add("7,6");
        edge.add("3,1");
        edge.add("3,5");
        edge.add("5,6");
        //初始化e
        e = new ArrayList[N+1];
        for(int i = 0;i<N+1;i++){
            e[i] = new ArrayList<Integer>();
        }
        //初始化tp
        tp = new ArrayList<>();
        //初始化din
        din = new int[N+1];

        //注入边信息
        for(String ed:edge){
            String[] arr = ed.split(",");
            int v = Integer.parseInt(arr[0]);
            int u = Integer.parseInt(arr[1]);
            e[v].add(u);
            din[u]++;
        }
        return topoSort();
    }
    //false代表有环
    public boolean topoSort(){
        Deque<Integer> queue = new LinkedList<>();
        //将入度为0的节点入队
        for(int i = 1;i<din.length;i++){
            if(din[i]==0){
                queue.offer(i);
            }
        }

        while(!queue.isEmpty()){
            //节点出队
            int poll = queue.poll();
            tp.add(poll);
            for(int child:e[poll]){
                if(--din[child]==0){
                    //将入度为零的子节点入队
                    queue.offer(child);
                }
            }
        }
        
        //false代表有环 true代表无环
        return tp.size()==din.length;
    }

    public static void main(String[] args) {
        topoSort topoSort = new topoSort();
        boolean res = topoSort.getRes();
    }


}

2.1dfs算法（染色）

不同于kahn算法，深度优先算法将沿着边的方向持续前进，直到尽头。这里主要的利用了visited数组记录节点的访问状态。0 -> -1 ->
1，0状态标识该节点还没被访问；-1节点标识该节点第一次被访问；1标识该节点第2次被访问，可形象成为染色法
算法设计里不是所有节点都能被访问第二次，因为如果算法在遍历过程中发现了环，就会立即返回，返回期间不会再干其他事情（比如更新节点的访问状态等），直到方法整个返回。

具体实现如下

public class topoSort1 {
    //邻接表
    List<Integer>[] e;
    //拓扑序列
    List<Integer> tp;
    //访问状态数组 记录访问状态
    int[] visited;

    public void init(){
        //有向图

        //节点数量
        int N = 7;
        //边的声明
        List<String> edge = new ArrayList<>();
        edge.add("2,1");
        edge.add("2,7");
        edge.add("1,7");
        edge.add("7,4");
        edge.add("7,6");
        edge.add("3,1");
        edge.add("3,5");
        edge.add("5,6");
        //初始化e
        e = new ArrayList[N+1];
        for(int i = 0;i<N+1;i++){
            e[i] = new ArrayList<Integer>();
        }
        //初始化tp
        tp = new ArrayList<>();
        //初始化visited 默认状态为0
        visited = new int[N+1];

        //注入边信息
        for(String ed:edge){
            String[] arr = ed.split(",");
            int v = Integer.parseInt(arr[0]);
            int u = Integer.parseInt(arr[1]);
            e[v].add(u);
        }

    }

    public boolean getRes(){
        for(int i = 1;i<visited.length;i++){
            if(visited[i]==0){
                if(!dfs(i)){
                    return false;
                }
            }
        }
        Collections.reverse(tp);
        return true;
    }

    //false代表有环
    public boolean dfs(int i){
        //首次访问节点 装填由0转为-1 第一次变色
        visited[i] = -1;
        for(int child:e[i]){
            if(visited[child]==0){
                if(!dfs(child)){
                    return false;
                }
            }else if(visited[child]==-1){
                return false;
            }
        }

        //遍历完所有节点并没有环 由-1转为1 第二次变色
        visited[i] = 1;
        //加入topo序列
        tp.add(i);
        return true;
    }

    public static void main(String[] args) {
        topoSort1 topoSort = new topoSort1();
        topoSort.init();
        boolean res = topoSort.getRes();
        System.out.println();
    }