拓扑排序入门和算法题模板

概念

拓扑排序：在有向图中，将节点进行排序，使得后面的节点不会指向前面节点。

如果最后有节点指向前面，表示图有环，不存在拓扑排序。

算法模板

拓扑算法常用来解决优先度限制下的调度问题，如：

先统计所有节点的入度，删除入度为0的节点，然后把这个节点指向的节点的入度减一，一直做改操作，直到所有的节点都被分离出来，如果最后存在入度不为0的节点，则表示有环。

1.计算每个节点的入度，使用数组保存；
2.创建一个集合储存满足拓扑排序的节点；
3.创建一个队列，保存入度为0的节点；
3.依次取出队列中入度为0的节点，获取这些节点的指向节点，将这些节点的入度-1，如果这些指向节点入度更新后为0，则将这些新节点加入队列；
4.当队列为空时，判断满足拓扑排序的节点数是否等于题目中给出的优先级数，如果相等则返回true。

当然拓扑排序可以判断一个图是否有环，最后判断满足拓扑排序元素的个数是否等于图中的节点数即可。

模板如下：时间复杂度为O(E+V)，E为边数，V为节点数，空间复杂度为O(V)

class Solution {
    public boolean hasCircle() {
        int n = 10;//有向图的节点数，这里使用10来模拟，按照题目要求自己替换
        int[][] edges;//表示有向图的边和节点(这里没初始化了)，edges[0]->edges[1]

        //1.创建一个数组来储存每个节点的入度
        int[] degrees = new int[n];
        for (int[] edge : edges) {
            degrees[edge[1]]++;
        }

        //2.创建一个队列储存入度为0的节点
        LinkedList queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            if (degrees[i] == 0) {
                queue.add(i);
            }
        }

        //3.创建一个集合保存拓扑排序的元素，然后删除入度为0的节点
        List res = new ArrayList<>();
        while (!queue.isEmpty()) {
            int node = queue.removeFirst();
            res.add(node);
            //将与node相连的节点的入度-1
            for (int i = 0; i < edges.length; i++) {
                if (edges[i][0] == node) {
                    degrees[edges[i][1]]--;
                    //加入入度为0的新节点
                    if (degrees[edges[i][1]] == 0) {
                        queue.add(edges[i][1]);
                    }
                }
            }
        }

        //4.判断满足拓扑排序的元素和是否等于图的节点数
        return n == res.size();
    }
}

模板使用

1.207. 课程表

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        if (numCourses <= 0) return false;
        int len = prerequisites.length;
        if (len == 0) return true;

        //创建一个入度数组
        int[] degrees = new int[numCourses];
        for (int i = 0; i < len; i++) {
            degrees[prerequisites[i][0]]++;
        }

        //创建一个队列储存入度为0的节点
        LinkedList list = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (degrees[i] == 0)
                list.add(i);
        }

        //创建一个集合保存拓扑排序
        List res = new ArrayList<>();
        while (!list.isEmpty()) {
            //弹出入度为0的节点
            int node = list.removeFirst();
            //加入拓扑排序结果
            res.add(node);
            //找到node的指向节点
            for (int i = 0; i < len; i++) {
                if (prerequisites[i][1] == node) {
                    degrees[prerequisites[i][0]]--;
                    //将为0的节点加入集合
                    if (degrees[prerequisites[i][0]] == 0) {
                        list.add(prerequisites[i][0]);
                    }
                }
            }
        }
        return res.size() == numCourses;
    }
}

2.210.课程表II

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        if (numCourses <= 0) return false;
        int len = prerequisites.length;
        if (len == 0) return true;

        //创建一个入度数组
        int[] degrees = new int[numCourses];
        for (int i = 0; i < len; i++) {
            degrees[prerequisites[i][0]]++;
        }

        //创建一个队列储存入度为0的节点
        LinkedList list = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (degrees[i] == 0)
                list.add(i);
        }

        //创建一个集合保存拓扑排序
        List res = new ArrayList<>();
        while (!list.isEmpty()) {
            //弹出入度为0的节点
            int node = list.removeFirst();
            //加入拓扑排序结果
            res.add(node);
            //找到node的指向节点
            for (int i = 0; i < len; i++) {
                if (prerequisites[i][1] == node) {
                    degrees[prerequisites[i][0]]--;
                    //将为0的节点加入集合
                    if (degrees[prerequisites[i][0]] == 0) {
                        list.add(prerequisites[i][0]);
                    }
                }
            }
        }
        return res.size() == numCourses;
    }
}