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))