def validator(
isSubtree: Callable[[Optional[TreeNode], Optional[TreeNode]], bool],
inputs: tuple[list[Optional[int]], list[Optional[int]]],
expected: bool,
) -> None:
tree_vals, subtree_vals = inputs
tree = build_tree(tree_vals)
subtree = build_tree(subtree_vals)
output = isSubtree(tree, subtree)
assert output == expected, (output, expected)
def validator(
_: object,
inputs: tuple[list[Optional[int]]],
expected: list[Optional[int]],
) -> None:
values, = inputs
tree = build_tree(values)
codec = Codec()
output_tree = codec.deserialize(codec.serialize(tree))
expected_tree = build_tree(expected)
tree_values = [node.val for node in traverse(output_tree)]
expected_values = [node.val for node in traverse(expected_tree)]
assert tree_values == expected_values, (tree_values, expected_values)
def validator(
kthSmallest: Callable[[Optional[TreeNode], int], int],
inputs: tuple[list[Optional[int]], int],
expected: int,
) -> None:
values, k = inputs
tree = build_tree(values)
output = kthSmallest(tree, k)
assert output == expected, (output, expected)
def validator(
inorderTraversal: Callable[[Optional[TreeNode]], list[int]],
inputs: tuple[list[Optional[int]]],
expected: list[int],
) -> None:
values, = inputs
tree = build_tree(values)
output = inorderTraversal(tree)
assert output == expected, (output, expected)
def validator(
levelOrder: Callable[[Optional[TreeNode]], list[list[int]]],
inputs: tuple[list[Optional[int]]],
expected: list[list[int]],
) -> None:
values, = inputs
tree = build_tree(values)
output = levelOrder(tree)
assert output == expected, (output, expected)
def validator(
isSymmetric: Callable[[Optional[TreeNode]], bool],
inputs: tuple[list[Optional[int]]],
expected: bool
) -> None:
values, = inputs
tree = build_tree(values)
output = isSymmetric(tree)
assert output == expected, (output, expected)
def validator(
rightSideView: Callable[[Optional[TreeNode]], list[int]],
inputs: tuple[list[Optional[int]]],
expected: list[int],
) -> None:
nums, = inputs
root = build_tree(nums)
output = rightSideView(root)
assert output == expected, (output, expected)
def validator(
buildTree: Callable[[list[int], list[int]], Optional[TreeNode]],
inputs: tuple[list[int], list[int]],
expected: list[Optional[int]],
) -> None:
preorder, inorder = inputs
tree = buildTree(preorder, inorder)
expected_tree = build_tree(expected)
tree_values = [node.val for node in traverse(tree)]
expected_values = [node.val for node in traverse(expected_tree)]
assert tree_values == expected_values, (tree_values, expected_values)
def validator(
lowestCommonAncestor: Callable[[TreeNode, TreeNode, TreeNode], TreeNode],
inputs: tuple[list[Optional[int]], int, int],
expected: int,
) -> None:
nums, p, q = inputs
tree = build_tree(nums)
assert tree is not None
node_p = find(tree, p)
node_q = find(tree, q)
ancestor = lowestCommonAncestor(tree, node_p, node_q)
assert ancestor.val == expected, (ancestor.val, expected)
def validator(
sortedArrayToBST: Callable[[list[int]], Optional[TreeNode]],
inputs: tuple[list[int]],
output: list[Optional[int]],
) -> None:
nums, = inputs
tree = sortedArrayToBST(nums)
output_tree = build_tree(output)
height = max_depth(tree)
expected_height = max_depth(output_tree)
assert height == expected_height, (height, expected_height)
values = list(inorder(tree))
expected_values = list(inorder(output_tree))
assert values == expected_values, (values, expected_values)
def validator(maxDepth: Callable[[Optional[TreeNode]], int],
inputs: tuple[list[Optional[int]]], expected: int) -> None:
values, = inputs
tree = build_tree(values)
output = maxDepth(tree)
assert output == expected, (output, expected)