solution to BFS 1

course-schedule.py

@@ -0,0 +1,48 @@
+# Time Complexity: O(V+E) V is the number of courses (vertices) and E is the number of prerequisites (edges)
+# Space Complexity: O(V+E)
+# Did this code successfully run on Leetcode : Yes
+
+
+from collections import defaultdict,deque
+class Solution(object):
+    def canFinish(self, numCourses, prerequisites):
+        """
+        :type numCourses: int
+        :type prerequisites: List[List[int]]
+        :rtype: bool
+        """
+        ndeg=[0]*numCourses
+        adjlist=defaultdict(list)
+        c=0
+        queue= deque()
+
+        for n in prerequisites:
+            ndeg[n[0]]+=1
+            adjlist[n[1]].append(n[0])
+
+        for i in range(numCourses):
+            if ndeg[i]==0:
+                c+=1
+                queue.append(i)
+
+        if c==numCourses: return True
+
+        while queue:
+            node = queue.popleft()
+
+            for neighbor in adjlist[node]:
+                ndeg[neighbor]-=1
+                if ndeg[neighbor]==0:
+                    queue.append(neighbor)
+                    c+=1
+
+                if c==numCourses:
+                    return True
+
+        return False
+
+
+
+
+
+

level-order-traversal.py

@@ -0,0 +1,41 @@
+# Time Complexity: O(n) 
+# Space Complexity: O(n)
+# Did this code successfully run on Leetcode : Yes
+
+from collections import deque
+# Definition for a binary tree node.
+class TreeNode(object):
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution(object):
+    def levelOrder(self, root):
+        """
+        :type root: Optional[TreeNode]
+        :rtype: List[List[int]]
+        """
+        res=[]
+        level=0
+        if root==None:
+            return res
+        queue=deque([root])
+
+        while queue:
+            res.append([])
+            level_elements=len(queue)
+
+            for i in range(level_elements):
+                popped = queue.popleft()
+                res[level].append(popped.val)
+                if popped.left: 
+                    queue.append(popped.left)
+                if popped.right:
+                    queue.append(popped.right)
+            level+=1
+
+        return res
+
+
+