Completed BFS-1

Leetcode102.java

@@ -0,0 +1,76 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ * int val;
+ * TreeNode left;
+ * TreeNode right;
+ * TreeNode() {}
+ * TreeNode(int val) { this.val = val; }
+ * TreeNode(int val, TreeNode left, TreeNode right) {
+ * this.val = val;
+ * this.left = left;
+ * this.right = right;
+ * }
+ * }
+ */
+class Solution {
+    // Solution 1 - Using List of list and having a level variable
+    // TC - O(n)
+    // SC - O(1)
+    // List<List<Integer>> res;
+
+    // public List<List<Integer>> levelOrder(TreeNode root) {
+    // this.res = new ArrayList<>();
+    // helper(root, 1);
+    // return res;
+    // }
+
+    // private void helper(TreeNode node, int level) {
+    // // Base
+    // if (node == null)
+    // return;
+
+    // // Logic
+    // if (level > res.size()) {
+    // List<Integer> li = new ArrayList<>();
+    // res.add(li);
+    // }
+    // res.get(level - 1).add(node.val);
+
+    // // Left
+    // helper(node.left, level + 1);
+
+    // // Right
+    // helper(node.right, level + 1);
+    // }
+
+    // Solution 2 - Using DFS and maintaining the size at the start of each level.
+    // TC - O(n)
+    // SC - O(n)
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (root == null)
+            return res;
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+
+        while (!q.isEmpty()) {
+            int size = q.size();
+            List<Integer> curr = new ArrayList<>();
+            for (int i = 0; i < size; i++) {
+                TreeNode node = q.poll();
+                curr.add(node.val);
+
+                if (node.left != null)
+                    q.add(node.left);
+                if (node.right != null)
+                    q.add(node.right);
+            }
+
+            res.add(curr);
+
+        }
+
+        return res;
+    }
+}

Leetcode207.java

@@ -0,0 +1,55 @@
+// Solution - Topological Sort using BFS
+// TC: O(V + E) where V is number of courses and E is number of prerequisites
+// SC: O(V + E) for storing the graph and in-degrees
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+
+        int[] inDegrees = new int[numCourses];
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        int totalCoursePresent = 0;
+        for (int[] pre : prerequisites) {
+            int dep = pre[0];
+            int indep = pre[1];
+
+            if (!map.containsKey(indep)) {
+                map.put(indep, new ArrayList<>());
+            }
+            map.get(indep).add(dep);
+            inDegrees[dep]++;
+            totalCoursePresent++;
+
+        }
+        if (totalCoursePresent == 0)
+            return true;
+
+        Queue<Integer> q = new LinkedList<>();
+        int courseTaken = 0;
+        for (int i = 0; i < numCourses; i++) {
+            if (inDegrees[i] == 0) {
+                q.add(i);
+                courseTaken++;
+            }
+        }
+        if (q.isEmpty())
+            return false;
+
+        while (!q.isEmpty()) {
+            int size = q.size();
+            int curr = q.poll();
+            List<Integer> currDeps = map.get(curr);
+            if (currDeps != null) {
+                for (int dep : currDeps) {
+                    inDegrees[dep]--;
+                    if (inDegrees[dep] == 0) {
+                        q.add(dep);
+                        courseTaken++;
+                        if (numCourses == courseTaken)
+                            return true;
+                    }
+                }
+            }
+        }
+        return false;
+
+    }
+}