def test_delete(): bs_tree = BinarySearchTree() keys = [5, 2, -4, 3, 12, 9 ,21, 19, 25] for key in keys: node = Node() node.key = key bs_tree.insert(node) # delete leaf bs_tree.delete(bs_tree.search(-4)) assert(bs_tree.search(-4) is None) assert(bs_tree.search(2).left is None) # delete node with one child bs_tree.delete(bs_tree.search(2)) assert(bs_tree.search(2) is None) assert(bs_tree.root.left.key == 3) # delete node with two children bs_tree.delete(bs_tree.search(12)) assert(bs_tree.root.right.key == 19) assert(bs_tree.search(19).left.key == 9) assert(bs_tree.search(19).right.key == 21) # delete root bs_tree.delete(bs_tree.root) assert(bs_tree.root.key == 9) assert(bs_tree.root.left.key == 3) assert(bs_tree.root.right.key == 19)
def test_insert_whenInsertingLowerValue_insertsAsLeftChild(self): bst = BinarySearchTree() bst.insert(10, bst.root) bst.insert(5, bst.root) self.assertEqual(len(bst), 2) self.assertEqual(bst.root.left.value, 5)
def test_root_remove(self): tree = BinarySearchTree() tree.insert(10) self.assertTrue(tree.remove(10)) self.assertFalse(tree.search(10)) tree.insert(10) tree.insert(20) self.assertTrue(tree.remove(10)) self.assertFalse(tree.search(10)) self.assertTrue(tree.search(20)) self.assertTrue(tree.remove(20)) tree.insert(10) tree.insert(20) tree.insert(5) tree.insert(25) tree.insert(11) self.assertTrue(tree.remove(10)) self.assertEqual(tree.root.value, 11) self.assertTrue(tree.search(5)) self.assertTrue(tree.search(20)) self.assertTrue(tree.search(25)) self.assertFalse(tree.search(10))
class TestBinaryTree(unittest.TestCase): def setUp(self): self.binarySearchTree = BinarySearchTree() def test_0(self): print("{} Can create binary search tree object".format(inspect.stack()[0][3])) self.assertTrue(type(self.binarySearchTree) is BinarySearchTree) def test_1(self): print("{} Newly created tree, root value should be None".format(inspect.stack()[0][3])) self.assertEqual(self.binarySearchTree.root.value, None) def test_2(self): print("{} Insert value in new tree, root.value is inserted value".format(inspect.stack()[0][3])) self.binarySearchTree.insert(5) self.assertEqual(self.binarySearchTree.root.value, 5) def test_3(self): print("{} Insert value, search returns true for value inserted".format(inspect.stack()[0][3])) self.binarySearchTree.insert(5) self.assertTrue(self.binarySearchTree.search(5)) def test_4(self): print("{} Insert value, search returns false for value not inserted".format(inspect.stack()[0][3])) self.binarySearchTree.insert(5) self.assertFalse(self.binarySearchTree.search(6)) def test_5(self): print("{} Insert two values, search returns true for both values".format(inspect.stack()[0][3])) self.binarySearchTree.insert(5) self.binarySearchTree.insert(6) self.assertTrue(self.binarySearchTree.search(5)) self.assertTrue(self.binarySearchTree.search(6)) def test_6(self): print("{} Fill BST, see if is BST".format(inspect.stack()[0][3])) for x in range(0, 50): self.binarySearchTree.insert(random.randint(0,50)) self.assertTrue(self.isBST(self.binarySearchTree.root)) # Returns true if the given tree is a binary search tree # Test courtesy of http://www.geeksforgeeks.org/a-program-to-check-if-a-binary-tree-is-bst-or-not/ def isBST(self, node): return (self.isBSTUtil(node, INT_MIN, INT_MAX)) # Returns true if the given tree is a BST and its values # >= min and <= max def isBSTUtil(self, node, mini, maxi): # An empty tree is BST if node.value is None: return True # False if this node violates min/max constraint if node.value < mini or node.value > maxi: return False # Otherwise check the subtrees recursively # tightening the min or max constraint return (self.isBSTUtil(node.left, mini, node.value -1) and self.isBSTUtil(node.right, node.value+1, maxi))
def test_delete_one_child(self): tree = BinarySearchTree(10) tree.insert(20) tree.insert(17) tree.insert(11) tree.insert(19) tree.deleteNode(tree, 19) self.assertEqual(tree.toList(), [10,20, 17, 11])
def test_find_leaf(self): keys = {1, 2, 3} binary_search_tree = BinarySearchTree() for key in keys: binary_search_tree.insert(key, key) result = binary_search_tree.find_leaf(binary_search_tree.root) self.assert_node_has_no_children(result)
def test_delete_two_childs(self): tree = BinarySearchTree(10) tree.insert(20, 0, 100, 50, 30, 17) print("\ntest tree") tree.printHierarchy() print("\nDepth") print(tree.getDepth()) tree.deleteNode(tree,20) print("\nremoved node with data == 20") tree.printHierarchy()
def test_maximum(): bs_tree = BinarySearchTree() assert(bs_tree.minimum(bs_tree.root) is None) keys = [6, 5, 7, 2, 5, 8] for key in keys: node = Node() node.key = key bs_tree.insert(node) assert(bs_tree.maximum(bs_tree.root).key == 8) subtree = bs_tree.search(5) assert(bs_tree.maximum(subtree).key == 5)
def test_search(): bs_tree = BinarySearchTree() assert(bs_tree.search(2) is None) keys = [6, 5, 7, 2] for key in keys: node = Node() node.key = key bs_tree.insert(node) assert(bs_tree.search(6).key == 6) assert(bs_tree.search(7).key == 7) assert(bs_tree.search(8) is None)
def test_insert(): bs_tree = BinarySearchTree() keys = [6, 5, 7, 2, 5, 8] for key in keys: node = Node() node.key = key bs_tree.insert(node) assert(bs_tree.search(6).key == 6) assert(bs_tree.search(5).key == 5) assert(bs_tree.search(7).key == 7) assert(bs_tree.search(8).key == 8)
def test_add_right_child(self): key1 = 1 key2 = 2 value1 = 1 value2 = 2 binary_search_tree = BinarySearchTree() binary_search_tree.insert(key1, value1) binary_search_tree.insert(key2, value2) self.assert_node_has_one_right_child(binary_search_tree.root)
def test_add_one_number(self): key = "Apeldoorn" value = 1 variable = self.create_node(key, value) binary_search_tree = BinarySearchTree() binary_search_tree.insert(key, value) self.assert_root_has_correct_key_and_value(binary_search_tree.root, variable) self.assert_node_has_no_children(binary_search_tree.root)
def test_predecessor(): bs_tree = BinarySearchTree() keys = [6, 5, 7, 2, 5, 8] for key in keys: node = Node() node.key = key bs_tree.insert(node) assert(bs_tree.predecessor(bs_tree.root).key == 5) subtree = bs_tree.search(7) assert(bs_tree.predecessor(subtree).key == 6) subtree = bs_tree.search(2) assert(bs_tree.predecessor(subtree) is None)
def test_add_left_child(self): key1 = 2 key2 = 1 key3 = 0 value1 = 1 value2 = 2 binary_search_tree = BinarySearchTree() binary_search_tree.insert(key1, value2) binary_search_tree.insert(key2, value1) binary_search_tree.insert(key3, value1) self.assert_node_has_one_left_child(binary_search_tree.root) self.assert_node_has_one_left_child(binary_search_tree.root.left)
def test_find_min(self): key1 = 2 key2 = 1 key3 = 0 value1 = 1 value2 = 2 binary_search_tree = BinarySearchTree() binary_search_tree.insert(key1, value2) binary_search_tree.insert(key2, value1) binary_search_tree.insert(key3, value1) lowest_key = key3 result = binary_search_tree.find_min() self.assert_lowest_found(lowest_key, result)
def test_find(self): key1 = 2 key2 = 1 key3 = 0 value1 = 1 value2 = 2 binary_search_tree = BinarySearchTree() binary_search_tree.insert(key1, value2) binary_search_tree.insert(key2, value1) binary_search_tree.insert(key3, value1) result = binary_search_tree.find(key1) self.assert_found(key1, result)
def benchmarking(): eBookEntry.__hash__ = monkey_hash # eBookEntry.set_sort_type(eBookEntry.Sort.AUTHOR) eBookEntry.set_sort_type(eBookEntry.Sort.ID) my_books = eBookEntryReader("catalog-short4.txt") my_hash_table = HashQP() bst = BinarySearchTree() avl = AVLTree() random_ids = random.choices([book.ID for book in my_books], k=10000) qp_res = [] avl_res = [] bst_res = [] for book in my_books: my_hash_table.insert(book) bst.insert(book) avl.insert(book) qp_time1 = time.time() for i in random_ids: # print(my_hash_table.find(i)) book = my_hash_table.find(i) qp_res.append(book) qp_time2 = time.time() print('QP time: ', qp_time2 - qp_time1) avl_time1 = time.time() for i in random_ids: # print(avl.find(i)) book = avl.find(i) avl_res.append(book) avl_time2 = time.time() print('AVL time: ', avl_time2 - avl_time1) bst_time1 = time.time() for i in random_ids: # print(bst.find(i)) book = bst.find(i) bst_res.append(book) # check if all items are same bst_time2 = time.time() print('BST time: ', bst_time2 - bst_time1) # test to see if all the finds were the same print(bst_res == avl_res) print(bst_res == qp_res)
def test_create_niveau(self): content = [["Plaats", "School", "Niveau", "Leerling", "Score", "Label"], ["Apeldoorn", "HAN", "HBO", "563631", "15", "test1"], ["Arnhem", "HAN", "HBO", "563631", "15", "test1"]] niveau = Level() binary_search_tree = BinarySearchTree() binary_search_tree.insert(content[1][0], 0) binary_search_tree.insert(content[2][0], 1) expected_niveau = "Plaats" niveau.create_level(content, content[0][0]) self.assertEqual(expected_niveau, niveau.name) self.assertEqual(binary_search_tree.find('Apeldoorn').key, niveau.variables.find('Apeldoorn').key) self.assertEqual(binary_search_tree.find('Arnhem').key, niveau.variables.find('Arnhem').key)
def test_findMax(self): key1 = 2 key2 = 1 key3 = 0 value1 = 1 value2 = 2 binary_search_tree = BinarySearchTree() binary_search_tree.insert(key1, value2) binary_search_tree.insert(key2, value1) binary_search_tree.insert(key3, value1) highest_key = key1 result = binary_search_tree.find_max() self.assertHighestFound(highest_key, result)
def minimal_tree(tree, array): """ Time: O(n) Space: O(n) where n is the size of the array """ if len(array) < 1: return mid = len(array) / 2 if tree is None: tree = BinarySearchTree(array[mid]) else: tree.insert(array[mid]) minimal_tree(tree, array[:mid]) minimal_tree(tree, array[mid + 1:]) return tree
def insert(self, key): node = TreapNode() new_node = BinarySearchTree.insert(self, key, node) # tee: heap järjestyksen tarkistaminen ja muuttaminen while (new_node != self.root and new_node.priority < new_node.parent.priority): self.rotate(new_node)
def test_findParent_whenLookingAtLevel1_returnsRoot(self): bst = BinarySearchTree() bst.insert(10, bst.root) bst.insert(9, bst.root) bst.insert(15, bst.root) self.assertEqual(bst.findParent(9, bst.root).value, 10)
def test_findParent_whenLookingAtRoot_returnsNone(self): bst = BinarySearchTree() bst.insert(10, bst.root) bst.insert(9, bst.root) bst.insert(15, bst.root) self.assertIsNone(bst.findParent(10, bst.root))
class TestBinarySearchTree(unittest.TestCase): def setUp(self): self.my_bst = BinarySearchTree() self.tree_values = [25, 50, 12, 35, 5, 60, 17, 1] for value in self.tree_values: self.my_bst.insert(value) def test_exceptions(self): self.assertRaises(AttributeError, self.my_bst.insert, 50) self.assertRaises(AttributeError, self.my_bst.insert, 12) self.assertRaises(AttributeError, self.my_bst.insert, 35) self.assertRaises(AttributeError, self.my_bst.insert, 1) def test_tree_operations(self): self.assertEquals(self.my_bst.find(13), False) self.assertEquals(self.my_bst.find(27), False) for val in self.tree_values: self.assertTrue(self.my_bst.find(val)) self.assertIsNone(self.my_bst.delete(12))
def test_findParent_whenLookingAtLevel2_returnsRightParentFromLevel1(self): bst = BinarySearchTree() bst.insert(19, bst.root) bst.insert(15, bst.root) bst.insert(21, bst.root) bst.insert(11, bst.root) bst.insert(18, bst.root) self.assertEqual(bst.findParent(18, bst.root).value, 15)
def test_search_whenElemNotPresent_returnsFalse(self): bst = BinarySearchTree() bst.insert(10, bst.root) bst.insert(9, bst.root) bst.insert(15, bst.root) #bst.inorderPrint(bst.root) self.assertFalse(bst.search(99, bst.root))
def test_search_whenElemPresent_returnsTrue(self): bst = BinarySearchTree() bst.insert(10, bst.root) bst.insert(9, bst.root) bst.insert(15, bst.root) #bst.inorderPrint(bst.root) res = bst.search(15, bst.root) self.assertTrue(res)
class SymbolTable: def __init__(self): self.__binarySearchTree = BinarySearchTree() def insert(self, value): return self.__binarySearchTree.insert(value) def find(self, value): return self.__binarySearchTree.find(value) def __str__(self): s = 'Symbol Table:\n' for i in range(len(self.__binarySearchTree.nodes)): if self.__binarySearchTree.nodes[i] is not None: s += str(i + 1) + ' ' + self.__binarySearchTree.nodes[i] + '\n' return s
def test_insert_whenInsertingHigherValue_insertsAsRightChild(self): bst = BinarySearchTree() bst.insert(10, bst.root) bst.insert(9, bst.root) bst.insert(15, bst.root) bst.insert(17, bst.root) #bst.inorderPrint(bst.root) self.assertEqual(len(bst), 4) self.assertEqual(bst.root.value, 10) self.assertEqual(bst.root.left.value, 9) self.assertEqual(bst.root.right.value, 15) self.assertEqual(bst.root.right.right.value, 17)
from BinarySearchTree import BinarySearchTree newBST = BinarySearchTree() newBST.insert(12) newBST.insert(32) newBST.insert(42) newBST.insert(90) newBST.insert(1) newBST.insert(-2) print("=====") newBST.traverseInOrder() print("=====") newBST.remove(42) newBST.traverseInOrder() print("=====") print(newBST.getMax()) print("=====") print(newBST.getMin()) print("=====") newBST.remove(12)
from BinarySearchTree import BinarySearchTree; bst = BinarySearchTree(); bst.insert(10); bst.insert(-5); bst.insert(3); bst.insert(345); bst.insert(678); bst.traverseInOrder(); bst.remove(678); bst.traverseInOrder();
# recurse to right for max node node = findKthMaxRecursive(root.rightChild, k) if (counter is not k) and (root.val is not current_max): # Increment counter if kth element is not found counter += 1 current_max = root.val node = root elif current_max is None: # Increment counter if kth element is not found # and there is no current_max set counter += 1 current_max = root.val node = root # Base condition reached as kth largest is found if (counter == k): return node # return kth node else: # Traverse left child if kth element is not reached # traverse left tree for kth node return findKthMaxRecursive(root.leftChild, k) BST = BinarySearchTree(6) BST.insert(4) BST.insert(9) BST.insert(5) BST.insert(2) BST.insert(8) print(findKthMax(BST.root, 4))
def insert(self, key): new_node = BinarySearchTree.insert(self, key) self.splay(new_node) return new_node
from BinarySearchTree import BinarySearchTree from Node import Node binarySearchTree = BinarySearchTree() binarySearchTree.insert(binarySearchTree.getRoot(), Node(50)) binarySearchTree.insert(binarySearchTree.getRoot(), Node(30)) binarySearchTree.insert(binarySearchTree.getRoot(), Node(20)) binarySearchTree.insert(binarySearchTree.getRoot(), Node(40)) binarySearchTree.insert(binarySearchTree.getRoot(), Node(70)) binarySearchTree.insert(binarySearchTree.getRoot(), Node(60)) binarySearchTree.insert(binarySearchTree.getRoot(), Node(80)) # Tree Height print("Height : ", binarySearchTree.getTreeHeight(binarySearchTree.getRoot())) # Inorder Traversal print("Inorder Traversal") binarySearchTree.inorder(binarySearchTree.getRoot()) # Level Order Traversal print("Level Order Traversal") treeHeight = binarySearchTree.getTreeHeight(binarySearchTree.getRoot()) for i in range(1, treeHeight + 1): binarySearchTree.levelOrder(binarySearchTree.getRoot(), i) # Level Order Zig-Zag print("Level Order Traversal Zig-Zag") leftToRight = True for i in range(1, treeHeight + 1): binarySearchTree.levelOrderZigZag(binarySearchTree.getRoot(), i,
def check_balanced_recur(node, count, min_max): # pre order traversal if node is None: return if node.left is None and node.right is None: if count < min_max[0]: min_max[0] = count if count > min_max[1]: min_max[1] = count check_balanced_recur(node.left, count + 1, min_max) check_balanced_recur(node.right, count + 1, min_max) if __name__ == '__main__': bst1 = BinarySearchTree(27) bst1.insert(9) bst1.insert(3) bst1.insert(1) bst1.insert(53) root1 = bst1.get_root() print check_balanced(root1) # false bst2 = BinarySearchTree(27) bst2.insert(9) bst2.insert(3) bst2.insert(1) bst2.insert(53) bst2.insert(30) root2 = bst2.get_root() print check_balanced(root2) # True
def testTreeFind(self): bst = BinarySearchTree() self.assertFalse(bst.find(5)) bst.insert(5) self.assertTrue(bst.find(5))
from BinarySearchTree import BinarySearchTree tree = BinarySearchTree() tree.insert(32) tree.insert(55) tree.insert(79) tree.insert(10) tree.insert(1) tree.insert(0) tree.insert(19) tree.insert(16) tree.insert(23) #tree.inOrderTraversal(); tree.inOrderTraversalWithStack();
from BinarySearchTree import BinarySearchTree bst = BinarySearchTree() bst.insert(5) bst.insert(3) bst.insert(8) bst.insert(1) bst.insert(4) bst.insert(2) bst.insert(7) bst.insert(6) bst.insert(9) bst.insert(10) print "------preOrder----------" bst.preOrder(bst.root) print "------inOrder----------" bst.inOrder(bst.root) print "------postOrder----------" bst.postOrder(bst.root) print "----------------" print bst.depth
# -*- coding: utf-8 -*- """ App: """ from BinarySearchTree import BinarySearchTree as BST bst = BST() bst.insert(12) bst.insert(10) bst.insert(-2) bst.insert(1) bst.traverseInOrder() bst.remove(10) bst.traverseInOrder() print bst.getMin() print bst.getMax()
temp.extend(left) temp.extend(right) weaved.append(temp) return # both left and right are not empty # recurse with head of the first list added to the prefix. # remove the head will damage the first, so we'll need to put it back where we found it afterwards head = left.pop(0) prefix.append(head) weave_lists(left, right, weaved, prefix) prefix.pop() left.insert(0, head) # do same thing with second, damaging then restoring the list head = right.pop(0) prefix.append(head) weave_lists(left, right, weaved, prefix) prefix.pop() right.insert(0, head) if __name__ == '__main__': bst = BinarySearchTree(2) bst.insert(1) bst.insert(3) root = bst.get_root() print bst_sequences(root) # weaved = [] # weave_lists([1,2], [3,4], weaved, []) # print weaved
#!/usr/bin/env python from BinarySearchTree import BinarySearchTree my_tree = BinarySearchTree() n = [25, 50, 12, 5, 35] for i in n: my_tree.insert(i) c = my_tree._root c = c.next while c != None: print(c) c = c._left_child
def main(): #open the list of names file and read the student info then put it into a list inputfile = str(input("Please enter a list of names file ")) inputfilehandle = open(inputfile, 'r') inputfileread = inputfilehandle.readlines() # BST = BinarySearchTree() BST = BinarySearchTree() #loops through and adds Student record to BinarySearchTree #create a start time for the creater starttime = time.time() #find out how many records your inserting into insertrecordcounter = 0 for line in inputfileread: ssline = line.strip(" ").split('\t') #changes the variable to an int sname = int(ssline[0]) BST.insert(Student(sname)) insertrecordcounter += 1 inputfilehandle.close() endtime = time.time() print(BST) #create a start time for the creater # asks for a second file, and reads it inputfile2 = str(input("Please enter a list of names file ")) sfilehandle = open(inputfile2, 'r') Idsearch = sfilehandle.readlines() #create a start time for the creater starttime2 = time.time() findrecordcounter = 0 # search for an ID match in the search file and BinarySearchTree for ID in range(len(Idsearch)): findrecordcounter += 1 num = Idsearch[ID] # change it to an integar IDcomparison = int(num) studentID = Student(IDcomparison) #finds the cross-over IDchecker = BST.find(studentID) #checks to see if the ID was found or not and prints it if IDchecker is not None: print("Found student record " + str(IDchecker)) else: print("Student ID " + str(IDcomparison) + " not found") #create a start time for the creater sfilehandle.close() endtime2 = time.time() print("Time to insert " + str(insertrecordcounter) + " records into an AVL Tree: " + format(endtime - starttime, "6.4f") + " seconds") print("Time to find " + str(findrecordcounter) + " records into an AVL Tree: " + format(endtime2 - starttime2, "6.4f") + " seconds")
def testTreeInit(self): bst = BinarySearchTree() self.assertTrue(bst.insert(5))