def test_init_with_list_of_tuples(self):
tree = BinarySearchTree([(2, 'B'), (1, 'A'), (3, 'C')])
assert tree.root.data == (2, 'B')
assert tree.root.left.data == (1, 'A')
assert tree.root.right.data == (3, 'C')
assert tree.size == 3
assert tree.is_empty() is False
def main():
tree = BinarySearchTree()
tree.insert_list([20, 8, 22, 4, 12, 10, 14])
sucessor = tree.sucessor(tree.find(20))
def test_search_with_7_items(self):
# Create a complete binary search tree of 7 items in level-order
items = [4, 2, 6, 1, 3, 5, 7]
tree = BinarySearchTree(items)
for item in items:
assert tree.search(item) == item
assert tree.search(8) is None
def test_search_with_7_strings(self):
# Create a complete binary search tree of 7 items in level-order
items = ['D', 'B', 'F', 'A', 'C', 'E', 'G']
tree = BinarySearchTree(items)
for item in items:
assert tree.search(item) == item
assert tree.search('H') is None
def test_init_with_list_of_strings(self):
tree = BinarySearchTree(['B', 'A', 'C'])
assert tree.root.data == 'B'
assert tree.root.left.data == 'A'
assert tree.root.right.data == 'C'
assert tree.size == 3
assert tree.is_empty() is False
def test_init_with_list(self):
tree = BinarySearchTree([2, 1, 3])
assert tree.root.data == 2
assert tree.root.left.data == 1
assert tree.root.right.data == 3
assert tree.size == 3
assert tree.is_empty() is False
def test_search_third_use_case(self):
bt = BinarySearchTree()
bt.insert_multiple_values([10, 20, 22, 3, 7, 4, 32, 900])
node, depth = bt.search(4)
self.assertEqual(node.value, 4)
self.assertEqual(depth, 3)
def test_search_root_value(self):
bt = BinarySearchTree()
bt.insert_multiple_values([10, 20, 22, 3, 7, 4, 32, 900])
node, depth = bt.search(10)
self.assertEqual(node.value, 10)
self.assertEqual(depth, 0)
class BinaryTreeStringList():
"""Binary Tree String List"""
def __init__(self):
self.__tree = BinarySearchTree()
def __iter__(self):
return iter(self.__tree)
def __getitem__(self, key):
return self.__tree[key]
def __setitem__(self, key, value):
self.__tree[key] = value
def __str__(self):
return str(self.__tree)
def __len__(self):
return len(self.__tree)
def add(self, value):
self.__tree.put(value)
def find(self, value):
return value in self.__tree
def test_search_with_3_items(self):
# Create a complete binary search tree of 3 items in level-order
items = [2, 1, 3]
tree = BinarySearchTree(items)
assert tree.search(1) == 1
assert tree.search(2) == 2
assert tree.search(3) == 3
assert tree.search(4) is None
def test_search_with_3_strings(self):
# Create a complete binary search tree of 3 items in level-order
items = ['B', 'A', 'C']
tree = BinarySearchTree(items)
assert tree.search('A') == 'A'
assert tree.search('B') == 'B'
assert tree.search('C') == 'C'
assert tree.search('D') is None
def test_structure(self):
bt = BinarySearchTree()
bt.insert_multiple_values([10, 20, 22, 3, 7, 4, 32, 900])
self.assertEqual(bt.root.value, 10)
self.assertEqual(bt.root.left.value, 3)
self.assertEqual(bt.root.left.right.value, 7)
self.assertEqual(bt.root.left.right.left.value, 4)
def test_delete_with_linked_list_trees(self):
# Create a complete binary search tree of 7 items in level-order
items = [1, 2, 3, 4, 5, 6]
tree = BinarySearchTree(items)
tree.delete(2)
assert tree.root.data == 1
assert tree.root.left is None
assert tree.root.right.data == 3
assert tree.root.right.right.data == 4
assert tree.root.right.left is None
def test_delete_with_unbalanced_trees(self):
# Create a complete binary search tree of 7 items in level-order
items = [3, 6, 1, 2, 5, 7]
tree = BinarySearchTree(items)
tree.delete(2)
assert tree.root.data == 3
assert tree.root.left.data == 1
assert tree.root.right.data == 6
assert tree.root.left.left is None
assert tree.root.left.right is None
def setUp(self):
self.empty_bst = BinarySearchTree()
self.single_node_bst = BinarySearchTree()
self.single_node_bst.insert(-1)
self.small_bst = BinarySearchTree()
self.small_bst.insert(43)
self.small_bst.insert(43)
self.small_bst.insert(-2)
self.small_bst.insert(102)
self.toy_bst = get_toy_binary_search_tree()
def test_insert_with_7_items(self):
# Create a complete binary search tree of 7 items in level-order
items = [4, 2, 6, 1, 3, 5, 7]
tree = BinarySearchTree()
for item in items:
tree.insert(item)
assert tree.root.data == 4
assert tree.root.left.data == 2
assert tree.root.right.data == 6
assert tree.root.left.left.data == 1
assert tree.root.left.right.data == 3
assert tree.root.right.left.data == 5
assert tree.root.right.right.data == 7
def test_insert(self):
bstn = BinarySearchTreeNode(10)
bst = BinarySearchTree(bstn)
bst.insert(12)
bst.insert(8)
self.assertFalse(bst.is_in_tree(9))
self.assertTrue(bst.is_in_tree(12))
self.assertTrue(bst.is_in_tree(8))
def DISABLED_test_delete_with_3_items(self):
# Create a complete binary search tree of 3 items in level-order
items = [2, 1, 3]
tree = BinarySearchTree(items)
assert tree.root.data == 2
assert tree.root.left.data == 1
assert tree.root.right.data == 3
def test_size(self):
tree = BinarySearchTree()
assert tree.size == 0
tree.insert('B')
assert tree.size == 1
tree.insert('A')
assert tree.size == 2
tree.insert('C')
assert tree.size == 3
def test_deletion_first_use_case(self):
bt = BinarySearchTree()
bt.insert_multiple_values([10, 20, 22, 3, 7, 4, 32, 900])
node, depth = bt.search(4)
self.assertEqual(node.value, 4)
self.assertEqual(depth, 3)
bt.delete(4)
node, depth = bt.search(4)
self.assertIsNone(node)
self.assertEqual(bt.in_order(), [3, 7, 10, 20, 22, 32, 900])
def test_deletion_leaf(self):
bt = BinarySearchTree()
bt.insert_multiple_values([10, 20, 22, 3, 7, 4, 32, 900])
node, depth = bt.search(900)
self.assertEqual(node.value, 900)
self.assertEqual(depth, 4)
bt.delete(900)
node, _ = bt.search(900)
self.assertIsNone(node)
self.assertEqual(bt.in_order(), [3, 4, 7, 10, 20, 22, 32])
def test_inserts_value_to_the_right_if_greater_second_level(self):
bt = BinarySearchTree()
bt.insert(10)
bt.insert(11)
bt.insert(12)
self.assertEqual(bt.root.right.right.value, 12)
def test_inserts_value_to_the_right_and_then_left(self):
bt = BinarySearchTree()
bt.insert(10)
bt.insert(20)
bt.insert(15)
self.assertEqual(bt.root.right.left.value, 15)
def test_inserts_value_to_the_left_if_smaller_second_level(self):
bt = BinarySearchTree()
bt.insert(10)
bt.insert(2)
bt.insert(1)
self.assertEqual(bt.root.left.left.value, 1)
def test_insert_with_3_items(self):
# Create a complete binary search tree of 3 items in level-order
tree = BinarySearchTree()
tree.insert(2)
assert tree.root.data == 2
assert tree.root.left is None
assert tree.root.right is None
tree.insert(1)
assert tree.root.data == 2
assert tree.root.left.data == 1
assert tree.root.right is None
tree.insert(3)
assert tree.root.data == 2
assert tree.root.left.data == 1
assert tree.root.right.data == 3
def test_size(self):
bstn = BinarySearchTreeNode(10)
bst = BinarySearchTree(bstn)
bst.insert(12)
bst.insert(8)
bst.insert(7)
self.assertEqual(size(bst.root), 4)
def test_delete_with_3_items(self):
# Create a complete binary search tree of 3 items in level-order
items = [2, 1, 3]
tree = BinarySearchTree(items)
assert tree.root.data == 2
assert tree.root.left.data == 1
assert tree.root.right.data == 3
tree.delete(2)
assert tree.root.data == 1
assert tree.root.left is None
assert tree.root.right.data is 3
tree.delete(1)
assert tree.root.data == 3
assert tree.root.left is None
assert tree.root.right is None
tree.delete(3)
assert tree.root is None
def test_delete_with_7_items(self):
# Create a complete binary search tree of 7 items in level-order
items = [4, 2, 6, 1, 3, 5, 7]
tree = BinarySearchTree(items)
tree.delete(4)
assert tree.root.data == 3
assert tree.root.left.data == 2
assert tree.root.right.data == 6
assert tree.root.left.left.data == 1
assert tree.root.left.right is None
tree.delete(6)
assert tree.root.data == 3
assert tree.root.left.data == 2
assert tree.root.right.data == 5
assert tree.root.right.left is None
assert tree.root.right.right.data == 7
tree.delete(5)
assert tree.root.data == 3
assert tree.root.left.data == 2
assert tree.root.right.data == 7
assert tree.root.right.left == None
assert tree.root.right.right == None
def test_is_bst(self):
bstn = BinarySearchTreeNode(10)
bst = BinarySearchTree(bstn)
bst.insert(12)
bst.insert(8)
bst.insert(7)
self.assertEqual(is_bst(bst.root, None, None), True)
bstn = BinarySearchTreeNode(10)
bstn.left = BinarySearchTreeNode(10)
bstn.left.left = BinarySearchTreeNode(11)
bstn.right = BinarySearchTreeNode(12)
self.assertEqual(is_bst(bstn, None, None), False)
bstn = BinarySearchTreeNode(20)
bstn.left = BinarySearchTreeNode(10)
bstn.left.right = BinarySearchTreeNode(25)
bstn.right = BinarySearchTreeNode(30)
self.assertEqual(is_bst(bstn, None, None), False)
def test_delete_node(self):
values = [7, 3, 23, 1, 5, 9, 52, 2, 4, 36]
tr = BinarySearchTree()
for v in values:
tr.insert(v)
tr.populate_parent()
expected_in_order_tree_after_7_delete = \
[1, 2, 3, 4, 5, 9, 23, 36, 52]
tr.delete_data(7)
self.assertEquals(tr.getInOrderPath(), expected_in_order_tree_after_7_delete)
self.assertRaises(Exception, tr.delete_data, 6)
expected_in_order = \
[1, 3, 4, 5, 9, 23, 36, 52]
tr.delete_data(2)
self.assertEquals(tr.getInOrderPath(), expected_in_order)
expected_in_order = \
[1, 4, 5, 9, 23, 36, 52]
tr.delete_data(3)
self.assertEquals(tr.getInOrderPath(), expected_in_order)
expected_in_order = \
[1, 4, 5, 9, 23, 36]
tr.delete_data(52)
self.assertEquals(tr.getInOrderPath(), expected_in_order)
expected_in_order = \
[1, 5, 9, 23, 36]
tr.delete_data(4)
self.assertEquals(tr.getInOrderPath(), expected_in_order)
class TestBinarySearchTree(unittest.TestCase):
def setUp(self):
self.empty_bst = BinarySearchTree()
self.single_node_bst = BinarySearchTree()
self.single_node_bst.insert(-1)
self.small_bst = BinarySearchTree()
self.small_bst.insert(43)
self.small_bst.insert(43)
self.small_bst.insert(-2)
self.small_bst.insert(102)
self.toy_bst = get_toy_binary_search_tree()
def test_maxValue(self):
self.assertRaises(TypeError, self.empty_bst.maxValue)
self.assertEqual(-1, self.single_node_bst.maxValue())
self.assertEqual(102, self.small_bst.maxValue())
self.assertEqual(102, self.toy_bst.maxValue())
def test_minValue(self):
self.assertRaises(TypeError, self.empty_bst.minValue)
self.assertEqual(-1, self.single_node_bst.minValue())
self.assertEqual(-2, self.small_bst.minValue())
self.assertEqual(-1, self.toy_bst.minValue())
def test_delete_node(self):
values = [7, 3, 23, 1, 5, 9, 52, 2, 4, 36]
tr = BinarySearchTree()
for v in values:
tr.insert(v)
tr.populate_parent()
expected_in_order_tree_after_7_delete = \
[1, 2, 3, 4, 5, 9, 23, 36, 52]
tr.delete_data(7)
self.assertEquals(tr.getInOrderPath(), expected_in_order_tree_after_7_delete)
self.assertRaises(Exception, tr.delete_data, 6)
expected_in_order = \
[1, 3, 4, 5, 9, 23, 36, 52]
tr.delete_data(2)
self.assertEquals(tr.getInOrderPath(), expected_in_order)
expected_in_order = \
[1, 4, 5, 9, 23, 36, 52]
tr.delete_data(3)
self.assertEquals(tr.getInOrderPath(), expected_in_order)
expected_in_order = \
[1, 4, 5, 9, 23, 36]
tr.delete_data(52)
self.assertEquals(tr.getInOrderPath(), expected_in_order)
expected_in_order = \
[1, 5, 9, 23, 36]
tr.delete_data(4)
self.assertEquals(tr.getInOrderPath(), expected_in_order)
def test_init(self):
tree = BinarySearchTree()
assert tree.root is None
assert tree.size == 0
assert tree.is_empty() is True
def test_items_level_order_with_3_strings(self):
# Create a complete binary search tree of 3 strings in level-order
items = ['B', 'A', 'C']
tree = BinarySearchTree(items)
# Ensure the level-order traversal of tree items is ordered correctly
assert tree.items_level_order() == ['B', 'A', 'C']
def test_items_level_order_with_7_numbers(self):
# Create a complete binary search tree of 7 items in level-order
items = [4, 2, 6, 1, 3, 5, 7]
tree = BinarySearchTree(items)
# Ensure the level-order traversal of tree items is ordered correctly
assert tree.items_level_order() == [4, 2, 6, 1, 3, 5, 7]
