def test_find_rand_value(self):
bst = Tree()
for i in [[10, 1], [12, 2], [11, 3], [14, 4], [13, 5]]:
bst.insert(i)
for j in range(100):
search_for = random.randint(10, 14)
r = bst.search(search_for)
if search_for == 10:
s = [10, 1]
elif search_for == 11:
s = [11, 3]
elif search_for == 12:
s = [12, 2]
elif search_for == 13:
s = [13, 5]
elif search_for == 14:
s = [14, 4]
self.assertEqual(r, s)
def test_insert_rand_values(self):
for num in range(100):
bst = Tree()
L = []
M = []
for i in range(100):
rand_int = random.randint(1, 100)
if rand_int not in L:
L.append(rand_int)
for j in L:
rand_ints = []
rand_int_2 = random.randint(1, 100)
rand_ints.append(j)
rand_ints.append(rand_int_2)
M.append(rand_ints)
for k in M:
r = bst.insert(k)
self.assertEqual(r, True)
def build_database(structure, num_keys, key_value_pairs):
if structure == 'binary':
database = Tree()
for i in key_value_pairs:
database.insert(i)
return database
elif structure == 'AVL':
database = AVL()
for i in key_value_pairs:
database.insert(i)
return database
elif structure == 'hash':
database = LPHashTable(num_keys, h_rolling)
for i in key_value_pairs:
database.insert(i[0], i[1])
return database
import sys
def is_bst(node, min_val=None, max_val=None):
if min_val is None:
min_val = -sys.maxint - 1
if max_val is None:
max_val = sys.maxint
if node is None:
return True
if node.value <= min_val or node.value > max_val:
return False
if (not is_bst(node.leftChild, min_val, node.value) or
not is_bst(node.rightChild, node.value, max_val)):
return False
return True
if __name__ == "__main__":
bst = Tree()
assert bst.insert(40)
assert bst.insert(25)
assert bst.insert(10)
assert bst.insert(32)
assert bst.insert(78)
assert(is_bst(bst.root))
if rightHeight == -1:
return -1
if abs(leftHeight - rightHeight) > 1:
return -1
else:
return max(leftHeight, rightHeight) + 1
def is_balanced(root):
if root is None: return True
if getHeight(root) == -1:
return False
else:
return True
if __name__ == "__main__":
bst = Tree()
bst.insert(10)
assert is_balanced(bst.root)
bst.insert(8)
assert is_balanced(bst.root)
bst.insert(12)
assert is_balanced(bst.root)
bst.insert(5)
bst.insert(6)
assert not is_balanced(bst.root)
print("all good")
def test_raise_exception(self):
test = Tree(9)
test.insert(33)
test.insert(56)
self.assertRaises(TypeError, test, "hello")
def test_insertion(self):
sample = Tree(5)
test = Tree(14)
self.assertEqual(sample.insert(10),test.insert(10))
def test_deletion(self):
sample = Tree(14)
sample.insert(2)
sample.insert(56)
self.assertNotEqual(sample.delete_node(sample, 56), 0)
def test_deletion2(self):
test = Tree(9)
test.insert(33)
test.insert(56)
self.assertTrue(test.delete_node(test, 9), 0)
class TestTree:
def setup(self):
self.test_tree = Tree()
self.test_key_4 = 4
self.test_key_2 = 2
self.test_key_5 = 5
self.test_key_3 = 3
self.test_key_6 = 6
self.test_key_1 = 1
self.test_data = "test_data"
def test_insert(self):
root = self.test_tree.insert(self.test_key_4, self.test_data)
assert root == "Root node created"
node = self.test_tree.insert(self.test_key_2, self.test_data)
assert node == "New node created"
duplicate_node = self.test_tree.insert(self.test_key_2, self.test_data)
assert duplicate_node == "Node with this key already exists"
def test_find_empty_tree(self):
message = self.test_tree.find(1)
assert message == "Empty Tree"
def test_find_does_not_exist(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
no_node = self.test_tree.find(self.test_key_3)
assert no_node == "Node with this key does not exist"
def test_find(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
root_node = self.test_tree.find(self.test_key_4)
assert str(root_node) == "Key: 4"
left_child = self.test_tree.find(self.test_key_2)
assert str(left_child) == "Key: 2"
right_child = self.test_tree.find(self.test_key_5)
assert str(right_child) == "Key: 5"
def test_create_key_list(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
self.test_tree.insert(self.test_key_3, self.test_data)
self.test_tree.insert(self.test_key_6, self.test_data)
self.test_tree.insert(self.test_key_1, self.test_data)
expected_result = [1, 2, 3, 4, 5, 6]
result = self.test_tree.create_key_list()
assert result == expected_result
def test_insert(self):
t = Tree()
t.insert(2)
self.assertEqual(list(t.display()), [2])
def test_find_same_value(self):
bst = Tree()
for i in [[10, 1], [12, 2], [12, 3], [17, 3], [14, 4], [15, 5]]:
bst.insert(i)
r = bst.search(12)
self.assertEqual(r, [12, 2, 3])
class TestTree:
def setup(self):
self.test_tree = Tree()
self.test_key_4 = 4
self.test_key_2 = 2
self.test_key_5 = 5
self.test_key_3 = 3
self.test_key_6 = 6
self.test_key_1 = 1
self.test_data = 'test_data'
def test_insert(self):
root = self.test_tree.insert(self.test_key_4, self.test_data)
assert root == 'Root node created'
node = self.test_tree.insert(self.test_key_2, self.test_data)
assert node == 'New node created'
duplicate_node = self.test_tree.insert(self.test_key_2, self.test_data)
assert duplicate_node == 'Node with this key already exists'
def test_find_empty_tree(self):
message = self.test_tree.find(1)
assert message == 'Empty Tree'
def test_find_does_not_exist(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
no_node = self.test_tree.find(self.test_key_3)
assert no_node == 'Node with this key does not exist'
def test_find(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
root_node = self.test_tree.find(self.test_key_4)
assert str(root_node) == 'Key: 4'
left_child = self.test_tree.find(self.test_key_2)
assert str(left_child) == 'Key: 2'
right_child = self.test_tree.find(self.test_key_5)
assert str(right_child) == 'Key: 5'
def test_create_key_list(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
self.test_tree.insert(self.test_key_3, self.test_data)
self.test_tree.insert(self.test_key_6, self.test_data)
self.test_tree.insert(self.test_key_1, self.test_data)
expected_result = [1, 2, 3, 4, 5, 6]
result = self.test_tree.create_key_list()
assert result == expected_result
def test_cannot_find_value(self):
bst = Tree()
for i in [[10, 1], [12, 2], [17, 3], [14, 4], [15, 5]]:
bst.insert(i)
r = bst.search(20)
self.assertEqual(r, False)
return max(leftHeight, rightHeight) + 1
def is_balanced(root):
if root is None: return True
if getHeight(root) == -1:
return False
else:
return True
if __name__ == "__main__":
bst = Tree()
bst.insert(10)
assert is_balanced(bst.root)
bst.insert(8)
assert is_balanced(bst.root)
bst.insert(12)
assert is_balanced(bst.root)
bst.insert(5)
bst.insert(6)
assert not is_balanced(bst.root)
print("all good")
def test_insert_rand_value(self):
bst = Tree()
k = [random.randint(1, 100), random.randint(1, 100)]
r = bst.insert(k)
self.assertEqual(r, True)
def test_insert_same_key(self):
bst = Tree()
for i in [[10, 1], [12, 2], [17, 3], [14, 4], [15, 5]]:
bst.insert(i)
r = bst.insert([12, 4])
self.assertEqual(r, False)
def test_insert_values(self):
bst = Tree()
for i in [[10, 1], [12, 2], [17, 3], [14, 4], [15, 5]]:
r = bst.insert(i)
self.assertEqual(r, True)
def is_bst(node, min_val=None, max_val=None):
if min_val is None:
min_val = -sys.maxint - 1
if max_val is None:
max_val = sys.maxint
if node is None:
return True
if node.value <= min_val or node.value > max_val:
return False
if (not is_bst(node.leftChild, min_val, node.value)
or not is_bst(node.rightChild, node.value, max_val)):
return False
return True
if __name__ == "__main__":
bst = Tree()
assert bst.insert(40)
assert bst.insert(25)
assert bst.insert(10)
assert bst.insert(32)
assert bst.insert(78)
assert (is_bst(bst.root))
def test_insert_value(self):
bst = Tree()
r = bst.insert([10, 2])
self.assertEqual(r, True)
