(番外)使用DFS和BFS实现拓扑排序

1.BFS实现

public class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] incLinkCounts = new int[numCourses];
        List<List<Integer>> adjs = new ArrayList<>(numCourses);
        initialiseGraph(incLinkCounts, adjs, prerequisites);
    //return solveByBFS(incLinkCounts, adjs);
        return solveByBFS(incLinkCounts,adjs);
    }

    private void initialiseGraph(int[] incLinkCounts, List<List<Integer>> adjs, int[][] prerequisites){
        int n = incLinkCounts.length;
        while (n-- > 0) adjs.add(new ArrayList<>());
        for (int[] edge : prerequisites) {
            incLinkCounts[edge[0]]++;
            adjs.get(edge[1]).add(edge[0]);
        }
   }

   private int[] solveByBFS(int[] incLinkCounts, List<List<Integer>> adjs){
       int[] order = new int[incLinkCounts.length];
       Queue<Integer> toVisit = new ArrayDeque<>();
       for (int i = 0; i < incLinkCounts.length; i++) {
           if (incLinkCounts[i] == 0) toVisit.offer(i);
            }
       int visited = 0;
       while (!toVisit.isEmpty()) {
           int from = toVisit.poll();
           order[visited++] = from;
           for (int to : adjs.get(from)) {
               incLinkCounts[to]--;
               if (incLinkCounts[to] == 0) toVisit.offer(to);
           }
       }
    return visited == incLinkCounts.length ? order : new int[0];
   }
}

2.DFS实现

public class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] incLinkCounts = new int[numCourses];
        List<List<Integer>> adjs = new ArrayList<>(numCourses);
        initialiseGraph(incLinkCounts, adjs, prerequisites);
    //return solveByBFS(incLinkCounts, adjs);
        return  solveByDFS(adjs);
    }

    private void initialiseGraph(int[] incLinkCounts, List<List<Integer>> adjs, int[][] prerequisites){
        int n = incLinkCounts.length;
        while (n-- > 0) adjs.add(new ArrayList<>());
        for (int[] edge : prerequisites) {
            incLinkCounts[edge[0]]++;
            adjs.get(edge[1]).add(edge[0]);
        }
   }

   private int[] solveByBFS(int[] incLinkCounts, List<List<Integer>> adjs){
       int[] order = new int[incLinkCounts.length];
       Queue<Integer> toVisit = new ArrayDeque<>();
       for (int i = 0; i < incLinkCounts.length; i++) {
           if (incLinkCounts[i] == 0) toVisit.offer(i);
            }
       int visited = 0;
       while (!toVisit.isEmpty()) {
           int from = toVisit.poll();
           order[visited++] = from;
           for (int to : adjs.get(from)) {
               incLinkCounts[to]--;
               if (incLinkCounts[to] == 0) toVisit.offer(to);
           }
       }
    return visited == incLinkCounts.length ? order : new int[0];
   }

   private int[] solveByDFS(List<List<Integer>> adjs) {
       BitSet hasCycle = new BitSet(1);
       BitSet visited = new BitSet(adjs.size());
       BitSet onStack = new BitSet(adjs.size());
       Deque<Integer> order = new ArrayDeque<>();
       for (int i = adjs.size() - 1; i >= 0; i--) {
           if (visited.get(i) == false && hasOrder(i, adjs, visited, onStack, order) == false) return new int[0];
       }
       int[] orderArray = new int[adjs.size()];
       for (int i = 0; !order.isEmpty(); i++) orderArray[i] = order.pop();
       return orderArray;
   }

private boolean hasOrder(int from, List<List<Integer>> adjs, BitSet visited, BitSet onStack, Deque<Integer> order) {
    visited.set(from);
    onStack.set(from);
    for (int to : adjs.get(from)) {
        if (visited.get(to) == false) {
            if (hasOrder(to, adjs, visited, onStack, order) == false) return false;
        } else if (onStack.get(to) == true) {
            return false;
        }
    }
    onStack.clear(from);
    order.push(from);
    return true;
   }
}