completed BFS-1

BinaryTreeLevelOrderTraversal.java

@@ -0,0 +1,67 @@
+/**
+ * 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 {
+//     List<List<Integer>> result = new ArrayList<>();
+//     public List<List<Integer>> levelOrder(TreeNode root) {
+//         // dfs - recursive
+//         helper(root, 0);
+//         return result;
+//     }
+
+//     private void helper(TreeNode root, int level)
+//     {
+//         if(null == root) return;
+//         if(level == result.size())
+//         {
+//             result.add(new ArrayList<>());
+//         }
+//         result.get(level).add(root.val);
+//         helper(root.left, level+1);
+//         helper(root.right, level+1);
+//     }
+// }
+
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        // bfs
+        if(null == root) return new ArrayList<>();
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        List<List<Integer>> result = new ArrayList<>();
+
+        while(!queue.isEmpty())
+        {
+            int size = queue.size();
+            List<Integer> list = new ArrayList<>();
+            for(int i = 0; i < size; i++)
+            {
+                TreeNode newNode = queue.poll();
+                list.add(newNode.val);
+                if(null != newNode.left)
+                {
+                    queue.add(newNode.left);
+                }
+                if(null != newNode.right)
+                {
+                    queue.add(newNode.right);
+                }
+            }
+            result.add(list);
+        }
+
+        return result;
+    }
+}

CourseSchedule.java

@@ -0,0 +1,55 @@
+
+class CourseSchedule {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        // use - adjacency matrix of independent(b) and dependent(a) - map
+        // and indegree array for each vetex/course
+        // and use queue to track completing courses with no or prerequisites finished
+
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        int[] indegree = new int[numCourses];
+        for(int i = 0; i < prerequisites.length; i++)
+        {
+            int inde = prerequisites[i][0];
+            int dep = prerequisites[i][1];
+            if(!map.containsKey(inde))
+            {
+                map.put(inde, new ArrayList<>());
+            }
+            map.get(inde).add(dep);
+            indegree[dep]++;
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int count = 0;
+        for(int i = 0; i < numCourses; i++)
+        {
+            if(0 == indegree[i])
+            {
+                queue.add(i);
+                count++;
+            }
+        }
+        if(0 == count) return false;
+        if(numCourses == count) return true;
+
+        while(!queue.isEmpty())
+        {
+            int courseDone = queue.poll();
+            List<Integer> dependencies = map.get(courseDone);
+            if(null != dependencies)
+            {
+                for(int course : dependencies)
+                {
+                    indegree[course]--;
+                    if(0 == indegree[course])
+                    {
+                        queue.add(course);
+                        count++;
+                        if(count == numCourses) return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+}