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)