def recurse_tree(self, node, path_sum: int, path: List[int],
target_sum: int, paths):
if not node or not node.val:
return
path_sum += node.val
path.append(node.val)
# Found leaf with targeted sum
if path_sum == target_sum and self.is_leaf(node):
paths.append(list(path))
# Reurse for left and right nodes
else:
self.recurse_tree(node.left, path_sum, path, target_sum, paths)
self.recurse_tree(node.right, path_sum, path, target_sum, paths)
path.pop()
def is_leaf(self, node) -> bool:
return not node.left and not node.right
root: Node = TreeHelper.create_tree(
[5, 2, 3, 10, 8, 7, 2, 3, 5, 1, None, None, 1, 3, 4])
# TreeHelper.print_tree(root)
sol = Solution()
print(sol.pathSum(root, 16))
if not root:
return
res: List[int] = []
stack: List[tuple] = [(StackItem(node=root, processed=False))]
while stack:
cur_item: StackItem = stack.pop()
if cur_item.processed:
res.append(cur_item.node.val)
continue
if cur_item.node.right and cur_item.node.right.val:
stack.append(
StackItem(node=cur_item.node.right, processed=False))
stack.append(StackItem(node=cur_item.node, processed=True))
if cur_item.node.left and cur_item.node.left.val:
stack.append(
StackItem(node=cur_item.node.left, processed=False))
return res
sol = Solution()
assert sol.inorderTraversal(
TreeHelper.create_tree([1, None, 2, None, None, 3, None])) == [1, 3, 2]
class Solution:
def bottom_view(self, root: Node) -> List[int]:
if not root:
return
res = []
self.pre_order(root, res)
return res
def pre_order(self, root, res):
if not root:
return
if root.val and ((not root.left and not root.right) or
(not root.left.val and not root.right.val)):
res.append(root.val)
self.pre_order(root.left, res)
self.pre_order(root.right, res)
sol = Solution()
root = TreeHelper.create_tree(
[20, 8, 22, 5, 3, None, 25, None, None, 10, 14, None, None, None, None])
TreeHelper.print_tree(root)
print(sol.bottom_view(root))
return 0
dl = self.printkDistanceNode(root.left, target, k)
if dl != -1:
if dl + 1 == k:
print(root.val)
else:
self.printkDistanceNodeDown(root.right, k - dl - 2)
return 1 + dl
dr = self.printkDistanceNode(root.right, target, k)
if dr != -1:
if (dr + 1 == k):
print(root.val)
else:
self.printkDistanceNodeDown(root.left, k - dr - 2)
return 1 + dr
return -1
sol = Solution()
root: Node = TreeHelper.create_tree(
[3, 5, 1, 6, 2, 9, 8, None, None, 7, 4, None, None, None, None])
TreeHelper.print_tree(root)
sol.printkDistanceNode(root, root.left, 2)
2. One tree is mirror of another
3. Some of the subtrees are mirror and some are identical
'''
from helpers import TreeHelper
from helpers import Node
class Solution:
def isSameTree(self, r1: Node, r2: Node) -> bool:
if not r1 and not r2:
return True
if (not r1 and r2) or (r1 and not r2) or r1.val != r2.val:
return False
return (self.isSameTree(r1.left, r2.left) and self.isSameTree(
r1.right, r2.right)) or (self.isSameTree(r1.left, r2.right)
and self.isSameTree(r1.right, r2.left))
r1 = TreeHelper.create_tree(['A', 'B', 'C', 'D', 'E', None, None])
r2 = TreeHelper.create_tree(['A', 'C', 'B', None, None, 'D', 'E'])
sol = Solution()
assert sol.isSameTree(r1, r2) == True
r3 = TreeHelper.create_tree(['A', 'B', 'C', 'D', 'E', None, None])
r4 = TreeHelper.create_tree(['A', 'C', 'F', None, None, 'D', 'E'])
assert sol.isSameTree(r3, r4) == False
right_status = self.lca_helper(root.right, p, q)
if right_status.num_target_nodes == 2:
return right_status
return Status(num_target_nodes=left_status.num_target_nodes +
right_status.num_target_nodes +
(p.val, q.val).count(root.val),
ancestor=root)
sol = Solution()
tree: Node = TreeHelper.create_tree([
3,
5,
1,
6,
2,
0,
8,
None,
None,
7,
4,
])
# ancestor = sol.lowestCommonAncestor(tree, Node(5, None, None), Node(1, None, None))
ancestor = sol.lowestCommonAncestor(tree, Node(5, None, None),
Node(4, None, None))
print(ancestor.val)
self.first_min, self.second_min = maxsize, maxsize
self.traverse_pre_order(root)
return self.second_min if self.second_min < maxsize else -1
def traverse_pre_order(self, node: Node):
if not node or not node.val:
return
if node.val < self.first_min:
self.first_min = node.val
elif self.first_min < node.val < self.second_min:
self.second_min = node.val
self.traverse_pre_order(node.left)
self.traverse_pre_order(node.right)
sol = Solution()
tree = TreeHelper.create_tree([2, 2, 5, None, None, 5, 7])
TreeHelper.print_tree(tree)
assert sol.findSecondMinimumValue(tree) == 5
tree = TreeHelper.create_tree([2, 2, 2])
TreeHelper.print_tree(tree)
assert sol.findSecondMinimumValue(tree) == -1
def check_if_symmetric(self, subtree_1: Node, subtree_2: Node) -> bool:
if not subtree_1 and not subtree_2:
return True
elif subtree_1 and subtree_2:
if subtree_1.val != subtree_2.val:
return False
elif self.check_if_symmetric(
subtree_1.left,
subtree_2.right) and self.check_if_symmetric(
subtree_1.right, subtree_2.left):
return True
else:
return False
else:
return False
def isSymmetric(self, root: Node) -> bool:
if not root:
return True
return self.check_if_symmetric(root.left, root.right)
root: Node = TreeHelper.create_tree([1, 2, 2, 3, None, 4, 3])
TreeHelper.print_tree(root)
print(Solution().isSymmetric(root))
return
self.in_order_traversal(root, target)
return self.value
def in_order_traversal(self, node: Node, target: float):
if not node:
return
self.in_order_traversal(node.left, target)
diff = abs(node.val - target)
if diff < self.difference:
self.difference = diff
self.value = node.val
self.in_order_traversal(node.right, target)
start_time = process_time()
root: Node = TreeHelper.create_tree([4, 2, 5, 1, 3])
TreeHelper.print_tree(root)
sol = Solution()
print(sol.closestValue(root, 3.714286))
print(process_time() - start_time)
res = self.is_path_present_rec(root, nums)
print(res)
def is_path_present_rec(self, root, nums) -> bool:
if not root:
return False
if not root.left and not root.right and len(
nums) == 1 and nums[0] == root.val:
return True
if root.val == nums[0]:
num = nums.pop(0)
is_present = self.is_path_present_rec(
root.left, nums) or self.is_path_present_rec(root.right, nums)
nums.insert(0, num)
return is_present
else:
return False
sol: Solution = Solution()
root: Node = TreeHelper.create_tree(
[5, 2, 3, 1, 4, None, None, None, None, 6, 8])
TreeHelper.print_tree(root)
sol.is_path_present([5, 2, 4, 8], root)
sol.is_path_present([5, 3, 4, 9], root)
if not root or not root.val:
return BalanceAndHeight(balanced=True, height=0)
left_balance_and_height = self.is_height_balanced(root.left)
if not left_balance_and_height.balanced:
return left_balance_and_height
right_balance_and_height = self.is_height_balanced(root.right)
if not right_balance_and_height:
return right_balance_and_height
if abs(left_balance_and_height.height -
right_balance_and_height.height) <= 1:
h = max([
left_balance_and_height.height, right_balance_and_height.height
]) + 1
return BalanceAndHeight(balanced=True, height=h)
else:
h = max([
left_balance_and_height.height, right_balance_and_height.height
]) + 1
return BalanceAndHeight(balanced=False, height=h)
root: Node = TreeHelper.create_tree([3, 9, 20, None, None, 15, 7])
TreeHelper.print_tree(root)
print(Solution().isBalanced(root))