def main():
""" Main driver function to test binary search. """
test = BinarySearchTree()
test.add(21)
test.add(26)
test.add(30)
test.add(9)
test.add(4)
test.add(14)
test.add(28)
test.add(18)
test.add(15)
test.add(10)
test.add(2)
test.add(3)
test.add(7)
preorder = test.preorder()
for item in preorder:
print(str(item) + ", ", end=" ")
print("")
print(test)
print("Lonsg string so I can see the test height: ", test.height())
test.remove(21)
test.remove(9)
test.remove(4)
test.remove(18)
test.remove(15)
test.remove(7)
print(test)
bst = BinarySearchTree()
print("Produced: ", bst.height())
print("Expects: ", -1)
for i in range(511):
bst.add(i)
print("Produced: ", bst.height())
print("Expects: ", 510)
bst.rebalance_tree()
print("Produced: ", bst.height())
print("Expects: ", 8)
newtest = BinarySearchTree()
for i in range(7):
newtest.add(i)
newtest.rebalance_tree()
print(newtest)
lasttest = BinarySearchTree()
lasttest.add(1)
print("Added")
lasttest.add(1)
def test_delete(self):
items = [4, 2, 6, 1, 3, 5, 7]
bst = BinarySearchTree(items)
bst.delete(1)
assert bst.size == 6
assert bst.root.left.left == None
bst.delete(2)
assert bst.size == 5
assert bst.root.left.data == 3
bst2 = BinarySearchTree(items)
bst2.delete(4)
assert bst2.size == 6
assert bst2.root.data == 3
assert bst2.root.left.right == None
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]
bst = BinarySearchTree(items)
for item in items:
assert bst.search(item) == item
assert bst.search(8) is None
def test03_to_List(self):
binarytree = BinarySearchTree()
binarytree.setData(10)
binarytree.insert(17)
binarytree.insert(16)
binarytree.insert(14)
self.assertEqual(binarytree.toList(), [10, 14, 16, 17])
def test_find_nontrivial_tree(self):
bst = BinarySearchTree()
data = [20, 50, 1, 150, 42]
for d in data:
bst.insert(d)
data.sort()
self.assertEqual(bst.toList(), data)
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']
bst = BinarySearchTree(items)
for item in items:
assert bst.search(item) == item
assert bst.search('H') is None
def test_find_missing_Value(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
self.assertEqual(bst.find(401), None)
def test_find_present_value(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
self.assertEqual(bst.find(data[0]).data, data[0])
def main():
""" Main driver function to test binary search. """
test = BinarySearchTree()
test.add(21)
test.add(26)
test.add(30)
test.add(9)
test.add(4)
test.add(14)
test.add(28)
test.add(18)
test.add(15)
test.add(10)
test.add(2)
test.add(3)
test.add(7)
preorder = test.preorder()
for item in preorder:
print(str(item) + ", ", end=" ")
print("")
print(test)
test.remove(21)
test.remove(9)
test.remove(4)
test.remove(18)
test.remove(15)
test.remove(7)
print(test)
def test_tree_size(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
self.assertEqual(len(bst), 123)
def main():
"""Main function"""
tree = BinarySearchTree()
tree.add(21)
tree.add(26)
tree.add(30)
tree.add(9)
tree.add(4)
tree.add(14)
tree.add(28)
tree.add(18)
tree.add(15)
tree.add(10)
tree.add(2)
tree.add(3)
tree.add(7)
pre = tree.preorder()
for item in pre:
print(item, end=', ')
print('')
print(tree)
tree.remove(21)
tree.remove(9)
tree.remove(4)
tree.remove(18)
tree.remove(15)
tree.remove(7)
print(tree)
def test_init_with_list_of_strings(self):
bst = BinarySearchTree(['B', 'A', 'C'])
assert bst.root.data == 'B'
assert bst.root.left.data == 'A'
assert bst.root.right.data == 'C'
assert bst.size == 3
assert bst.is_empty() is False
def test_tree_height(self):
bst = BinarySearchTree()
bst.add(123)
self.assertEqual(bst.height(), 1)
bst.add(12)
bst.add(2)
self.assertEqual(bst.height(), 3)
def main():
"""Driver function for a binary search tree."""
bst = BinarySearchTree()
data = [21, 26, 30, 9, 4, 14, 28, 18, 15, 10, 2, 3, 7]
# data = [25, 50, 57, 100, 125, 150, 200]
for i in data:
bst.add(i)
print('21, 9, 4, 2, 3, 7, 14, 10, 18, 15, 26, 30, 28,')
bst.preorder()
print(bst)
# data2 = [21,9,4,18,15,7]
# for i in data2:
# bst.remove(i)
# bst.preorder()
# print(bst)
print('inorder: ', bst.inorder())
print('Height: ', bst.height())
print('Length: ', bst.__len__())
bst.remove(14)
bst.remove(7)
bst.remove(9)
print(bst.rebalance_tree())
print('Height: ', bst.height())
# bst.display()
print('-=-=-')
bst._is_balanced()
print('------')
def test_init_with_list(self):
bst = BinarySearchTree([2, 1, 3])
assert bst.root.data == 2
assert bst.root.left.data == 1
assert bst.root.right.data == 3
assert bst.size == 3
assert bst.is_empty() is False
def test_find_nontrivial_tree(self):
bst = BinarySearchTree()
data = [20, 50, 1, 150, 42]
for d in data:
bst.insert(d)
for d in data:
self.assertEqual(bst.find(d).getData(), d)
def test_init_with_list_of_tuples(self):
bst = BinarySearchTree([(2, 'B'), (1, 'A'), (3, 'C')])
assert bst.root.data == (2, 'B')
assert bst.root.left.data == (1, 'A')
assert bst.root.right.data == (3, 'C')
assert bst.size == 3
assert bst.is_empty() is False
def test_insert_node_to_left(self):
new_node = Node(3)
bst = BinarySearchTree(new_node)
left_node = Node(2)
bst.insert(bst, left_node)
self.assertEqual(bst.left.val, 2)
bst.insert(bst, Node(1))
self.assertEqual(bst.left.left.val, 1)
def test_search_with_3_strings(self):
# Create a complete binary search tree of 3 items in level-order
items = ['B', 'A', 'C']
bst = BinarySearchTree(items)
assert bst.search('A') == 'A'
assert bst.search('B') == 'B'
assert bst.search('C') == 'C'
assert bst.search('D') is None
def test_recursive_add(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=20)
rc.recursion_count = 0
for datum in data:
bst.add(datum)
self.assertGreater(rc.recursion_count, 15)
def test_remove(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 100), k=10)
for datum in data:
bst.add(datum)
bst.remove(data[0])
self.assertEqual(bst.find(data[0]), None)
def test_insert_and_delete_tree(self):
bst = BinarySearchTree(10)
bst.insert(20)
self.assertEqual(bst.size(), 2)
bst = bst.delete(20)
self.assertEqual(bst.size(), 1)
bst = bst.delete(10)
self.assertEqual(bst.size(), 0)
def test_preorder_output(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
output = bst.preorder()
self.assertEqual(output[0], data[0])
def test_preorder_type(self):
bst = BinarySearchTree()
seed(0)
data = sample(range(1, 400), k=123)
for datum in data:
bst.add(datum)
output = bst.preorder()
self.assertTrue(isinstance(output, list))
def test_insert_node_to_right(self):
new_node = Node(3)
bst = BinarySearchTree(new_node)
right_node = Node(4)
bst.insert(bst, right_node)
self.assertEqual(bst.right.val, 4)
bst.insert(bst, Node(5))
self.assertEqual(bst.right.right.val, 5)
def test_search_with_3_items(self):
# Create a complete binary search tree of 3 items in level-order
items = [2, 1, 3]
bst = BinarySearchTree(items)
assert bst.search(1) == 1
assert bst.search(2) == 2
assert bst.search(3) == 3
assert bst.search(4) is None
def test_delete_root_node(self):
bst = BinarySearchTree(10)
bst.insert(20)
bst.insert(30)
bst.insert(5)
bst.insert(9)
self.assertEqual(bst.size(), 5)
bst = bst.delete(10)
self.assertEqual(bst.size(), 4)
def test_tree_height(self):
bst = BinarySearchTree()
self.assertEqual(bst.height(), -1)
for i in range(511):
bst.add(i)
self.assertEqual(bst.height(), 510)
bst.rebalance_tree()
self.assertEqual(bst.height(), 8)
def test_size(self):
bst = BinarySearchTree()
assert bst.size == 0
bst.insert('B')
assert bst.size == 1
bst.insert('A')
assert bst.size == 2
bst.insert('C')
assert bst.size == 3
def main():
tree = BinarySearchTree() # instantiating the BinarySearchTree to be used.
for x in range(511):
tree.add(3)
tree.rebalance_tree()
print(tree)
