[Function add]

1. Add leetcode solutions.

Author: Seanforfun

README.md

@@ -359,6 +359,8 @@
 
 [206. Reverse Linked List](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/206.%20Reverse%20Linked%20List.md)
 
+[207. Course Schedule](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/207.%20Course%20Schedule.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/206. Reverse Linked List.md

@@ -70,6 +70,7 @@ class Solution {
 ```
 
 ### 二刷
+1. 使用迭代法。
 ```Java
 /**
  * Definition for singly-linked list.
@@ -92,4 +93,36 @@ class Solution {
         return pre;
     }
 }
+```
+
+2. 使用递归法。
+```Java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    ListNode ret = null;
+    public ListNode reverseList(ListNode head) {
+        if(head == null) return head;
+        ListNode tail = reverseNode(head);
+        tail.next = null;
+        return this.ret;
+    }
+    
+    private ListNode reverseNode(ListNode node){
+        if(node.next == null){
+            this.ret = node;
+            return node;
+        }else{
+            ListNode next = reverseNode(node.next);
+            next.next = node;
+            return node;
+        }
+    }
+}
 ```

leetcode/207. Course Schedule.md

@@ -64,4 +64,82 @@ class Solution {
         return count == numCourses;
     }
 }
-```
+```
+
+### 二刷
+1. Method 1： We can use Khan method to solve this question, which is another version of bfs.
+```Java
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        int[] indegree = new int[numCourses];
+        Map<Integer, List<Integer>> adj = new HashMap<>();
+        for(int[] pre : prerequisites){
+            List<Integer> temp = adj.containsKey(pre[0]) ? adj.get(pre[0]) : new ArrayList<Integer>();
+            temp.add(pre[1]);
+            adj.put(pre[0], temp);
+            indegree[pre[1]]++;
+        }
+        LinkedList<Integer> queue = new LinkedList<>();
+        for(int i = 0; i < numCourses; i++){
+            if(indegree[i] == 0)  queue.add(i);
+        }
+        int count = 0;
+        while(!queue.isEmpty()){
+            int pre = queue.poll();
+            count++;
+            if(adj.containsKey(pre)){
+                List<Integer> list = adj.get(pre);
+                for(Integer v : list){
+                    indegree[v]--;
+                    if(indegree[v] == 0)
+                        queue.add(v);
+                }
+            }
+        }
+        return count == numCourses;
+    }
+}
+```
+
+2. Method 2: Use dfs to solve this problem.
+```Java
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        int[] indegree = new int[numCourses];
+        Map<Integer, List<Integer>> adj = new HashMap<>();
+        boolean[] visited = new boolean[numCourses];
+        for(int[] pre : prerequisites){
+            indegree[pre[1]]++;
+            List<Integer> temp = adj.containsKey(pre[0]) ? adj.get(pre[0]): new ArrayList<>();
+            temp.add(pre[1]);
+            adj.put(pre[0], temp);
+        }
+        boolean containsZero = false;
+        for(int i = 0; i < numCourses; i++){
+            if(indegree[i] == 0 && !visited[i]){
+                containsZero = true;
+                dfs(i, indegree, visited, adj);
+            }
+        }
+        if(!containsZero) return false;
+        for(boolean visit : visited){
+            if(!visit) return false;
+        }
+        return true;
+    }
+    private void dfs(int cur, int[] indegree, boolean[] visited, Map<Integer, List<Integer>> adj){
+        visited[cur] = true;
+        if(adj.containsKey(cur)){
+            for(Integer next : adj.get(cur)){
+                indegree[next]--;
+                if(indegree[next] == 0 && !visited[next]){
+                    dfs(next, indegree, visited, adj);
+                }
+            }
+        }
+    }
+}
+```
+
+### Reference
+1. [【图论】有向无环图的拓扑排序](https://www.cnblogs.com/en-heng/p/5085690.html)