def test1(self):
node1 = Node(1)
node2 = Node(2)
node3 = Node(3)
node4 = Node(4)
node5 = Node(5)
node6 = Node(6)
node7 = Node(7)
node8 = Node(8)
node9 = Node(9)
node10 = Node(10)
node11 = Node(11)
node1.left = node2
node1.right = node3
node2.left = node4
node2.right = node5
node3.left = node6
node3.right = node7
node6.left = node8
node6.right = node9
node7.left = node10
node7.right = node11
s = Solution()
res = s.compress(node1)
print res
root = s.decompress(res)
res2 = s.compress(root)
print res2
self.assertEqual(res, res2)
def test_handles_bad_tree_left():
bad_tree = Node(7)
bad_tree.left = Node(8)
tree = Node(8)
tree.left = bad_tree
assert (check_binary_search_tree_(tree) == False)
def convert_list_to_binary_search_tree(raw_list: Optional[list[int]]) -> Optional[Node]:
if not raw_list:
return None
root = Node(raw_list[0])
root.right = convert_list_to_binary_search_tree(raw_list[1:])
root.left = convert_list_to_binary_search_tree(raw_list[2:])
return root
def test_handles_example():
candidate_tree = Node(3)
candidate_tree.left = Node(5)
candidate_tree.left.left = Node(1)
candidate_tree.left.right = Node(4)
candidate_tree.right = Node(2)
candidate_tree.right.left = Node(6)
assert (check_binary_search_tree_(candidate_tree) == False)
def test_inorder():
root = Node(4)
root.left = Node(2)
root.right = Node(5)
root.left.left = Node(1)
root.left.right = Node(3)
res = inorder(root)
assert res == [1, 2, 3, 4, 5]
def test_handles_valid_nested_tree():
candidate_tree = Node(4)
candidate_tree.left = Node(2)
candidate_tree.left.left = Node(1)
candidate_tree.left.right = Node(3)
candidate_tree.right = Node(6)
candidate_tree.right.left = Node(5)
assert (check_binary_search_tree_(candidate_tree) == True)
def test_deepest(self):
root = Node('a')
root.left = Node('b')
root.left.left = Node('d')
root.right = Node('c')
n, d = deepest(root)
self.assertEqual('d', n.val)
self.assertEqual(3, d)
def test_solution():
from solution import Node, Preorder
items = Node(5)
items.left = Node(6)
items.right = Node(7)
items.left.left = Node(8)
items.left.right = Node(9)
result_value_1 = Preorder(items)
result = [5, 6, 8, 9, 7]
assert result_value_1 == result
def test_solution():
from solution import Node
items = Node(10)
items.left = Node(11)
items.left.left = Node(7)
items.right = Node(9)
items.right.left = Node(15)
items.right.right = Node(8)
val = 12
items.insert(val)
assert items.left.right.key == 12
def test_serialize(self):
# 1
# / \
# 3 4
# / \ \
# 2 5 7
tree = Node(1)
tree.left = Node(3)
tree.left.left = Node(2)
tree.left.right = Node(5)
tree.right = Node(4)
tree.right.right = Node(7)
self.assertEqual('1 3 2 # # 5 # # 4 # 7 # #', serialize(tree))
def test_solution():
from solution import Node, NthInorder
items = Node(5)
items.left = Node(6)
items.right = Node(7)
items.left.left = Node(8)
items.left.right = Node(9)
[8, 6, 9, 5, 7]
assert NthInorder(items, 4) == 5
assert NthInorder(items, 1) == 8
assert NthInorder(items, 6) == "no 6-th element"
def test_solution():
from solution import Node, closest_value
root = Node(8)
root.left = Node(5)
root.right = Node(14)
root.left.left = Node(4)
root.left.right = Node(6)
root.left.right.left = Node(8)
root.left.right.right = Node(7)
root.right.right = Node(24)
root.right.right.left = Node(22)
result = closest_value(root, 9)
assert result == 8
def test_solution():
from solution import Node, NthPreorder
items = Node(25)
items.left = Node(20)
items.right = Node(30)
items.left.left = Node(18)
items.left.right = Node(22)
items.right.left = Node(24)
items.right.right = Node(32)
assert NthPreorder(items, 6) == 24
assert NthPreorder(items, 4) == 22
assert NthPreorder(items, 8) == "no 8-th element"
def test_solution():
from solution import Node, search
items = Node(5)
items.left = Node(6)
items.right = Node(7)
items.left.left = Node(8)
items.left.right = Node(9)
items.right.left = Node(10)
items.right.right = Node(11)
result_value = search(items, 11)
result_value_2 = search(items, 99)
assert result_value == True
assert result_value_2 == False
def test_evaluate(self):
# *
# / \
# + +
# / \ / \
# - 2 4 5
# \
# -3
tree = Node('*')
tree.left = Node('+')
tree.left.left = Node('-')
tree.left.left.right = Node(-3)
tree.left.right = Node(2)
tree.right = Node('+')
tree.right.left = Node(4)
tree.right.right = Node(5)
self.assertEqual(45, evaluate(tree))
def test_romanToInt(self):
# Given this tree:
# 1
# / \
# 2 3
# / / \
# 0 9 4
# We want a tree like:
# 1
# / \
# 0 3
# / \
# 9 4
tree = Node(1)
tree.left = Node(2)
tree.right = Node(3)
tree.right.right = Node(4)
tree.right.left = Node(9)
tree.left.left = Node(0)
self.assertEqual('1\n03\n94', fullBinaryTree(tree).__str__())
import unittest
from solution import Node, findCeilingFloor
root = Node(8)
root.left = Node(4)
root.right = Node(12)
root.left.left = Node(2)
root.left.right = Node(6)
root.right.left = Node(10)
root.right.right = Node(14)
class Test(unittest.TestCase):
def test_findCeilingFloor_withEmptyTree(self):
self.assertEqual([None, None], findCeilingFloor(None, 0))
def test_findCeilingFloor(self):
self.assertEqual(findCeilingFloor(root, 1), [None, 2])
self.assertEqual(findCeilingFloor(root, 2), [2, 2])
self.assertEqual(findCeilingFloor(root, 3), [2, 4])
self.assertEqual(findCeilingFloor(root, 4), [4, 4])
self.assertEqual(findCeilingFloor(root, 5), [4, 6])
self.assertEqual(findCeilingFloor(root, 6), [6, 6])
self.assertEqual(findCeilingFloor(root, 7), [6, 8])
self.assertEqual(findCeilingFloor(root, 8), [8, 8])
self.assertEqual(findCeilingFloor(root, 9), [8, 10])
self.assertEqual(findCeilingFloor(root, 10), [10, 10])
self.assertEqual(findCeilingFloor(root, 11), [10, 12])
def test_handles_no_right_child():
tree = Node(7)
tree.left = Node(5)
assert (check_binary_search_tree_(tree) == True)
def test_compares_to_children():
tree = Node(7)
tree.left = Node(5)
tree.right = Node(8)
assert (check_binary_search_tree_(tree) == True)
import unittest
from solution import Node, invert
root = Node('a')
root.left = Node('b')
root.right = Node('c')
root.left.left = Node('d')
root.left.right = Node('e')
root.right.left = Node('f')
class Test(unittest.TestCase):
def test_invert(self):
self.assertEquals('abdecf', root.preorder())
invert(root)
self.assertEquals('acfbed', root.preorder())
if __name__ == '__main__':
unittest.main()
