class TestBinarySearchTree(unittest.TestCase):
def setUp(self):
self.bst = None
def _initialize(self):
self._cleanup()
self.bst = BinarySearchTree()
lst = [5, 8, 2, 1, 3, 9, 7, 4, 6, 0]
for i in lst:
self.bst.insert(i)
def _cleanup(self):
if self.bst:
del(self.bst)
self.bst = None
def test_insert(self):
self._initialize()
self.assertEqual(len(self.bst), 10)
def test_delete(self):
self._initialize()
self.bst.delete(5)
self.assertEqual(len(self.bst), 9)
def test_iteration(self):
self._initialize()
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in self.bst.root:
self.assertTrue(i == lst[i])
def tearDown(self):
self._cleanup()
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])
class TreeTraversal(object):
def __init__(self, elements=None):
if not elements or not len(elements) > 1:
raise ValueError('Please provide data to traverse.')
self.tree = BinarySearchTree(BST_Node(elements.pop(0)))
print(self.tree.head)
for element in elements:
self.tree.insert(element)
# Left - Root - Right
def inorder(self, node=None):
if node:
self.inorder(node.get_next('left'))
print(node.data)
self.inorder(node.get_next('right'))
# Root - Left - Right
def preorder(self, node=None):
if node:
print(node.data)
self.inorder(node.get_next('left'))
self.inorder(node.get_next('right'))
# Left - Right - Root
def postorder(self, node=None):
if node:
self.inorder(node.get_next('left'))
self.inorder(node.get_next('right'))
print(node.data)
def breadthfirst(self):
raise NotImplementedError
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_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_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_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_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_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_delete_method(self):
bst = BinarySearchTree(Node(50))
bst.insert(bst, Node(40))
bst.insert(bst, Node(70))
bst.insert(bst, Node(60))
bst.insert(bst, Node(80))
bst.delete(bst, 50)
self.assertEqual(bst.val, 60)
bst.delete(bst, 40)
self.assertIsNone(bst.left)
bst.delete(bst, 80)
self.assertIsNone(bst.right.right)
def test_search_method(self):
new_node = Node(3)
bst = BinarySearchTree(new_node)
right_node = Node(4)
bst.insert(bst, right_node)
left_node = Node(2)
bst.insert(bst, left_node)
res = bst.search(bst, 2)
self.assertEqual(res.val, 2)
res = bst.search(bst, 4)
self.assertEqual(res.val, 4)
res = bst.search(bst, 5)
self.assertIsNone(res)
def test_delete(self):
# Create a complete binary search tree of 7 items in level-order
items = [4, 2, 6, 1, 3, 5, 7]
bst = BinarySearchTree()
for item in items:
bst.insert(item)
# Delete the specific nodes
bst.delete(7)
assert bst.contains(7) is False
bst.delete(2)
assert bst.contains(2) is False
assert bst.root.left.data == 1
assert bst.root.left.left.data is None
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]
bst = BinarySearchTree()
for item in items:
bst.insert(item)
assert bst.root.data == 4
assert bst.root.left.data == 2
assert bst.root.right.data == 6
assert bst.root.left.left.data == 1
assert bst.root.left.right.data == 3
assert bst.root.right.left.data == 5
assert bst.root.right.right.data == 7
def test_binary_search_tree():
for i in range(1000):
random_list = []
t = BinarySearchTree()
for j in range(100):
random_number = random.randrange(-1000, 1000, 1)
random_list.append(random_number)
t.insert(random_number)
for random_number in random_list:
assert random_number in t
next_random_number = random.randrange(-1000, 1000, 1)
if next_random_number not in random_list:
assert next_random_number not in t
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 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_insert_with_3_items(self):
# Create a complete binary search tree of 3 items in level-order
bst = BinarySearchTree()
bst.insert(2)
assert bst.root.data == 2
assert bst.root.left is None
assert bst.root.right is None
bst.insert(1)
assert bst.root.data == 2
assert bst.root.left.data == 1
assert bst.root.right is None
bst.insert(3)
assert bst.root.data == 2
assert bst.root.left.data == 1
assert bst.root.right.data == 3
return root
_bst2dll(root.left, prev, h)
if prev.value is None:
head = root
h.value = root
else:
root.left = prev.value
prev.value.right = root
prev.value = root
_bst2dll(root.right, prev, h)
def printList(head):
tmp = head
while tmp.right is not None:
print(tmp.right.data)
tmp = tmp.right
s = BinarySearchTree(5)
s.insert(s.root, 3)
s.insert(s.root, 4)
s.insert(s.root, 2)
s.insert(s.root, 7)
s.insert(s.root, 6)
s.insert(s.root, 9)
h = bst2dll(s.root)
printList(h)
f = open('names_2.txt', 'r')
names_2 = f.read().split("\n") # List containing 10000 names
f.close()
duplicates = [] # Return the list of duplicates in this data structure
# # Replace the nested for loops below with your improvements
# for name_1 in names_1:
# for name_2 in names_2:
# if name_1 == name_2:
# duplicates.append(name_1)
# For each name in names_1, insert name into a binary search tree
best_n = BinarySearchTree(names_1[0])
for name1 in names_1:
best_n.insert(name1)
# For each name in names_2, check if bst contains name.
for name2 in names_2:
# If true, append name from names_2 to duplicates
if best_n.contains(name2):
duplicates.append(name2)
duplicates.sort()
end_time = time.time()
print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")
print(f"runtime: {end_time - start_time} seconds")
# ---------- Stretch Goal -----------
# Python has built-in tools that allow for a very efficient approach to this problem
# print()
# myList.display()
# print()
# myList.delete_first()
# myList.display()
# print()
# myList.delete(8)
# myList.display()
# print()
# print(myList.size)
# Binary Search Tree
print('*****Binary search tree testing*****')
my_tree = BinarySearchTree()
root = None
root = my_tree.insert(root, 3)
my_tree.insert(root, 7)
my_tree.insert(root, 1)
my_tree.insert(root, 5)
my_tree.insert(root, 10)
print('in order')
my_tree.display_in_order(root)
print('pre order')
my_tree.display_pre_order(root)
print('post order')
my_tree.display_post_order(root)
val = 7
print('contains', val, my_tree.contains(root, val))
val = 2
print('contains', val, my_tree.contains(root, val))
val = 10
def test02_Incert(self):
binarytree = BinarySearchTree()
binarytree.setData(10)
binarytree.insert(17)
self.assertEqual(binarytree.size(), 2)
while not done:
if len(stack1) == 0 or len(stack2) == 0:
return None
dl = stack1.pop()
dr = stack2.pop()
if dl.data + dr.data == n:
done = True
return [dl.data, dr.data]
elif dl.data + dr.data > n:
if dr.left:
stack2.append(dr.left)
elif dl.data + dr.data < n:
if dl.right:
stack1.append(dl.right)
if len(stack1) == 0 and len(stack2) == 0:
done = True
print(stack1)
print(stack2)
t = BinarySearchTree(5)
t.insert(t.root, 3)
t.insert(t.root, 4)
t.insert(t.root, 2)
t.insert(t.root, 7)
t.insert(t.root, 6)
t.insert(t.root, 9)
print(findPair(t.root, 16))
def test_insert_multiple_items_from_nonempty_tree(self):
bst = BinarySearchTree(20)
bst.insert(10)
bst.insert(30)
bst.insert(5)
self.assertEqual(bst.size(), 4)
def test_insert_from_nonempty_tree(self):
bst = BinarySearchTree(10)
bst.insert(20)
self.assertEqual(bst.size(), 2)
