leetcode课程排序

图的表示方法：

（1）邻接矩阵表示方法

	0	1	2	3	4	5	6
0	0	1	2	0	0	0	0
1	1	0	1	1	0	0	0
2	1	1	0	0	1	0	0
3	0	1	0	0	1	0	0
4	0	0	1	1	0	1	0
5	0	0	0	0	1	0	1
6	0	0	0	0	0	1	0

（2）邻接表表示方法

0	1	2
1	0	2	3
2	0	1	4
3	1	4
4	2	3	5
5	4	6
6	5

（3）边缘列表表示方法

0	0	1
1	0	2
2	1	2
3	1	3
4	3	4
5	2	4
6	4	5
7	5	6

ArrayList , LinkedList, List的区别：

List是一个接口，ArrayList, LinkedList分别是用两种不同的数据结构实现的两个类：

ArrayList是用数组实现的， LinkedList是用链表实现的。

在做实际项目的时候一般用List list = new ArrayList; 而不直接使用 ArrayList = new ArrayList；原因如下：

ArrayList是一个类，LIst是一个借口。ArrayList实现并继承了List。

List list = new ArrayList()；这句创建了一个ArrayList对象以后上溯到了List。此时他是一个List对象了，有些ArrayList有但是List没有的属性和方法，他就不能在用了。

List有多个实现类，如LinkedList或者Vector等等，现在用的是ArrayList，也许哪一天就需要换成其他的实现类。这时就只需要改变这一行：List list = new ArrayList();就可以了。

其他使用list地方的代码根本不需要改动

题目描述：

现在你总共有 n 门课程需要修，记为 0 ~ n-1 。

在选修某些课程之前需要一些先修课程。例如，想要学习课程 0 ，你需要先完成课程 1， 我们用一个匹配来表示他们：【0，1】

给定课程总量以及他们的先决条件，判断是否可能完成所有课程的学习。

示例1：

输入：2，【【1，0】】

输出：true

解释：总共有2门课程，学习课程 1 之前需要先学习课程 0。

这是一道拓扑排序的题，挺简单的。直接上代码。

public boolean canFinish(int numCourses,int[][] prerequisites) {
        if(numCourses<=0) {
            return false;
        }
        int len=prerequisties.length();
        if(len==0) {
            return true;
        }
        int[] inDegree=new int[numCourses];
        for(int[] p:prerequistes) {
            inDegree[p[0]]++;
        }
        LinkedList<Integer> queue = new LinkedList<>();
        for(int i=0;i<numCourses;i++) {
            if(inDegree[i]==0) {
                queue.addLast(i);
            }
        }
        List<Integer> res = new ArrayList<>();
        while(!queue.isEmpty()) {
            Integer num = queue.removeFirst();
            res.add(num);
            for(int[] p:prerequisites) {
                if(p[1]==num) {
                    inDegree[p[0]]--;
                    if(inDegree[p[0]]==0) {
                        queue.addLast(p[0]);
                    }
                }
            }
        }
        return numCourses == res.length();
    }