def test_basic(self): bin = BST() bin.insert(5) self.assertEqual(bin.root.val, 5) bin.insert(6) self.assertEqual(bin.root.right.val, 6)
def full_tree(): test_tree = BST() test_tree.insert(5) test_tree.insert(8) test_tree.insert(3) test_tree.insert(4) return test_tree
def main(argv): #create a new tree tree = BST() #open file argument file = open(argv[1], "r") # goes for amount of of lines in f for line in file: text = line.split() #test cases for what the first element in the list is if text[0] == "insert": #saves the second element, since it exists data = text[1] tree.insert(data) elif text[0] == "delete": #saves element, then calls delete data = text[1] tree.delete(data) elif text[0] == "preorder" or text[0] == "postorder" or text[0] == "inorder": #tests for if a traverse then calls the function tree.traverse(text[0], tree.getRoot()) else: print("incorrect format") return 0
def test_preorder(): for i in range(20): bst = BST() randomlist = random.sample(range(1, 100), 35) for x in randomlist: bst.insert(x) assert bst.preorder(bst.root) == bst.preorder_iterative()
def main(): #create BST: print('create BST with elements: 10, 5, 2, 6, 1, 4, 20, 15, 25') bst = BST(10) insert_in_BST = [5, 2, 6, 1, 4, 20, 15, 25] for item in insert_in_BST: bst.insert(item) # test find() -> find root with key = 2 and print key: print('find root with key=2 and print key:') print(bst.find(2).key) # find min/max: print('find node with min key and print key (should be 1):') print(bst.findMin().key) print('find node with max key and print key (should be 25):') print(bst.findMax().key) # traverse tree / delete nodes: print('traverse tree in order and print all keys:') bst.traverseInOrder() print('delete node with key=5 and traverse tree again:') bst.delete(5) bst.traverseInOrder() # get root and print it's key: print('get root key (should be 10)') print(bst.getRoot().key)
def main(argv): myBST = BST() # Loop over input file (filename passed via argv). input_file = argv[1] with open(input_file, 'r') as file_ob: # Split each line into a task and number (if one exists) #hint: use the split method for strings # Perform the function corresponding to the specified task # i.e., insert, delete, inorder, preorder, postorder # Close the file when you're done. for line in file_ob: if ' ' in line: command, num = line.split() if command == "insert": myBST.insert(num) if command == "delete": myBST.deleteBook(num) #print command #print num else: line = line.split() myBST.traverse(line[0], myBST.getRoot()) print '' if 'str' in line: break pass
def main(argv): input_file = argv[1] # Instance of the binary search tree tree = BST() with open(input_file, 'r') as file_ob: for line in file_ob: line = line.split() if line[0] == 'insert': tree.insert(int(line[1])) if line[0] == 'delete': tree.delete(int(line[1])) if line[0] == 'preorder': tree.traverse('preorder', tree.getRoot()) print("") if line[0] == 'inorder': tree.traverse('inorder', tree.getRoot()) print("") if line[0] == 'postorder': tree.traverse('postorder', tree.getRoot()) print("") # Close the file file_ob.close()
def testInsertThreeNodes(self): node_1 = Node(5, None, None) bst = BST(node_1) bst.insert(node_1, 4) bst.insert(node_1, 2) bst.insert(node_1, 1) self.assertEquals(node_1.left.left.left.data, 1)
class TestBST(TestCase): def setUp(self): self.list1 = [3, 2, 1, 5, 6, 7] # Creating the BST1 self.BST1 = BST(dtype=int, key=4) for val in self.list1: self.BST1 = self.BST1.insert(val) def test_insert(self): self.assertEqual(self.BST1.key, 4) self.assertEqual(self.BST1.left.key, 3) self.assertEqual(self.BST1.right.key, 5) self.BST1 = self.BST1.insert(9) self.assertEqual(self.BST1.right.right.right.right.key, 9) def test_preOrderTraversal(self): preOrderValues = [4, 3, 2, 1, 5, 6, 7] self.assertEqual(self.BST1.PreOT(), ', '.join(str(i) for i in preOrderValues)) def test_inOrderTraversal(self): inOrderValues = [1, 2, 3, 4, 5, 6, 7] self.assertEqual(self.BST1.IOT(), ', '.join([str(i) for i in inOrderValues])) def test_postOrderTraversal(self): postOrderValues = [1, 2, 3, 7, 6, 5, 4] self.assertEqual(self.BST1.PostOT(), ', '.join([str(i) for i in postOrderValues])) def tearDown(self): del self.list1
class TranversalBST(object): def __init__(self): self.bst = BST(None) self.nodes = [] def insert(self, value): if not self.bst.value: self.bst.value = value else: self.bst.insert(value) def contains(self, value): return bool(self.bst.find(value)) def get(self, index): for i, value in enumerate(self.inorder()): if i == index: return value def inorder(self): current = self.bst self.nodes = [] stack = [] while len(stack) > 0 or current is not None: if current is not None: stack.append(current) current = current.left else: current = stack.pop() self.nodes.append(current.value) current = current.right return self.nodes def preorder(self): self.nodes = [] stack = [self.bst] while len(stack) > 0: curr = stack.pop() if curr is not None: self.nodes.append(curr.value) stack.append(curr.right) stack.append(curr.left) return self.nodes def preorder2(self): self.nodes = [] current = self.bst stack = [] while len(stack) > 0 or current is not None: if current is not None: self.nodes.append(current.value) stack.append(current) current = current.left else: current = stack.pop() current = current.right return self.nodes
def test_search(self): bin = BST() for i in range(50): bin.insert(i) self.assertEqual(bin.find(8).val, 8) self.assertEqual(bin.find(49).val, 49) self.assertEqual(bin.find(60), None)
def testInsertFourNodes(self): node_1 = Node(5, None, None) bst = BST(node_1) bst.insert(node_1, 4) bst.insert(node_1, 2) bst.insert(node_1, 1) bst.insert(node_1, 6) self.assertEquals(node_1.right.data, 6)
def demo(): B = Node(50) tree = BST() tree.insert(tree.root, Node(50)) tree.insert(tree.root, Node(48)) tree.insert(tree.root, Node(52)) tree.print_BST(tree.root)
def test_inorder_traversal(self): bst = BST() listi = [x for x in range(50)] random.shuffle(listi) for j in listi: bst.insert(j) inorderTreeWalk(bst.root) self.assertEqual(len(listi), bst.size)
def BSTFromArray(arr): """ Creates a BST from the keys in a given array. type arr: List[] rtype: BST """ tree = BST() for k in arr: tree.insert(Node(k)) return tree
def test_Search_Iter(self): bst = BST() listi = [x for x in range(50)] random.shuffle(listi) for j in listi: bst.insert(j) node = treeSearch(bst.root, 32) self.assertIsNotNone(node) self.assertEqual(32, node.value)
def heightrandom(): for i in range(2, 10, 2): L = [100 * random() for x in range((2**i) - 1)] BSTTree = BST() TreapTree = Treap() for x in L: BSTTree.insert(x) TreapTree.insert(x) print("Complete Tree would have height of", i - 1) print("Height of BST is: ", BSTTree.height()) print("Height of Treap is: ", TreapTree.height())
def test_Search(self): bst = BST() listi = [x for x in range(50)] random.shuffle(listi) for j in listi: bst.insert(j) searchValue = 40 inorderTreeWalk(bst.root) node = treeSearch(bst.root, searchValue) self.assertIsNotNone(node) self.assertEqual(searchValue, node.value)
def test_MinMax_Recursive(self): bst = BST() listi = [x for x in range(50)] random.shuffle(listi) for j in listi: bst.insert(j) node = treeMinRecursive(bst.root) node2 = treeMaxRecursive(bst.root) self.assertIsNotNone(node) self.assertEqual(0, node.value) self.assertIsNotNone(node2) self.assertEqual(49, node2.value)
def test_delete_w_one_child(self): bin = BST() bin.insert(5) bin.insert(2) bin.insert(18) bin.insert(-4) bin.insert(3) bin.insert(21) bin.insert(19) bin.insert(25) bin.delete(bin.root.right) self.assertEqual([x.val for x in bin.get_level(1)], [2, 21])
class SymbolTable: def __init__(self): self.bst = BST() self.pos = 0 def add(self, identifier): param = [self.pos, str(identifier)] self.bst.insert(param) self.pos = self.pos + 1 def search(self, identifier): return self.bst.search(str(identifier)) def print(self): self.bst.print()
def handle_BST(self): print "How many nodes would you like to include in the binary search tree?" num_nodes = raw_input(">") print "Please enter the root node" root_node_data = raw_input(">") root_node = Node(data=root_node_data, left=None, right=None, is_root=True) bst = BST(root_node) for i in range(int(num_nodes) - 1): print "Please enter node val" val = raw_input(">") bst.insert(bst.root, val) print "Your final binary search tree is, in the form [Current, Left Node, Right Node]\n", bst.printAllNodes( )
def test_delete_w_two_children(self): bin = BST() bin.insert(5) bin.insert(2) bin.insert(12) bin.insert(-4) bin.insert(3) bin.insert(9) bin.insert(21) bin.insert(19) bin.insert(25) bin.delete(bin.root.right) self.assertEqual([x.val for x in bin.get_level(1)], [2, 19]) self.assertEqual([x.val for x in bin.get_level(3)], [25])
class SymbolTable: def __init__(self): self.tree = BST() def add(self, symbol): return self.tree.insert(symbol) def print(self): return self.tree.print()
def main(argv): tree = BST( ) # Creating the instance of a binary search tree, and going to be # referring to it as tree. input_file = argv[ 1] # This will be the input file with the tree instructions # passed in as an argument when the program is compiled. with open(input_file, 'r') as file_object: # Looping over the input file (file is passed in as argv[1]) for line in file_object: # splitting each line into a task and a number, so this would mean that # the task will be refered to as line[0] and then the actual number # is going to be referred to as line[1] after the split. line = line.rstrip('\n') line = line.split() if line[0] == "insert": # calling the insert function. tree.insert((line[1])) if line[0] == "inorder": # for the tree traversals, these will only call the traverse function # which will then decide which traversal to execute. tree.traverse(line[0], tree.getRoot()) print "\n", if line[0] == "preorder": tree.traverse(line[0], tree.getRoot()) print "\n", if line[0] == "postorder": tree.traverse(line[0], tree.getRoot()) print "\n", if line[0] == "delete": tree.delete(line[1]) file_object.close() # closing the input file after we finish reading it.
def testFoundSearch(self): node_5 = Node(5, None, None) bst = BST(node_5) bst.insert(node_5, 4) bst.insert(node_5, 2) bst.insert(node_5, 1) bst.insert(node_5, 3) bst.insert(node_5, 6) bst.insert(node_5, 7) bst.insert(node_5, 8) bst.insert(node_5, 0) bst.printAllNodes() self.assertTrue(bst.search(node_5, 7))
def testRemoveNodeHasTwoChildrenRightSubtree(self): node_5 = Node(5, None, None) bst = BST(node_5) bst.insert(node_5, 4) bst.insert(node_5, 2) bst.insert(node_5, 1) bst.insert(node_5, 3) bst.insert(node_5, 6) bst.insert(node_5, 7) bst.insert(node_5, 8) bst.insert(node_5, 0) bst.removeNode(None, node_5, 7) self.assertFalse(bst.search(node_5, 7))
def testNotFoundSearch(self): node_5 = Node(5, None, None) bst = BST(node_5) bst.insert(node_5, 4) bst.insert(node_5, 2) bst.insert(node_5, 1) bst.insert(node_5, 3) bst.insert(node_5, 6) bst.insert(node_5, 7) bst.insert(node_5, 8) bst.insert(node_5, 0) bst = BST(node_5) self.assertFalse(bst.search(node_5, 9))
class SymbolTable: def __init__(self): self.bst = BST() self.pos = 0 def add(self, identifier): param = [self.pos, str(identifier)] self.bst.insert(param) self.pos = self.pos + 1 def search(self, identifier): return self.bst.search(str(identifier)) def get_identifier_id(self, id): id = self.search(id) if id is None: return -1 return id[0] def print(self): self.bst.print()
def main(argv): # Loop over input file (filename passed via argv). # Split each line into a task and number (if one exists) # hint: use the split method for strings https://docs.python.org/2/library/string.html#string.split # Perform the function corresponding to the specified task # i.e., insert, delete, inorder, preorder, postorder # Close the file when you're done. filename = argv[1] file = open(filename, "r") bst = BST() for line in file: line = line.strip('\n') task = line.split(" ") # If task is insert if (task[0] == "insert"): val = int(task[1]) bst.insert(val) # If task is delete elif (task[0] == "delete"): val = int(task[1]) bst.delete(val) # If task is inorder elif (task[0] == "inorder"): bst.traverse(task[0], bst.getRoot()) # If task is preorder elif (task[0] == "preorder"): bst.traverse(task[0], bst.getRoot()) # If task is postorder elif (task[0] == "postorder"): bst.traverse(task[0], bst.getRoot()) # Close file file.close()
class Window(object): def silentremove(self, filename): try: os.remove(filename) except OSError as e: # this would be "except OSError, e:" before Python 2.6 if e.errno != errno.ENOENT: # errno.ENOENT = no such file or directory raise def __init__(self, master): self.silentremove("tree.png") self.silentremove("tree") self.tree = BST() self.display = None self.img = tkinter.Label(master) self.btn_add = tkinter.Button(master, text="add") self.btn_del = tkinter.Button(master, text="del") self.entry_node = tkinter.Entry(master) self.btn_add.bind("<Button-1>", self.add_element) self.btn_del.bind("<Button-1>", self.del_element) self.btn_add.pack(side="bottom") self.btn_del.pack(side="bottom") self.entry_node.pack(side="bottom") self.img.pack(fill="both") def del_element(self, event): self.tree.delete(int(self.entry_node.get())) self.tree.draw().render("tree") self.display = ImageTk.PhotoImage(image=Image.open("tree.png")) self.img.pack_forget() self.img = tkinter.Label(image=self.display) self.img.pack() def add_element(self, event): self.tree.insert(int(self.entry_node.get())) self.tree.draw().render("tree") self.display = ImageTk.PhotoImage(image=Image.open("tree.png")) self.img.pack_forget() self.img = tkinter.Label(image=self.display) self.img.pack()
def main(argv): # Loop over input file (filename passed via argv). # Split each line into a task and number (if one exists) # hint: use the split method for strings https://docs.python.org/2/library/string.html#string.split # Perform the function corresponding to the specified task # i.e., insert, delete, inorder, preorder, postorder # Close the file when you're done. file = argv[1] tasklist = [] tree = BST() with open(file, 'r') as file_ob: for line in file_ob: tasks = line.strip() #strips whitespace calls = tasks.split( " ") #separates commands (some require 2 arguments) tasklist.append(calls) for task in tasklist: #these types of commands are the traversals inorder, preorder, postorder if task[0] == "inorder": tree.traverse("inorder", tree.getRoot()) print("") # just to make my output a little more readable elif task[0] == "preorder": tree.traverse("preorder", tree.getRoot()) print("") # just to make my output a little more readable elif task[0] == "postorder": tree.traverse("postorder", tree.getRoot()) print("") # just to make my output a little more readable elif len(task) == 2: command = task[0] #here are the insert/delete commands value = int(task[1]) if command == "insert": tree.insert(value) elif command == "delete": tree.delete(value) else: print("this is not an appropriate BST method")
def insert_without_splay(self, z): BST.insert(self, z)
def insert(self, z): BST.insert(self, z) self.splay(z)
from BST import BST bst = BST(7, 'ok') bst.insert(3, 'dooke') bst.insert(10, 'poke') bst.insert(5, 'poop') bst.insert(1, 'dope') bst.insert(8, 'lol') bst.insert(9, 'haagu') bst.insert(12,'paadu') bst.printinorder() print '\n' '''try: print bst.getvalue(12) print bst.getvalue(9) print bst.getvalue(8) print bst.getvalue(1) print bst.getvalue(5) print bst.getvalue(10) print bst.getvalue(3) print bst.getvalue(7) print bst.getvalue(14) except RuntimeError as e: print e''' key = 19 if key in bst: print "I am in bst" else: print 'No i am not'
class TranversalBST(object): def __init__(self): self.bst = BST(None) self.nodes = [] def insert(self, value): if not self.bst.value: self.bst.value = value else: self.bst.insert(value) def contains(self, value): return bool(self.bst.find(value)) def get(self, index): for i, value in enumerate(self.inorder()): if i == index: return value def inorder(self): current = self.bst self.nodes = [] stack = [] while len(stack) > 0 or current is not None: if current is not None: stack.append(current) current = current.left else: current = stack.pop() self.nodes.append(current.value) current = current.right return self.nodes def preorder(self): self.nodes = [] stack = [self.bst] while len(stack) > 0: curr = stack.pop() if curr is not None: self.nodes.append(curr.value) stack.append(curr.right) stack.append(curr.left) return self.nodes def preorder2(self): self.nodes = [] current = self.bst stack = [] while len(stack) > 0 or current is not None: if current is not None: self.nodes.append(current.value) stack.append(current) current = current.left else: current = stack.pop() current = current.right return self.nodes def preorder3(self): self.nodes = [] node = self.bst if not node: return None stack = [] stack.append(node) while stack: node = stack.pop() self.nodes.append(node.value) if node.right: stack.append(node.right) # RIGHT FIRST! if node.left: stack.append(node.left) return self.nodes def BFT(self): self.nodes = [] node = self.bst if not node: return None queue = deque() queue.append(node) while queue: node = queue.popleft() self.nodes.append(node.value) if node.left: queue.append(node.left) # LEFT FIRST! if node.right: queue.append(node.right) return self.nodes
__author__ = 'Hazem Safwat' from BST import BST import random from tabulate import tabulate table = [[]] for i in range(51): #creating 50 different trees size = random.randint(50,100) items = random.sample(range(1,12000) , size) #random items in tree has a size = size tree = BST(items[0]) #Root of the tree for j in range(1,size): #inserting items in the tree tree.insert(items[j]) counter = BST.stepCounter(tree) table.append([i , size , counter , 2*counter]) print(tabulate(table[1:51] , headers= ["no." , "number of items" ,"number of calls" ,"number of steps" ]))
class Test: __a=0 def __init__(self): self.b=0 self.__a=self.__a+1 #Test.__a=Test.__a+1 def get_a(self): return self.__a test1=Test() test2=Test() print 'test1' print 'a:%d'%(test1.get_a()) test1.a=10 print 'test2' print 'a:%d'%(test1.a) from BST import BST import random bst=BST() bst.insert(int(random.random()*100)) bst.insert(int(random.random()*100)) bst.insert(int(random.random()*100)) bst.insert(int(random.random()*100)) bst.insert(int(random.random()*100)) bst.insert(int(random.random()*100)) bst.insert(int(random.random()*100)) bst.insert(int(random.random()*100)) bst.mid_travel()
#!/usr/env/bin python3 # File that uses BST from BST import BST bst = BST(25) bst.insert(12) bst.insert(50) bst.insert(6) bst.insert(45) bst.insert(1) print("Does tree contain 1 {0}".format(bst.contains(1))) print("Does tree contain 5 {0}".format(bst.contains(5))) print("Does tree contain 12 {0}".format(bst.contains(12))) print("Does tree contain 51 {0}".format(bst.contains(51)))