def find_second_largest(root):
arr = [TreeNode(-math.inf), TreeNode(-math.inf)]
traverse_tree(root, arr)
if arr[1] == -math.inf:
# the tree has 0 or 1 elements
return None
return arr[1]
current_path = left_result[1] + node.val + right_result[1]
# find the max path till now, comparing the new path, max path from the left and right subtree
max_path = max(left_result[0], current_path, right_result[0])
# find the max subpath, min value for a subpath sum is 0
max_subpath = max(left_result[1] + node.val, right_result[1] + node.val, node.val, 0)
return (max_path, max_subpath)
###########
# Testing #
###########
# Test 1
# Correct result => 18
tree = TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6), TreeNode(7)))
print(max_path_sum(tree))
# Test 2
# Correct result => 10
tree = TreeNode(-1, TreeNode(-2, TreeNode(-4), TreeNode(-5)), TreeNode(3, TreeNode(2), TreeNode(5)))
print(max_path_sum(tree))
# Test 3
'''
1
/ \
7 3
/ \ / \
-4 -5 6 2
'''
if not root: return 0
l = self.maxHeight(root.left)
r = self.maxHeight(root.right)
return max(l, r) + 1
if __name__ == "__main__":
'''
3 # height 1
/ \
9 20 # height 2
/ \
15 7 # height 3
'''
root1 = TreeNode(3)
root1.left = TreeNode(9)
root1.right = TreeNode(20)
root1.right.left = TreeNode(15)
root1.right.right = TreeNode(7)
'''
3 # height 1
/ \
9 20 # height 2
/ \
15 7 # height 3
/ \
13 19 # height 4
/
10 # height 5
if arr[1] == -math.inf:
# the tree has 0 or 1 elements
return None
return arr[1]
def traverse_tree(node, arr):
if node == None:
return
if arr[0].val < node.val:
arr[1] = arr[0]
arr[0] = node
elif arr[1].val < node.val:
arr[1] = node
# search left
traverse_tree(node.left, arr)
# search right
traverse_tree(node.right, arr)
###########
# Testing #
###########
# Test 1
# Correct result => 8
tree = TreeNode(1, TreeNode(5, TreeNode(2), TreeNode(8)),
TreeNode(4, TreeNode(12), TreeNode(7)))
print(find_second_largest(tree).val)
###########
# Testing #
###########
# Test 1
'''
5
/ \
1 4
/ \
3 6
'''
# Correct result => False
root = TreeNode(5, TreeNode(1), TreeNode(4, TreeNode(3), TreeNode(6)))
print(is_valid_bst(root))
# Test 2
'''
5
/ \
1 6
/ \
4 7
'''
# Correct result => False
root = TreeNode(5, TreeNode(1), TreeNode(6, TreeNode(4), TreeNode(7)))
print(is_valid_bst(root))
# Test 3
k = right[0] - 1
if k == 0:
return (0, node)
# check left
return search_2(node.left, k)
###########
# Testing #
###########
# Test 1
# Correct result => 10
tree = TreeNode(
5, TreeNode(3, TreeNode(1), TreeNode(4)),
TreeNode(8, TreeNode(7), TreeNode(12, TreeNode(10, TreeNode(13)))))
print(find_second_largest_bst_1(tree).val)
print(find_second_largest_bst_2(tree).val)
# Test 2
# Correct result => 8
tree = TreeNode(5, TreeNode(3, TreeNode(1), TreeNode(4)),
TreeNode(8, TreeNode(7), TreeNode(12)))
print(find_second_largest_bst_1(tree).val)
print(find_second_largest_bst_2(tree).val)
# Test 3
# Correct result => 4
tree = TreeNode(5, TreeNode(3, TreeNode(1), TreeNode(4)))
print(find_second_largest_bst_1(tree).val)
left_result = total_unival_trees(node.left)
unival_trees += left_result[0]
is_left_unival_tree = left_result[1]
left_value = node.left.val
# count right unival trees and save the value
if node.right is not None:
right_result = total_unival_trees(node.right)
unival_trees += right_result[0]
is_right_unival_tree = right_result[1]
right_value = node.right.val
# check if this root is an unival tree
is_this_unival_tree = is_left_unival_tree and is_right_unival_tree and (
left_value == right_value)
unival_trees += is_this_unival_tree
return (unival_trees, is_this_unival_tree)
###########
# Testing #
###########
# Test 1
# Correct result => 5
print(
count_unival_trees(
TreeNode(
0, TreeNode(1),
TreeNode(0, TreeNode(1, TreeNode(1), TreeNode(1)), TreeNode(0)))))
queue.append((root, 0))
while queue:
node, lvl = queue.popleft()
if node is None:
continue
if len(results) < lvl + 1:
results.append([])
results[lvl].append(node.val)
lvl += 1
queue.append((node.left, lvl))
queue.append((node.right, lvl))
# reverse odd level
for i in range(1, len(results), 2):
results[i] = results[i][::-1]
return results
###########
# Testing #
###########
# Test 1
# Correct result => [[3], [20, 9], [15, 7]]
tree = TreeNode(3, TreeNode(9), TreeNode(20, TreeNode(15), TreeNode(7)))
print(zigzag_level_order_traversal(tree))
def find_diameter(root):
''' returns (max branch length, max diameter) '''
if not root:
return 0, 0
# traverse left and right subtrees
left, right = find_diameter(root.left), find_diameter(root.right)
# return the max branch from the left and right subtrees plus the current node
# and find the max diameter till now (using the current node and the max left and right subtree branches)
return max(left[0], right[0]) + 1, max(left[1], right[1],
left[0] + right[0] + 1)
###########
# Testing #
###########
# Test 1
# Correct result => 6
tree = TreeNode(3, TreeNode(1, None, TreeNode(2, TreeNode(7))),
TreeNode(4, None, TreeNode(5)))
print(diameter(tree))
# Test 2
# Correct result => 5
tree = TreeNode(
5, TreeNode(3, TreeNode(2, TreeNode(1)), TreeNode(4, None, TreeNode(8))),
TreeNode(6))
print(diameter(tree))
return False
if p.val != q.val:
return False
# check left
if not is_same_tree(p.left, q.left):
return False
# check right
if not is_same_tree(p.right, q.right):
return False
return True
###########
# Testing #
###########
# Test 1
# Correct result => True
p = TreeNode(1, TreeNode(2), TreeNode(3))
q = TreeNode(1, TreeNode(2), TreeNode(3))
print(is_same_tree(p, q))
# Test 2
# Correct result => False
p = TreeNode(1, TreeNode(2))
q = TreeNode(1, None, TreeNode(2))
print(is_same_tree(p, q))
'''
############
# Solution #
############
# import TreeNode class from tree_helpers.py
from tree_helpers import TreeNode
def max_branch_sum(node):
if node is None:
return 0
# take the max left subbranch sum and add the current node value
left_max_sum = max_branch_sum(node.left) + node.val
# take the max right subbranch sum and add the current node value
right_max_sum = max_branch_sum(node.right) + node.val
# return the bigger sum
return max(left_max_sum, right_max_sum)
###########
# Testing #
###########
# Test 1
# Correct result => 11
tree = TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6), TreeNode(7)))
print(max_branch_sum(tree))