def test_put(self): tree = BinarySearchTree() keys = random.sample(range(1000000), 10000) for key in keys: tree.put(key, "value{}".format(key)) for key in keys: self.assertTrue(tree.get(key) == "value{}".format(key))
def delete(self, remove): parent = None if remove.parent != None: parent = remove.parent self.splay(remove) BinarySearchTree.delete(self, remove) if parent: self.splay(parent)
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 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 setUp(self): self.bst = BinarySearchTree() self.bst.put('H', 5) self.bst.put('B', 4) self.bst.put('K', 9) self.bst.put('C', 2) self.bst.put('I', -1) self.bst.put('M', 11)
def test_get(self): tree = BinarySearchTree() self.assertIsNone(tree.get(1), "empty tree") keys = random.sample(range(1000), 100) for key in keys: tree.put("key{}".format(key), "value{}".format(key)) for _ in range(100): index = random.randint(0, len(keys) - 1) self.assertEqual("value{}".format(keys[index]), tree.get("key{}".format(keys[index]))) for i in range(1001, 1100): self.assertIsNone(tree.get("key{}".format(i))) # tree is list tree = BinarySearchTree() for i in range(1000): tree.put(i, i * 100) for i in range(1000): self.assertEqual(i * 100, tree.get(i))
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_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 print_binary_tree(input_structure): clear_screen() # asks which trait to sort tree by print("What would you like the tree to be sorted by?\n") print("1.ID\n" "2.Name\n" "3.Age\n" "4.Personality Rating\n") choice = input('Choice: ') # checks to make sure the user entered a valid option while not choice in ['1','2','3','4']: print("You didn't enter a valid choice. Please try again.") choice = input('Choice: ') # creates BinarySearchTree and adds the chairs to the tree my_tree = BinarySearchTree() for chair in input_structure.chair_list(): my_tree.put(chair.person.data(['id','name','age','personality'][int(choice) - 1]), chair) my_tree.print()
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_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_deleteLeafNode(): BST = BinarySearchTree() BST.put(10, "ten") BST.put(15, "fifteen") BST.put(5, "five") BST.put(3, "three") BST.put(7, "seven") BST.put(12, "twelve") BST.put(17, "seventeen") BST.delete(3) assert BST.inOrder(BST.root) == \ "5 7 10 12 15 17" BST.delete(17) assert BST.inOrder(BST.root) == \ "5 7 10 12 15"
str1 = "".join(str(e) for e in order1) str2 = "".join(str(e) for e in order2) return str2 in str1 def preorder(node, order): if node is None: order.append("X") return order.append(node.value) preorder(node.left, order) preorder(node.right, order) if __name__ == '__main__': bst1 = BinarySearchTree(50) bst1.insert(20) bst1.insert(60) bst1.insert(10) bst1.insert(25) bst1.insert(70) bst1.insert(5) bst1.insert(15) bst1.insert(65) bst1.insert(80) root1 = bst1.get_root() bst2 = BinarySearchTree(60) bst2.insert(70) bst2.insert(65) bst2.insert(80)
# filename : TreeProblem.py from BinarySearchTree import BinarySearchTree from BinaryTree import BinaryTree from util import Queue import random # ---------------------- problem : 1 ------------------------------------------ """ * Given Sorted Array with unique integers make a Binary Serach Tree out of it with minimal Height. """ binaryTree = BinarySearchTree() def minimal_height_binary_serach_tree_from_sorted_array( arr, binaryTree, start, end): # recursive approch. if start > end: return None else: mid = int((start + end) / 2) print(f"mid : {mid} start : {start} end : {end}") binaryTree.insertKey(arr[mid]) minimal_height_binary_serach_tree_from_sorted_array( arr, binaryTree, start, mid - 1) minimal_height_binary_serach_tree_from_sorted_array( arr, binaryTree, mid + 1, end) #--------------------------------------------------------------------------------------------------------------------
def max(self, x): max_node = BinarySearchTree.max(self, x) self.splay(max_node) return max_node
def insert(self, key): new_node = BinarySearchTree.insert(self, key) self.splay(new_node) return new_node
def testTreeInit(self): bst = BinarySearchTree() self.assertTrue(bst.insert(5))
def isSubtree(t1, t2): queue = [] queue.append(t1) while len(queue): node = queue.pop(0) if node.data == t2.data: if isIdenticalTrees(node, t2): return True if node.left: queue.append(node.left) if node.right: queue.append(node.right) return False t1 = BinarySearchTree() t1.insertRecursive(4) t1.insertRecursive(2) t1.insertRecursive(3) t1.insertRecursive(1) t1.insertRecursive(6) t1.insertRecursive(5) t1.insertRecursive(7) t1.insertRecursive(8) bst = BinarySearchTree() bst.insertRecursive(6) bst.insertRecursive(5) bst.insertRecursive(7) bst.insertRecursive(8)
def test_find_non_empty_tree(self): BST = BinarySearchTree(51) self.assertNotEqual(BST.find(51), None)
def test_find_empty_tree(self): BST = BinarySearchTree() self.assertEqual(BST.find(11), None)
def test_insert_from_nonempty_tree(self): BST = BinarySearchTree(88) self.assertEqual(BST.size(), 1)
def test_nonempty_tree(self): BST = BinarySearchTree(28) self.assertEqual(BST.size(), 1)
def test_nonempty_tree(self): BST = BinarySearchTree(5) self.assertEqual(BST.isEmpty(), False)
from BinarySearchTree import BinarySearchTree tree = BinarySearchTree() assert tree.is_empty() is True tree.add(1) assert tree.is_empty() is False assert tree.size() == 1 tree.remove(1) assert tree.height() == 0 tree.add('M') assert tree.height() == 1 tree.add('J') assert tree.height() == 2 tree.add('S') assert tree.height() == 2 tree.add('B') assert tree.height() == 3 tree.add('N') assert tree.height() == 3 tree.add('Z') assert tree.height() == 3 tree.add('A') assert tree.height() == 4 tree.remove('M') tree.remove('J') tree.remove('S') tree.remove('B') tree.remove('N')
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();
class BinarySearchTreeTest(TestCase): def setUp(self): self.bst = BinarySearchTree() self.bst.put('H', 5) self.bst.put('B', 4) self.bst.put('K', 9) self.bst.put('C', 2) self.bst.put('I', -1) self.bst.put('M', 11) def test_get(self): self.assertEqual(self.bst.get('C'), 2) self.assertEqual(self.bst.get('M'), 11) self.assertEqual(self.bst.get('Z'), None) def test_size(self): self.assertEqual(self.bst.size(), 6) def test_min(self): self.assertEqual(self.bst.min(), 'B') def test_max(self): self.assertEqual(self.bst.max(), 'M') def test_floor(self): self.assertEqual(self.bst.floor('D'), 'C') self.assertEqual(self.bst.floor('M'), 'M') self.assertEqual(self.bst.floor('A'), None) def test_select(self): self.assertEqual(self.bst.select(0), 'B') self.assertEqual(self.bst.select(1), 'C') self.assertEqual(self.bst.select(5), 'M') self.assertEqual(self.bst.select(6), None) def test_rank(self): self.assertEqual(self.bst.rank('B'), 0) self.assertEqual(self.bst.rank('C'), 1) self.assertEqual(self.bst.rank('D'), 2) self.assertEqual(self.bst.rank('H'), 2) self.assertEqual(self.bst.rank('M'), 5) self.assertEqual(self.bst.rank('Z'), 6) def test_delete_min(self): self.bst.delete_min() self.assertEqual(self.bst.size(), 5) self.assertEqual(self.bst.min(), 'C') def test_delete(self): self.bst.delete('H') self.assertEqual(self.bst.size(), 5) self.assertEqual(self.bst.get('H'), None) def test_keys(self): keys = self.bst.keys('C', 'J') self.assertEqual(keys, ['C', 'H', 'I'])
def test_toList_empty_tree(self): BST = BinarySearchTree() self.assertEqual(BST.toList(), [])
#!/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 test_empty_tree(self): BST = BinarySearchTree() self.assertEqual(BST.isEmpty(), True)
def testTreeFind(self): bst = BinarySearchTree() self.assertFalse(bst.find(5)) bst.insert(5) self.assertTrue(bst.find(5))
def test_toList_non_empty_tree(self): BST = BinarySearchTree(72) self.assertEqual(BST.toList(), [72])
def min(self, x): min_node = BinarySearchTree.min(self, x) self.splay(min_node) return min_node
def test_toList_tree_with_children(self): BST = BinarySearchTree(72) BST.insert(10) BST.insert(99) self.assertEqual(BST.toList(), [10, 72, 99])
def succ(self, x): succ_node = BinarySearchTree.succ(self, x) self.splay(succ_node) return succ_node
k_list = [] stack = [] while r or stack: if r: stack.append(r) r = r.right else: r=stack.pop() k_list.append(r) if len(k_list) == k: break r = r.left return k_list if __name__=='__main__': t=BinarySearchTree() ''' The tree is : 20 / \ 10 40 / \ / \ 3 17 35 73 / \ / \ \ 1 7 15 18 89 \ / / 2 5 11 / \ \ 4 6 12 ''' a=[20,10,40,3,17,35,73,1,7,15,18,89,2,5,11,4,6,12]
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))
# -*- 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()
def test_deleteNodeWithTwoChildren(): BST = BinarySearchTree() BST.put(10, "ten") BST.put(15, "fifteen") BST.put(5, "five") BST.put(3, "three") BST.put(7, "seven") BST.put(12, "twelve") BST.put(17, "seventeen") BST.delete(15) assert BST.inOrder(BST.root) == \ "3 5 7 10 12 17" BST.delete(5) assert BST.inOrder(BST.root) == \ "3 7 10 12 17"
def test_delete(self): tree = BinarySearchTree() self.assertIsNone(tree.delete(1), "empty tree") keys = random.sample(range(1000), 100) for key in keys: tree.put("key{}".format(key), "value{}".format(key)) for key in keys: v = tree.delete("key{}".format(key)) self.assertEqual("value{}".format(key), v) tree = BinarySearchTree() for i in range(512): tree.put(i, i * 100) for i in range(512): self.assertEqual(i * 100, tree.delete(i)) tree = BinarySearchTree() for i in range(128): tree.put(i, i * 100) for i in reversed(range(128)): self.assertEqual(i * 100, tree.delete(i)) for j in range(i): self.assertEqual(j * 100, tree.get(j)) self.assertIsNone(tree.delete(0))
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 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)
from BinarySearchTree import BinarySearchTree mytree = BinarySearchTree() mytree[3] = "red" mytree[4] = "blue" mytree[6] = "yellow" mytree[2] = "at" print(mytree[6]) print(mytree[2])
from TreeNode import TreeNode from BinarySearchTree import BinarySearchTree bst = BinarySearchTree() bst.put(10, 'A') bst.put(1, 'B') bst.put(11, 'C') bst[20] = 'D' print(bst.get(10)) print(bst[11]) print(bst.get(-1)) print(10 in bst)
def test_Size(self): tree = BinarySearchTree() self.assertEqual(tree.size(), 0) tree.add("Hello World!") self.assertEqual(tree.size(), 1)
def tree(): tree = BinarySearchTree() tree.insert(5) tree.insert(10) tree.insert(1) return tree
def _removeLeaf(self, path): """Last node of path is a leaf that should be removed.""" problem = len(path) >= 2 and path[-2].isBlack() _BinarySearchTree._contractAbove(self,path) # path is updated automatically while problem: problem = False # typically, we fix it. We'll reset to True when necessary if path[-1].isRed(): path[-1].setBlack() # problem solved elif len(path) >= 2: # bottom node is a "double-black" that must be remedied if _DEBUG>1: print "double-black node must be resolved:",path[-1] parent = path[-2] sibling = parent.getOtherChild(path[-1]) if len(path) >= 3: grandparent = path[-3] else: grandparent = None if sibling.isRed(): # our parent is a 3-node that we prefer to realign if _DEBUG>1: print "realigning red sibling" sibling.setBlack(True) parent.setBlack(False) self._rotate(sibling,parent,grandparent) path.insert(-2,sibling) # reflects the rotation of sibling above parent grandparent = sibling sibling = parent.getOtherChild(path[-1]) # will surely be black this time # now sibling is black nephewA,nephewB = _identifyNephews(sibling,parent) # closer,farther if _DEBUG>1: print "nephews:",nephewA,"-",nephewB if nephewA.isBlack() and nephewB.isBlack(): # we and sibling are 2-nodes. Recolor sibling to enact merge if _DEBUG>1: print "sibling also 2-node; recoloring" sibling.setBlack(False) if parent.isRed(): parent.setBlack() else: if _DEBUG>1: print "will continue with",path[-1] path.pop() problem = True # must continue from parent level else: # should be able to maneuver to borrow from sibling if not nephewA.isRed(): # rotate other nephew and sibling if _DEBUG>1: print "realigning nephews" self._rotate(nephewB,sibling,parent) nephewB.setBlack(True) sibling.setBlack(False) sibling = nephewB nephewA,nephewB = _identifyNephews(sibling,parent) if _DEBUG>1: print "nephews:",nephewA,"-",nephewB # at this point, nephewA is guaranteed to be red. Let's borrow from it self._rotate(nephewA,sibling,parent) self._rotate(nephewA,parent,grandparent) nephewA.setBlack(parent.isBlack()) # they've been promoted parent.setBlack() # cross your fingers; should be done! if _DEBUG>0 and self._validate() == -1: print 'Error after deletion.'
#!/usr/bin/python from BinarySearchTree import BinarySearchTree bst = BinarySearchTree() bst.put(10,'a') bst.put(9,'b') bst.put(2,'c') bst.put(12,'d') bst.put(14,'e') bst.put(11,'e') bst.put(16,'e') bst[20] = 'f' print bst.length() print bst.get(12) print bst.get(20) bst.delete(12) bst.delete(2) print for i in bst: print i
def setUp(self): self.binarySearchTree = BinarySearchTree()
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
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();