Course Schedule II

                            Solution in C :

int cmpfunc(const void* a, const void* b){
    int* arr1 = *(int**)a;
    int* arr2 = *(int**)b;
    
    return arr1[1] - arr2[1];
}

int BTS(int** arr, int arrSize, int val){
    int left = 0, right = arrSize-1;
    int mid;
    while(left < right){
        mid = left + (right - left)/2 ;
        if(arr[mid][1] >= val)
            right = mid;
        else
            left = mid + 1;
    }
    if(arr[left][1] == val)
        return left;
    else
        return -1;
}

int* findOrder(int numCourses, int** prerequisites, int prerequisitesSize, int* prerequisitesColSize, int* returnSize){
    int* prereqCn = calloc(numCourses , sizeof(int));
    for(int i = 0; i < prerequisitesSize; i++){
        prereqCn[ prerequisites[i][0] ]++;
    }
    //depend test case : queue can be smaller 
    int* queue = malloc(1000 * sizeof(int));
    int Qidx  = 0;
    for(int i = 0; i < numCourses; i++){
        if(prereqCn[i] == 0){
            queue[Qidx] = i;
            Qidx++;
        }
    }
    if(prerequisitesSize > 0)
        qsort(prerequisites, prerequisitesSize, sizeof(int*), cmpfunc);
    int* ans = malloc( numCourses * sizeof(int)) ;
    int andIdx = 0;
    while(Qidx){
        Qidx--;
        int val = queue[Qidx];
        ans[andIdx] = val;
        andIdx++;
        if(prerequisitesSize > 0){
            int k = BTS(prerequisites, prerequisitesSize, val);
            if(k != -1){
                while(k < prerequisitesSize && prerequisites[k][1] == val){
                    prereqCn[ prerequisites[k][0] ]--;
                    if( prereqCn[ prerequisites[k][0] ] == 0  ){
                        queue[Qidx] = prerequisites[k][0] ;
                        Qidx++;  
                    }
                    k++;
                }
            }
        }
    }
    //if collision happen, then no ans
    if(andIdx != numCourses){
        *returnSize = 0;
        free(ans);
        return NULL;
    }
    else
        *returnSize = numCourses;
    return ans;
}
                        

                        Solution in C++ :

typedef vector<vector<int>> vvi;
typedef vector<int> vi;
class Solution {
private:
    void dfs(int s, vvi& graph, vi& pro, vi& res, bool& cycle) {
        if (pro[s] > 0) {
            if (pro[s] == 1) cycle = true;
            return;
        }
        pro[s] = 1;
        for (int u: graph[s]) dfs(u, graph, pro, res, cycle);
        pro[s] = 2;
        res.push_back(s);
    }

public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vvi graph(numCourses);
        vi pro(numCourses);
        vi res, buf;
        bool cycle = false;

        for (int i = 0; i < prerequisites.size(); i++) {
            int a = prerequisites[i][0], b = prerequisites[i][1];
            graph[b].push_back(a);
        }

        for (int i = 0; i < numCourses; i++) {
            dfs(i, graph, pro, res, cycle);
            if (cycle == true) return buf;
        }

        reverse(res.begin(), res.end());
        return res;
    }
};
                    

                        Solution in Java :

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
       int[] indegree = new int[numCourses];
       boolean[] visited = new boolean[prerequisites.length];
       boolean[] done = new boolean[numCourses];
       int[] res = new int[numCourses];

       for (int[] p : prerequisites) {
           indegree[p[1]]++;
       }
       int index = 0;
        boolean hasNewVertex = true;
        while(hasNewVertex) {
            hasNewVertex = false;
            for (int i = 0; i < prerequisites.length; i++) {
                if (!visited[i]) {
                    int cur = prerequisites[i][0];
                    int pre = prerequisites[i][1];
                    if (indegree[cur] == 0) { 
                        // start from indegree == 0, cut edges, until no indegree = 0
                        visited[i] = true;
                        indegree[pre]--;
                        hasNewVertex = true;
                        if(!done[cur]){
                            done[cur] = true;
                            res[index++] = cur;
                        }
                    }
                }
            }
        }

        for (int i = 0 ; i < numCourses; i++) {
            if (!done[i]) {
                res[index++] = i;
            }
        }
        
        for (int i = 0; i < numCourses/2; i++) {
            int temp = res[i];
            res[i] = res[numCourses-1-i];
            res[numCourses-1-i] = temp;
        }

        for (int i = 0; i < numCourses; i++) {
            if (indegree[i] != 0) {
                return new int[]{};
            }
        }

        return res;
    }
}
                    

                        Solution in Python : 
                            
class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        graph = {}
        
        for i in range(numCourses):
            graph[i]=[]
        
        for c,pc in prerequisites:
            graph[c].append(pc)
            
        ans = []
        finallyVisited=set()
        visited = set()
        def dfs(course):
            if course in visited:
                return False
            
            if course in finallyVisited:
                return True
            
            visited.add(course)

            for nei in graph[course]:
                if not dfs(nei):
                    return False
            
            ans.append(course)
            finallyVisited.add(course)
            visited.remove(course)
            return True


        for key,val in graph.items():
            if not dfs(key):
                return []

        return ans