init

Author: tiationg-kho

.gitignore

@@ -157,4 +157,6 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+.idea/
+.DS_Store
+**/.DS_Store

README.md

@@ -0,0 +1,28 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        res = []
+        if not root:
+            return root
+        queue = deque([root])
+        while queue:
+            level_count = len(queue)
+            cur_level = []
+            for _ in range(level_count):
+                node = queue.popleft()
+                cur_level.append(node.val)
+                for child in [node.left, node.right]:
+                    if child:
+                        queue.append(child)
+            res.append(cur_level)
+        return res
+    
+# time O(n), due to traversal
+# space O(n), queue can have a size of n/2 or the list's size to store nodes
+# using tree and bfs

[A]tree/[A]tree-bfs/102-binary-tree-level-order-traversal.py

@@ -0,0 +1,31 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        res = []
+        if not root:
+            return res
+        queue = deque([root])
+        while queue:
+            level_count = len(queue)
+            cur_level = []
+            for _ in range(level_count):
+                node = queue.popleft()
+                cur_level.append(node.val)
+                for child in [node.left, node.right]:
+                    if child:
+                        queue.append(child)
+            if len(res) % 2 == 0:
+                res.append(cur_level)
+            else:
+                res.append(cur_level[:: - 1])
+        return res
+    
+# time O(n), due to traverse
+# space O(n), due to queue's size (tree diameter or last level)
+# using tree and bfs

[A]tree/[A]tree-bfs/103-binary-tree-zigzag-level-order-traversal.py

@@ -0,0 +1,22 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+        queue = deque([(root, 1)])
+        while queue:
+            node, level = queue.popleft()
+            for child in [node.left, node.right]:
+                if child:
+                    queue.append((child, level + 1))
+        return level
+    
+# time O(n), due to bfs
+# space O(n), due to queue's size, it can be n/2 in a balanced tree's deepest level
+# using tree and bfs

[A]tree/[A]tree-bfs/104-maximum-depth-of-binary-tree.py

@@ -0,0 +1,27 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+class Solution:
+    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
+        res = []
+        if not root:
+            return res
+        queue = deque([root])
+        while queue:
+            level_count = len(queue)
+            for i in range(level_count):
+                node = queue.popleft()
+                if i == level_count - 1:
+                    res.append(node.val)
+                for child in [node.left, node.right]:
+                    if child:
+                        queue.append(child)
+        return res
+    
+# time O(n), due to traverse
+# space O(n), due to queue's size (tree diameter or last level)
+# using tree and bfs

[A]tree/[A]tree-bfs/199-binary-tree-right-side-view.py

@@ -0,0 +1,34 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+class Solution:
+    def amountOfTime(self, root: Optional[TreeNode], start: int) -> int:
+        start_node = None
+        node_parent = {root: None}
+        queue = deque([root])
+        while queue:
+            node = queue.popleft()
+            if node.val == start:
+                start_node = node
+            for child in [node.left, node.right]:
+                if child:
+                    queue.append(child)
+                    node_parent[child] = node
+        
+        queue = deque([(start_node, 0)])
+        visited = {start_node.val}
+        while queue:
+            node, distance = queue.popleft()
+            for next_node in [node.left, node.right, node_parent[node]]:
+                if next_node and next_node.val not in visited:
+                    queue.append((next_node, distance + 1))
+                    visited.add(next_node.val)
+        return distance
+
+# time O(n)
+# space O(n)
+# using tree and bfs and build child_parent hashmap

[A]tree/[A]tree-bfs/2385-amount-of-time-for-binary-tree-to-be-infected.py

@@ -0,0 +1,35 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+class Solution:
+    def reverseOddLevels(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        queue = deque([root])
+        level = 1
+        while queue:
+            level_count = len(queue)
+            cur_level = []
+            for _ in range(level_count):
+                node = queue.popleft()
+                if level % 2 == 0:
+                    cur_level.append(node)
+                for child in [node.left, node.right]:
+                    if child:
+                        queue.append(child)
+
+            left, right = 0, len(cur_level) - 1
+            while left < right:
+                cur_level[left].val, cur_level[right].val = cur_level[right].val, cur_level[left].val
+                left += 1
+                right -= 1
+                
+            level += 1
+
+        return root
+    
+# time O(n)
+# space O(n)
+# using tree and bfs and two pointers

[A]tree/[A]tree-bfs/2415-reverse-odd-levels-of-binary-tree.py

@@ -0,0 +1,33 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque, defaultdict
+class Solution:
+    def verticalOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root:
+            return []
+        queue = deque([(root, 0)])
+        col_vals = defaultdict(list)
+        min_col = float('inf')
+        max_col = float('-inf')
+        while queue:
+            node, col = queue.popleft()
+            col_vals[col].append(node.val)
+            min_col = min(min_col, col)
+            max_col = max(max_col, col)
+            if node.left:
+                queue.append((node.left, col - 1))
+            if node.right:
+                queue.append((node.right, col + 1))
+        
+        res = []
+        for col in range(min_col, max_col + 1):
+            res.append(col_vals[col][:])
+        return res
+
+# time O(n), due to traverse
+# space O(n), due to hashmap
+# using tree and bfs and hashmap and assign coordinates

[A]tree/[A]tree-bfs/314-binary-tree-vertical-order-traversal.py

@@ -0,0 +1,31 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def addOneRow(self, root: Optional[TreeNode], val: int, depth: int) -> Optional[TreeNode]:
+        if not root:
+            return root
+            
+        if depth == 1:
+            return TreeNode(val=val, left=root)
+
+        queue = deque([(root, 1)])
+        while queue:
+            level_count = len(queue)
+            for _ in range(level_count):
+                node, level = queue.popleft()
+                if level == depth - 1:
+                    node.left = TreeNode(val=val, left=node.left)
+                    node.right = TreeNode(val=val, right=node.right)
+                else:
+                    for child in [node.left, node.right]:
+                        if child:
+                            queue.append((child, level + 1))
+        return root
+    
+# time O(n)
+# space O(n)
+# using tree and bfs

[A]tree/[A]tree-bfs/623-add-one-row-to-tree.py

@@ -0,0 +1,27 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+class Solution:
+    def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:
+        res = 0
+        queue = deque([(root, 1)])
+        while queue:
+            level_count = len(queue)
+            cur_level = []
+            for _ in range(level_count):
+                node, idx = queue.popleft()
+                cur_level.append(idx)
+                if node.left:
+                    queue.append((node.left, idx * 2))
+                if node.right:
+                    queue.append((node.right, idx * 2 + 1))
+            res = max(res, cur_level[- 1] - cur_level[0] + 1)
+        return res
+                        
+# time O(n)
+# space O(n), due to queue
+# using tree and bfs and assign idx

[A]tree/[A]tree-bfs/662-maximum-width-of-binary-tree.py

@@ -0,0 +1,27 @@
+"""
+# Definition for Employee.
+class Employee:
+    def __init__(self, id: int, importance: int, subordinates: List[int]):
+        self.id = id
+        self.importance = importance
+        self.subordinates = subordinates
+"""
+from collections import deque
+class Solution:
+    def getImportance(self, employees: List['Employee'], id: int) -> int:
+        id_employee = {}
+        for e in employees:
+            id_employee[e.id] = e
+
+        res = 0
+        queue = deque([id_employee[id]])
+        while queue:
+            node = queue.popleft()
+            res += node.importance
+            for subordinate in node.subordinates:
+                queue.append(id_employee[subordinate])
+        return res
+        
+# time O(n)
+# space O(n)
+# using tree and bfs and tree's idea and building graph

[A]tree/[A]tree-bfs/690-employee-importance.py

@@ -0,0 +1,35 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+from collections import deque
+class Solution:
+    def distanceK(self, root: TreeNode, target: TreeNode, k: int) -> List[int]:
+        node_parent = {root: None}
+        queue = deque([root])
+        while queue:
+            node = queue.popleft()
+            for child in [node.left, node.right]:
+                if child:
+                    queue.append(child)
+                    node_parent[child] = node
+        
+        res = []
+        queue = deque([(target, 0)])
+        visited = {target.val}
+        while queue:
+            node, distance = queue.popleft()
+            if distance == k:
+                res.append(node.val)
+            else:
+                for next_node in [node.left, node.right, node_parent[node]]:
+                    if next_node and next_node.val not in visited:
+                        queue.append((next_node, distance + 1))
+                        visited.add(next_node.val)
+        return res
+    
+# time O(n)
+# space O(n)
+# using tree and bfs and build child_parent hashmap

[A]tree/[A]tree-bfs/863-all-nodes-distance-k-in-binary-tree.py

@@ -0,0 +1,30 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque, defaultdict
+class Solution:
+    def verticalTraversal(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root:
+            return []
+        queue = deque([(root, 0, 0)])
+        min_col, max_col = 0, 0
+        col_rowvals = defaultdict(list)
+        while queue:
+            node, r, c = queue.popleft()
+            min_col, max_col = min(min_col, c), max(max_col, c)
+            col_rowvals[c].append((r, node.val))
+            if node.left:
+                queue.append((node.left, r + 1, c - 1))
+            if node.right:
+                queue.append((node.right, r + 1, c + 1))
+        res = []
+        for c in range(min_col, max_col + 1):
+            res.append([v for r, v in sorted(col_rowvals[c])])
+        return res
+    
+# time O(n + k * (n/k)log(n/k)), k is the number of cols
+# space O(n), due to queue's max size (number of leaf nodes)
+# using tree and bfs and hashmap and sort and assign coordinates