feat: trees working

Author: mativs-kp

technical-fundamentals/python/coding/problems/30_trees.py

@@ -21,16 +21,40 @@ def __init__(
 
 
 class Tree(Generic[T]):
+    def backtrack(self, node, answer):
+        if not node:
+            return answer
+
+        to_track = []
+        for n in [node.left, node.right]:
+            if n:
+                answer.append(n)
+                to_track.append(n)
+
+        for n in to_track:
+            self.backtrack(n, answer)
+
+        return answer
+
     def bfs(
         self,
         node: Optional[TreeNode[T]],
         visit: Callable[[TreeNode[T]], None],
     ) -> None:
-        pass
+        if node:
+            nodes = []
+            nodes.append(node)
+            self.backtrack(node, nodes)
+            while nodes:
+                visit(nodes.pop(0))
 
     def dfs(
         self,
         node: Optional[TreeNode[T]],
         visit: Callable[[TreeNode[T]], None],
     ) -> None:
-        pass
+        if node:
+            visit(node)
+            self.dfs(node.left, visit)
+            self.dfs(node.right, visit)
+            

technical-fundamentals/python/coding/problems/31_has_route_between_nodes.py

@@ -11,6 +11,20 @@ def __init__(self, value: int, neighbors: List["GraphNode"] = None):
         self.value = value
         self.neighbors: List["GraphNode"] = neighbors if neighbors is not None else []
 
+def backtrack(start, end, path):
+    if start == end:
+        return True
+
+    if not start or not end:
+        return False
+
+    for n in start.neighbors:
+        if n not in path:
+            path.append(n)
+            if backtrack(n, end, path):
+                return True
+
+    return False 
 
 def has_route_between_nodes(start: GraphNode, end: GraphNode) -> bool:
-    pass
+    return backtrack(start, end, [])

technical-fundamentals/python/coding/problems/32_minimal_tree.py

@@ -30,4 +30,12 @@ def __init__(
 
 
 def minimal_tree(sorted_array: List[T]) -> Optional[TreeNode[T]]:
-    pass
+    if not sorted_array:
+        return None
+
+    len_array = len(sorted_array)
+    middle = len_array // 2
+    root = TreeNode(sorted_array[middle])
+    root.left = minimal_tree(sorted_array[0:middle])
+    root.right = minimal_tree(sorted_array[middle+1:])
+    return root

technical-fundamentals/python/coding/problems/33_list_of_depths.py

@@ -26,5 +26,42 @@ def __init__(self, value: T, next: Optional["ListNode[T]"] = None):
         self.next = next
 
 
+
+def dfs(node, depth, answer):
+    if not node:
+        return answer
+
+    len_answer = len(answer)
+    to_traverse = []
+    for n in [node.left, node.right]:
+        if n:
+            if depth == len_answer:
+                answer.append([])
+            answer[depth].append(n.value)
+            to_traverse.append(n)
+
+    for n in to_traverse:
+        dfs(n, depth+1, answer)
+
+    return answer
+
 def list_of_depths(root: Optional[TreeNode[T]]) -> List[ListNode[T]]:
-    pass
+    if not root:
+        return []
+
+    answer = []
+
+    answer.append([root.value])
+    dfs(root, 1, answer)
+
+    returned = []
+    for a in answer:
+        dummy = ListNode(0)
+        pointer = dummy
+        for x in a:
+            n = ListNode(x)
+            pointer.next = n
+            pointer = pointer.next
+        returned.append(dummy.next)
+
+    return returned

technical-fundamentals/python/coding/problems/34_check_balanced.py

@@ -20,6 +20,20 @@ def __init__(
         self.left = left
         self.right = right
 
+def check_length(tree: Optional[TreeNode[T]]) -> bool:
+    if not tree:
+        return 0
+
+    return max([
+        check_length(tree.left),
+        check_length(tree.right)
+    ]) + 1
 
 def check_balanced(tree: Optional[TreeNode[T]]) -> bool:
-    pass
+    if not tree:
+        return True
+
+    left = check_length(tree.left)
+    right = check_length(tree.right)
+
+    return abs(left-right) <= 1

technical-fundamentals/python/coding/problems/35_validate_bst.py

@@ -18,6 +18,30 @@ def __init__(
         self.left = left
         self.right = right
 
+def max_tree(node: Optional[TreeNode[T]]) -> int | None:
+    if not node:
+        return None
+
+    to_check = [node.value]
+    max_left = max_tree(node.left)
+    if max_left is not None:
+        to_check.append(max_left)
+    max_right = max_tree(node.right)
+    if max_right is not None:
+        to_check.append(max_right)
+    return max(
+        to_check
+    )
+
 
 def validate_bst(node: Optional[TreeNode[T]]) -> bool:
-    pass
+    if not node:
+        return True
+
+    max_left = max_tree(node.left)
+    max_right = max_tree(node.right)
+
+    return (
+        (max_left is None or max_left <= node.value ) and
+        (max_right is None or max_right >= node.value)
+        )

technical-fundamentals/python/coding/problems/36_successor.py

@@ -21,6 +21,24 @@ def __init__(
         self.right = right
         self.parent = parent
 
+def min_node(node: TreeNode[T]) -> Optional[TreeNode[T]]:
+    if not node or not node.left:
+        return node
+
+    return min_node(node.left)
 
 def successor(node: TreeNode[T]) -> Optional[TreeNode[T]]:
-    pass
+    if not node:
+        return None
+
+    if node.right is None:
+        if not node.parent:
+            return None
+
+        pointer = node.parent
+        while pointer and pointer.value < node.value:
+            pointer = pointer.parent
+
+        return pointer
+
+    return min_node(node.right)

technical-fundamentals/python/coding/problems/37_build_order.py

@@ -9,11 +9,84 @@
 #   projects: a, b, c, d, e, f
 #   dependencies: (a, d), (f, b), (b, d), (f, a), (d, c)
 # Output: e, f, a, b, d, c
+# 
+#                 -> a -> f
+# dummy -> c -> d -> b -> f
+#       -> e
+#       -> d
+#       -> b
+#       -> a
+#       -> f
+#       
+#       path c
+#       path d
+#       path a
+#       path f
+#       append f
+#       pop f
+#       append a
+#       pop a
+#       path b
+#       append b
+#       pop b
+#       append d
+#       pop d
+#       append c
+#       pop c
+#       append e
+
 
 from typing import List, Union
 
+class GraphNode:
+    def __init__(self, value: str, neighbors: List["GraphNode"] = None):
+        self.value = value
+        self.neighbors: List["GraphNode"] = neighbors if neighbors is not None else []
+
+def dfs(node, answer, path):
+    if not node:
+        return answer
+
+    for n in node.neighbors:
+        if n.value not in path and n.value not in answer:
+            print('path', n.value)
+            path.append(n.value)
+            dfs(n, answer, path)
+            print('pop', n.value)
+            path.pop()
+    answer.append(node.value)
+    print('append', node.value)
+    return answer
+    
 
 def build_order(
     projects: List[str], dependencies: List[List[str]]
 ) -> Union[List[str], str]:
-    pass
+    hashmap = {}
+    starts = {}
+    if not projects and not dependencies:
+        return []
+
+    for a in projects:
+        n = GraphNode(a)
+        hashmap[a] = n
+        starts[a] = n
+
+    for left, right in dependencies:
+        if right not in hashmap or left not in hashmap:
+            raise Exception("No valid build order exists")
+        hashmap[right].neighbors.append(hashmap[left])
+        if left in starts:
+            del starts[left]
+
+    if not starts:
+        raise Exception("No valid build order exists")
+
+    dummy = GraphNode('')
+    for n in list(starts.values())[::-1]:
+        dummy.neighbors.append(n)
+
+    answer = dfs(dummy, [], [])
+    print(answer[:-1])
+    return [x for x in answer[:-1]]
+

technical-fundamentals/python/coding/problems/38_first_common_ancestor.py

@@ -21,9 +21,30 @@ def __init__(
         self.right = right
 
 
+def find(node, q, path):
+    if node is None:
+        return None
+
+    if node is q:
+        return path
+
+    for n in [node.left, node.right]:
+        if n:
+            path.append(n)
+            if find(n, q, path):
+                return path
+            path.pop()
+
+
 def first_common_ancestor(
     root: Optional[TreeNode[T]],
     p: TreeNode[T],
     q: TreeNode[T],
 ) -> Optional[TreeNode[T]]:
-    pass
+    answer = find(root, p, [root])
+    while answer:
+        node = answer.pop()
+        if find(node, q, []):
+            return node
+
+

technical-fundamentals/python/coding/problems/39_bst_sequences.py

@@ -15,6 +15,15 @@
 
 T = TypeVar("T")
 
+#       5
+#   3        7
+# 2   4   6    8
+
+
+# root = TreeNode(5,
+#             left=TreeNode(3, left=TreeNode(2), right=TreeNode(4)),
+#             right=TreeNode(7, left=TreeNode(6), right=TreeNode(8)),
+#         )
 
 class TreeNode(Generic[T]):
     def __init__(
@@ -27,6 +36,34 @@ def __init__(
         self.left = left
         self.right = right
 
+def total_nodes(root: TreeNode[T] | None):
+    if not root:
+        return 0
+
+    return total_nodes(root.left) + total_nodes(root.right) + 1
+
+
+def backtrack(total, choices, path, answer):
+    if len(path) == total:
+        answer.append(list(path))
+        return answer
+
+    for i in range(len(choices)):
+        c = choices[i]
+        if c.value not in path:
+            path.append(c.value)
+            new_choices = choices[:i] + choices[i+1:]
+            if c.left:
+                new_choices.append(c.left)
+            if c.right:
+                new_choices.append(c.right)
+
+            backtrack(total, new_choices, path, answer)
+            path.pop()
+
+    return answer
 
 def bst_sequences(root: TreeNode[T]) -> List[List[T]]:
-    pass
+    total = total_nodes(root)
+    return backtrack(total, [root], [], [])
+