8/28 - 8/30: Binary trees

- kth_node_in_tree.py
- is_tree_balanced.py
- is_tree_symmetric.py
- lowest_common_ancestor.py
- lowest_common_ancestor_with_parent.py
- path_sum.py
- sum_root_to_leaf.py
- successor_in_tree.py
- tree_connect_leaves.py

Plus some small changes to binary tree libraries:
- binary_tree_node.py
- binary_tree_with_parent_prototype.py
- test_framework/binary_tree_utils.py

Author: jsgoller1

elements-of-programming-interviews/problem_mapping.js

@@ -1010,7 +1010,7 @@ problem_mapping = {
                 "total": 3852
             },
             "Python: is_tree_balanced.py": {
-                "passed": 0,
+                "passed": 3852,
                 "total": 3852
             }
         },
@@ -1024,7 +1024,7 @@ problem_mapping = {
                 "total": 3852
             },
             "Python: is_tree_symmetric.py": {
-                "passed": 0,
+                "passed": 3852,
                 "total": 3852
             }
         },
@@ -1038,7 +1038,7 @@ problem_mapping = {
                 "total": 948
             },
             "Python: lowest_common_ancestor.py": {
-                "passed": 0,
+                "passed": 948,
                 "total": 948
             }
         },
@@ -1052,7 +1052,7 @@ problem_mapping = {
                 "total": 948
             },
             "Python: lowest_common_ancestor_with_parent.py": {
-                "passed": 0,
+                "passed": 948,
                 "total": 948
             }
         },
@@ -1066,7 +1066,7 @@ problem_mapping = {
                 "total": 3849
             },
             "Python: sum_root_to_leaf.py": {
-                "passed": 0,
+                "passed": 3849,
                 "total": 3849
             }
         },
@@ -1080,7 +1080,7 @@ problem_mapping = {
                 "total": 7690
             },
             "Python: path_sum.py": {
-                "passed": 0,
+                "passed": 7690,
                 "total": 7690
             }
         },
@@ -1108,7 +1108,7 @@ problem_mapping = {
                 "total": 3851
             },
             "Python: kth_node_in_tree.py": {
-                "passed": 0,
+                "passed": 3851,
                 "total": 3851
             }
         },
@@ -1122,7 +1122,7 @@ problem_mapping = {
                 "total": 948
             },
             "Python: successor_in_tree.py": {
-                "passed": 0,
+                "passed": 948,
                 "total": 948
             }
         },
@@ -1178,7 +1178,7 @@ problem_mapping = {
                 "total": 3852
             },
             "Python: tree_connect_leaves.py": {
-                "passed": 0,
+                "passed": 3852,
                 "total": 3852
             }
         },

elements-of-programming-interviews/python/binary_tree_node.py

@@ -12,6 +12,7 @@ def __eq__(self, other):
         return equal_binary_trees(self, other)
 
     def __repr__(self):
+        # return f"BinaryTreeNode({self.data})"
         return str(binary_tree_to_string(self))
 
     def __str__(self):

elements-of-programming-interviews/python/binary_tree_with_parent_prototype.py

@@ -9,6 +9,7 @@ def __init__(self, data=None, left=None, right=None, parent=None):
         self.parent = parent
 
     def __repr__(self):
+        # return f"BTNode({self.data})"
         return str(binary_tree_to_string(self))
 
     def __str__(self):

elements-of-programming-interviews/python/is_tree_balanced.py

@@ -1,10 +1,39 @@
 from binary_tree_node import BinaryTreeNode
 from test_framework import generic_test
 
+"""
+Recursive solution:
+    height of a tree is 1 plus each of its subtrees (unless they're both empty)
+    recursively calculate the height and difference
+
+"""
+
+
+def display(node, prefix="", margin=0):
+    print(f"{' '*margin}| {prefix + ':' if prefix else ''} {node.data}")
+    if node.right:
+        display(node.right, 'R', margin+2)
+    if node.left:
+        display(node.left, 'L', margin+2)
+
 
 def is_balanced_binary_tree(tree: BinaryTreeNode) -> bool:
-    # TODO - you fill in here.
-    return True
+    # print("")
+    # display(tree)
+
+    def balance_height(node):
+        if not node:
+            return -1, True
+        lheight, lbalance = balance_height(node.left)
+        rheight, rbalance = balance_height(node.right)
+
+        height = max(lheight, rheight) + 1
+        balanced = lbalance and rbalance and abs(lheight - rheight) < 2
+        return height, balanced
+
+    _, balanced = balance_height(tree)
+
+    return balanced
 
 
 if __name__ == '__main__':

elements-of-programming-interviews/python/is_tree_symmetric.py

@@ -1,10 +1,29 @@
 from binary_tree_node import BinaryTreeNode
 from test_framework import generic_test
 
+"""
+Suppose we went through the left and right trees together:
+    root.left must equal root.right
+    root.left.left must equal root.right.right
+    root.left.right must equal root.right.left 
+
+So we recursively implement this; base case is if one node is none, both must be.
+"""
+
 
 def is_symmetric(tree: BinaryTreeNode) -> bool:
-    # TODO - you fill in here.
-    return True
+    if not tree:
+        return True
+
+    def compare(left_subtree, right_subtree):
+        if None in [left_subtree, right_subtree]:
+            return left_subtree == right_subtree
+        symmetric = left_subtree.data == right_subtree.data
+        symmetric &= compare(left_subtree.left, right_subtree.right)
+        symmetric &= compare(left_subtree.right, right_subtree.left)
+        return symmetric
+
+    return compare(tree.left, tree.right)
 
 
 if __name__ == '__main__':

elements-of-programming-interviews/python/kth_node_in_tree.py

@@ -14,10 +14,36 @@ def __init__(self, data=None, left=None, right=None, size=None):
         self.size = size
 
 
+"""
+- Inorder traversal is LNR. So before we process the current node, we have to process the entire left subtree.
+- going left means "we will process fewer nodes before reaching this node"
+- going right mean "we commit to processing this many nodes."
+
+At each node:
+    if k == left subtree size + 1, current node is kth. 
+    if k < left subtree size + 1, go left. 
+    if k > left subtree's size + 1, go right and subtract left subtree's size plus one (for root) from k. 
+
+
+edge cases: tree empty, k is larger than whole tree size (assume this won't happen for now)
+"""
+
+
 def find_kth_node_binary_tree(tree: BinaryTreeNode,
                               k: int) -> Optional[BinaryTreeNode]:
-    # TODO - you fill in here.
-    return None
+    if (not tree) or k > tree.size:
+        return None
+
+    def find_kth(root, remaining):
+        traversable = (root.left.size+1 if root.left else 1)
+        if remaining == traversable:
+            return root
+        if root.left and traversable > remaining:
+            return find_kth(root.left, remaining)
+        else:  # (not root.left) or traversable < remaining
+            return find_kth(root.right, remaining-traversable)
+
+    return find_kth(tree, k)
 
 
 @enable_executor_hook

elements-of-programming-interviews/python/lowest_common_ancestor.py

@@ -8,10 +8,66 @@
 from test_framework.test_utils import enable_executor_hook
 
 
+def get_path(root, node, path):
+    if not root:
+        return False
+    path.append(root)
+    if root == node:
+        return True
+
+    if root.left:
+        if get_path(root.left, node, path):
+            return True
+    if root.right:
+        if get_path(root.right, node, path):
+            return True
+    path.pop()
+    return False
+
+
+def lca_Oh_space(tree: BinaryTreeNode, node0: BinaryTreeNode,
+                 node1: BinaryTreeNode) -> Optional[BinaryTreeNode]:
+    node0_path = []
+    get_path(tree, node0, node0_path)
+    node1_path = []
+    get_path(tree, node1, node1_path)
+
+    solution = tree
+    for n0, n1 in zip(node0_path, node1_path):
+        if n0 is n1:
+            solution = n0
+        else:
+            break
+
+    return solution
+
+
 def lca(tree: BinaryTreeNode, node0: BinaryTreeNode,
         node1: BinaryTreeNode) -> Optional[BinaryTreeNode]:
-    # TODO - you fill in here.
-    return None
+    best_lca = tree
+    best_lca_distance = 0
+
+    def nodes_in_tree(root, depth):
+        if not root:
+            return False, False
+
+        node0_left, node1_left = nodes_in_tree(root.left, depth+1)
+        node0_right, node1_right = nodes_in_tree(root.right, depth+1)
+
+        node0_exists = (root is node0) or node0_left or node0_right
+        node1_exists = (root is node1) or node1_left or node1_right
+
+        nonlocal best_lca_distance
+        nonlocal best_lca
+        if (node0_exists and node1_exists) and best_lca_distance < depth:
+            best_lca_distance = depth
+            best_lca = root
+
+        return node0_exists, node1_exists
+
+    node0_exists, node1_exists = nodes_in_tree(tree, 0)
+
+    return best_lca if (node0_exists and node1_exists) else None
 
 
 @enable_executor_hook

elements-of-programming-interviews/python/lowest_common_ancestor_with_parent.py

@@ -7,11 +7,34 @@
 from test_framework.test_failure import TestFailure
 from test_framework.test_utils import enable_executor_hook
 
+"""
+Get depth of each node by tracing to root. Then advance the longer to meet the shorter's depth,
+then go one by one until they reach the first common node, which is LCA.
+"""
+
+
+def get_depth(node):
+    depth = -1
+    while node is not None:
+        node = node.parent
+        depth += 1
+    return depth
+
 
 def lca(node0: BinaryTreeNode,
         node1: BinaryTreeNode) -> Optional[BinaryTreeNode]:
-    # TODO - you fill in here.
-    return None
+    n0_depth, n1_depth = get_depth(node0),  get_depth(node1)
+    if n0_depth != n1_depth:
+        node0, node1 = (node0, node1) if n0_depth > n1_depth else (node1, node0)
+        n0_depth, n1_depth = (n0_depth, n1_depth) if n0_depth > n1_depth else (n1_depth, n0_depth)
+        while n0_depth > n1_depth:
+            node0 = node0.parent
+            n0_depth -= 1
+
+    while node0 is not node1:
+        node0 = node0.parent
+        node1 = node1.parent
+    return node0
 
 
 @enable_executor_hook

elements-of-programming-interviews/python/path_sum.py

@@ -3,8 +3,16 @@
 
 
 def has_path_sum(tree: BinaryTreeNode, remaining_weight: int) -> bool:
-    # TODO - you fill in here.
-    return True
+    def recurse(node, remaining):
+        if not node:
+            return False
+
+        remaining -= node.data
+        if not node.left and not node.right:
+            return remaining == 0
+        return recurse(node.left, remaining) or recurse(node.right, remaining)
+
+    return recurse(tree, remaining_weight)
 
 
 if __name__ == '__main__':