def create_tree_from_nested_list(nested_list): if nested_list == None: return None head = BinaryTree(nested_list[0]) head.set_left(create_tree_from_nested_list(nested_list[1])) head.set_right(create_tree_from_nested_list(nested_list[2])) return head
def __init__(self,filename): self.file = open(filename,'w+') self.blocksBySize = BinaryTree() self.blocksByPosition = BinaryTree() self.blocksByIndex = dict() self.loadDeletedBlocks() self.maxIndex = -1
def really_create_tree_from_flat_list(flat_list, pos): if pos >= len(flat_list): return None if flat_list[pos] == None: return None head = BinaryTree(flat_list[pos]) head.set_left(really_create_tree_from_flat_list(flat_list, pos * 2)) head.set_right(really_create_tree_from_flat_list(flat_list, pos * 2 + 1)) return head
def make_bst(lst, start, end): if end - start < 0: return None # Base case: one element if end - start == 0: return BinaryTree(lst[start]) mid = start + end // 2 # Center, leaning left temp = BinaryTree(lst[mid]) temp.left = make_bst(lst, start, mid-1) temp.right = make_bst(lst, mid+1, end) return temp
def test_question_five(): print('\n====================\n Testing Question 5\n====================') flat_list = [None, 10, 5, 15, None, None, 11, 22] #my_tree = create_tree_from_flat_list(flat_list) my_tree = [None, 10, 5, 15, None, None, 11, 22] a = BinaryTree(10) a.set_left(BinaryTree(5)) a.set_right(BinaryTree(6)) print(Asst2.sum_tree(a))
def insert(self, o): successful = BinaryTree.insert(self, o) if not successful: return False # o is already in the tree else: self.balancePath(o) # Balance from o to the root if necessary return True # o is inserted
class InvertedFile: """A indexing file that stores all the words from a file as well as the indices of all the places in the file that each word appears. """ def __init__(self): self.data = dict() # dict contains: { word: [indices in doc where word is found]} self.order = BinaryTree() # sorted binary tree maintains the order of items def __contains__(self, item): return item in self.data def next(self): for item in self.order.in_order(): yield item, self.data[item] def __getitem__(self, key): if isinstance(key, str): # if indexing by string: talk to dict return self.data[key] else: return self.order[key] # if indexing numerically: talk to tree def fetch(self, path): """Add all words in the given file to this inverted file. Case is ignored when adding words :param path: The path to the file from which to retrieve words """ with open(path, 'r') as document: length = 0 # total of all line lengths for line in document: for match in re.finditer('[\w-]+', line): # find all words in line word = match.group().lower() index = length + match.start() if word in self.data: # add word to dict self.data[word].append(index) else: self.data.update({word: [index]}) self.order.add(word) # AND add to ordered binary tree length += len(line)
def main(): """pass""" b = BinaryTree() print(CYN) print("size:", b.getSize()) print("root:", b.getRoot()) print(NC) print("{}Creating 10 elements... [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] {}".format(BLU, NC)) [b.insert(thing) for thing in [0,1,2,3,4,5,6,7,8,9] ] print(CYN) print("size:", b.getSize()) print("root:", b.getRoot().element) print(NC) b.breadth()
def balancePath(self, o): path = BinaryTree.path(self, o); for i in range(len(path) - 1, -1, -1): A = path[i] self.updateHeight(A) parentOfA = None if (A == self.root) else path[i - 1] if self.balanceFactor(A) == -2: if self.balanceFactor(A.left) <= 0: self.balanceLL(A, parentOfA) # Perform LL rotation else: self.balanceLR(A, parentOfA) # Perform LR rotation elif self.balanceFactor(A) == +2: if self.balanceFactor(A.right) >= 0: self.balanceRR(A, parentOfA) # Perform RR rotation else: self.balanceRL(A, parentOfA) # Perform RL rotation
def main(): bookTree = BinaryTree("Book") bookTree.insertLeft("Chapter1") bookTree.insertRight("Chapter2") chap1 = bookTree.getLeftChild() chap2 = bookTree.getRightChild() chap1.insertLeft("Sec 1.1") chap1.insertRight("Sec 1.2") chap2.insertLeft("Sec 2.1") chap2.insertRight("Sec 2.2") pre = preorder(bookTree) post = postorder(bookTree) inO = inorder(bookTree) print("In pre order: ", pre) print("In post order: ", post) print("In order: ", inO )
""" Validate BST: Implement a function to check if a binary tree is a binary search tree. """ import pytest from BinaryTree import BinaryTree def validate_bst_node(node, left_bound, right_bound): if node is None: return True return left_bound <= node.value < right_bound and validate_bst_node(node.left, left_bound, node.value) and validate_bst_node(node.right, node.value, right_bound) def validate_bst(root): return validate_bst_node(root, -float('inf'), float('inf')) @pytest.mark.parametrize('binary_tree, expected', [ (BinaryTree(10, BinaryTree(5, BinaryTree(2), BinaryTree(7)), BinaryTree(15, BinaryTree(12), BinaryTree(17))), True), (BinaryTree(1, BinaryTree(0, BinaryTree(-1, BinaryTree(-2)))), True), (BinaryTree(5, BinaryTree(3, BinaryTree(2), BinaryTree(6)), BinaryTree(10)), False) ]) def test_validate_bst(binary_tree, expected): assert validate_bst(binary_tree) == expected
class Test(unittest.TestCase): def setUp(self): self.bst = BinaryTree() self.bst.insert(5) self.bst.insert(3) self.bst.insert(4) self.bst.insert(2) self.bst.insert(1) self.bst.insert(6) self.bst.insert(9) def test_balanced_bst(self): self.assertTrue(is_balanced(self.bst)) self.bst.insert(7) self.bst.insert(8) self.assertFalse(is_balanced(self.bst)) def test_balanced_bst_optimization(self): self.assertTrue(is_balanced_with_optimization(self.bst)) self.bst.insert(7) self.bst.insert(8) self.assertFalse(is_balanced_with_optimization(self.bst))
def add(self, key: object, value: object) -> bool: p = self.find_last(key) return self.add_child(p, BinaryTree.Node(key, value))
curr_node = stack.pop() if curr_node.right: stack.append(curr_node.right) if curr_node.left: stack.append(curr_node.left) if prev_node: prev_node.left = None prev_node.right = curr_node prev_node = curr_node if __name__=='__main__': ''' The tree is: 1 / \ 2 3 / \ / \ 4 5 8 9 / \ / \ 6 7 10 11 / 12 ''' t=BinaryTree() pre_order=[1,2,4,5,6,12,7,3,8,9,10,11] in_order=[4,2,12,6,5,7,1,8,3,10,9,11] t.create_tree(pre_order, in_order) flattern_bt2list(t.root) t.pre_order_print(t.root) print t.in_order_print(t.root)
4164(3197+317+328+322) ''' from BinaryTree import BinaryTree def sum_root_to_leaf(r): if not r: return 0 return sum_root_to_leaf_helper(r, 0, [0]) def sum_root_to_leaf_helper(r, curr_num, sum): if not r: return if not r.left and not r.right: sum[0]+=curr_num*10+r.data return sum[0] curr_num = curr_num *10 + r.data sum_root_to_leaf_helper(r.left, curr_num, sum) sum_root_to_leaf_helper(r.right, curr_num, sum) return sum[0] if __name__=='__main__': t=BinaryTree() pre_order=[3,1,9,7,7,2,8,2] in_order=[7,9,1,7,3,8,2,2] t.create_tree(pre_order, in_order) print sum_root_to_leaf(t.root)
trrce(q) q.remove() trrce(q) print("isEmpty? ",s.isEmpty()) print("--------------BinaryTree----------------") tree = ''' 1 2 3 4 5 ''' print(tree) r = BinaryTree() #root rll = BinaryTree() rll.makeTree(4,None,None) rr = BinaryTree() rr.makeTree(2,rll,None) rrr = BinaryTree() rrr.makeTree(5,None,None) rl = BinaryTree() rl.makeTree(3,None,rrr) r.makeTree(1,rr,rl) print("preOrder") r.preOrder(r) print("inOrder") r.inOrder(r) print("postOrder")
else: return None # O(n) def isChildNode(node, n1): if node == None: return False if node.obj is n1.obj: return True return isChildNode(node.left, n1) or isChildNode(node.right, n1) tree = Node("0") tree.left = Node("1") tree.right = Node("2") tree.left.left = Node("3") tree.left.right = Node("4") tree.right.left = Node("5") tree.right.right = Node("6") tree.right.right.left = Node("10") tree.right.right.right = Node("7") tree.right.right.right.right = Node("8") BinaryTree.print(tree) node = get_Smallest_Common_Ancestor(tree, tree.right, tree.right.right.right.right) print("Smalest common ancestor: {}".format(node.obj))
class TreeTest(unittest.TestCase): #===============Initial========================== def setUp(self): self.b = BinaryTree(Node(12)) self.b.add(15) self.b.add(18) self.b.add(4) self.b.add(9) def tearDown(self): del self.b #==============Testing=================== """ BinaryTree -add(value): -del_node(value): -find(value, from_node=None) -min_max() -get_node_list() """ def test_add(self): val = 8 parent = self.b.root.left_child.right_child self.b.add(val) self.assertEqual(parent.left_child.value, val) print(self.b.display()) def test_del(self): x = self.b.root.right_child.right_child self.assertNotEqual(x, None) self.b.del_node(x.value) self.assertTrue(self.b.root.right_child.right_child == None) def test_find(self): res = self.b.find(15) parent = self.b.root role = "right" self.assertNotEqual(res["node"], None) self.assertEqual(parent, res["parent"]) self.assertEqual(role, res["role"]) def test_min_max(self): self.b.add(1) self.b.add(17) self.b.add(88) self.assertTrue(self.b.min_max2() == [1, 88])
def setUp(self): self.b = BinaryTree(Node(12)) self.b.add(15) self.b.add(18) self.b.add(4) self.b.add(9)
def setUp(self): print "=========== Running BinaryTree Test ===========" self.b = BinaryTree()
Chapter 4 Question 4 Given a binary tree, convert it to a set of linked lists, each list representing a layer of the tree. (I'm kind of cheating: instead of a stict linked list, I'm using regular lists. Same principle, though.) """ from BinaryTree import BinaryTree def layerize(root, current_layer=0, lst=None): if not lst: lst = list() if len(lst) < current_layer+1: lst.append(list()) lst[current_layer].append(root.data) if root.left: lst = layerize(root.left, current_layer+1, lst) if root.right: lst = layerize(root.right, current_layer+1, lst) return lst if __name__ == '__main__': root = BinaryTree(1) root.left = BinaryTree(2) root.right = BinaryTree(3) root.right.right = BinaryTree(4) print(layerize(root))
#!/usr/bin/python from BinaryTree import BinaryTree r = BinaryTree(10) r.insertLeft(5) r.getLeftChild().insertRight(6) r.insertRight(15) r.getRightChild().insertLeft(11) r.getRightChild().insertRight(100) print r.getRootVal() print r.getLeftChild().getRootVal() print r.getLeftChild().getRightChild().getRootVal() print r.getRightChild().getRootVal() print r.getRightChild().getLeftChild().getRootVal() print r.getRightChild().getRightChild().getRootVal() print def preorder(tree): if tree: print(tree.getRootVal()) preorder(tree.getLeftChild()) preorder(tree.getRightChild()) preorder(r) print r.preorder() print
# if r is leaf or r has no left child or r has no right child, the min depth is current depth if not r: return depth-1 left_min_depth = get_min_depth(r.left, depth+1) right_min_depth = get_min_depth(r.right, depth+1) if r.left and not r.right: return left_min_depth if not r.left and r.right: return right_min_depth return min(left_min_depth, right_min_depth) if __name__=='__main__': ''' The tree is: 1 / \ 2 3 / \ / \ 4 5 8 9 / \ / \ 6 7 10 11 / 12 ''' t=BinaryTree() pre_order=[1,2,4,5,6,12,7,3,8,9,10,11] in_order=[4,2,12,6,5,7,1,8,3,10,9,11] t.create_tree(pre_order, in_order) print get_min_depth(t.root,1)
if __name__=='__main__': ''' T1 is: 1 / \ 2 3 / \ / \ 4 5 8 9 / \ / \ 6 7 10 11 / 12 T2 is : 3 / \ 8 9 / \ 10 11 ''' t1=BinaryTree() pre_order=[1,2,4,5,6,12,7,3,8,9,10,11] in_order=[4,2,12,6,5,7,1,8,3,10,9,11] r1=t1.create_tree(pre_order, in_order) t2=BinaryTree() pre_order=[3,8,9,10,11] in_order=[8,3,10,9,11] r2=t2.create_tree(pre_order, in_order) print is_subtree(r1,r2)
def Decode_by_Tree(T, codeString): space = ' ' temp = BinaryTree(space) temp = T print(codeString) phraseString = "" check = True Decode_phrase_list = [] Decode_phrase_list.append(phraseString) Decode_phrase_list.append(check) codeStringlist = [] for n in codeString: codeStringlist.append(n) foundchar = False while (check and (len(codeStringlist) > 0)): digit = codeStringlist.pop(0) if (digit == '0'): print("Go Left") if (temp.getLeftChild() != None): if (temp.getLeftChild().getRootVal() == space): temp = temp.getLeftChild() if ((len(codeStringlist) == 0)): check = False print( " Erorr _________________Left_______(len (codeStringlist) == 0)________________", temp.getRootVal()) else: print(temp.getLeftChild().getRootVal()) phraseString = phraseString + temp.getLeftChild( ).getRootVal() print(phraseString) temp = T else: check = False print(" Erorr _________________Left_______________________", temp.getRootVal()) else: if (digit == '1'): print("Go Right") if (temp.getRightChild() != None): if (temp.getRightChild().getRootVal() == space): temp = temp.getRightChild() if ((len(codeStringlist) == 0)): check = False print( " Erorr _________________Right_______(len (codeStringlist) == 0)________________", temp.getRootVal()) else: print(temp.getRightChild().getRootVal()) phraseString = phraseString + temp.getRightChild( ).getRootVal() print(phraseString) temp = T else: check = False print( " Erorr ___________________Right_____________________", temp.getRootVal()) Decode_phrase_list[0] = phraseString Decode_phrase_list[1] = check return Decode_phrase_list
def main(): bt = BinaryTree() dataSet = set([]) # values = ['F', 'B', 'A', 'D', 'C', 'E', 'G', 'I', 'H'] values = [25, 15, 40, 10, 20, 30, 50, 18, 22, 27, 45, 60, 42, 47, 49] for r in range(random.randint(7, 12)): n = random.randint(1, 100) dataSet.add(n) print ("Inserting into Binary Tree: ") # for data in dataSet: for data in values: bt.insert(data) print (data, sep=" ", end=" ") print () print ("Inorder: ") bt.inorder() print ("Preorder: ") bt.preorder() print ("postorder: ") bt.postorder() print ("Binary Tree Size: ", bt.size()) print ("Max Depth: ", bt.maxdepth()) print ("Min value in BST: ", bt.minvalue()) print ("Max value in BST: ", bt.maxvalue()) targetsums = [50, 78, 82, 97, 150] for target in targetsums: ans = bt.haspathsum(target) print ("Sum: %d in binary tree: %s" % (target, ans)) print ("print all the root to leaf paths in binary tree") bt.printpaths() print ("Mirroring the binary tree: ") bt.mirror() bt.inorder() bt = BinaryTree() values = [2, 3, 1] print ("Inserting into Binary Tree: ") # for data in dataSet: for data in values: bt.insert(data) print (data, sep=" ", end=" ") print () bt.inorder() print ("After doing double tree: ") bt.doubletree() bt.inorder() bt1 = BinaryTree() bt2 = BinaryTree() # values = ['F', 'B', 'A', 'D', 'C', 'E', 'G', 'I', 'H'] values = [25, 15, 40, 10, 20, 30, 50, 18, 22, 27, 45, 60, 42, 47, 49] print ("Inserting into Binary Tree: ") # for data in dataSet: for data in values: bt1.insert(data) bt2.insert(data) print (data, sep=" ", end=" ") print () bt1.inorder() bt2.inorder() comp = bt1.sametree(bt2) print ("Are the trees same: ", comp) print ("is bt1 BST: ", bt1.isbst1()) print ("is bt2 BST: ", bt2.isbst1()) bt2.mirror() print ("is bt2 BST after mirroring: ", bt2.isbst1()) bt1 = BinaryTree() bt2 = BinaryTree() for data in values: bt1.insert(data) bt2.insert(data) print (data, sep=" ", end=" ") print () print ("is bt1 BST (efficient version): ", bt1.isbst2()) print ("is bt2 BST (efficient version): ", bt2.isbst2()) bt2.mirror() print ("is bt2 BST after mirroring(efficient version): ", bt2.isbst2()) for i in range(1,13): tot = bt.counttrees(i) print ("%d nodes: %d unique BSTs" % (i, tot))
def main(): tree = BinaryTree() tree.insert("George") tree.insert("Michael") tree.insert("Tom") tree.insert("Adam") tree.insert("Jones") tree.insert("Peter") tree.insert("Daniel") printTree(tree) print("\nAfter delete George:") tree.delete("George") printTree(tree) print("\nAfter delete Adam:") tree.delete("Adam") printTree(tree) print("\nAfter delete Michael:") tree.delete("Michael") printTree(tree)
if not r.parent: return None else: return r.parent def get_next(r): if r.right: return get_leftmost_child(r.right) else: return get_first_right_parent(r) if __name__=='__main__': ''' The tree is: 20 / \ 10 30 / \ 5 15 / \ \ 3 7 17 ''' t=BinaryTree(); pre_order=[20,10,5,3,7,15,17,30] in_order=[3,5,7,10,15,17,20,30] root=t.create_tree(pre_order, in_order) for node in in_order: r=t.get_TreeNode_NR(root,node) print "r is ", r print "r's next is", get_next(r)
def setData(self, data): BinaryTree.setData(self, data) if (self.getHeight() < 0): self.setHeight(0)
def __init__(self): self.data = dict() # dict contains: { word: [indices in doc where word is found]} self.order = BinaryTree() # sorted binary tree maintains the order of items
graph.addEdge(2,9) graph.addEdge(3,4) graph.addEdge(4,6) graph.addEdge(4,2) graph.addEdge(4,9) graph.addEdge(5,10) graph.addEdge(5,3) graph.addEdge(6,3) graph.addEdge(7,8) graph.addEdge(8,3) graph.addEdge(9,10) graph.addEdge(10,4) graph.findVertex(2) graph.findVertex(3) graph.findVertex(4) graph.findVertex(5) graph.findVertex(6) print("Graph Test Completed.") print("-------------------------------------------------------") print("This is the tree test. It does not work all the way.") tree = BinaryTree(1) tree.add(2,1) tree.add(3,1) tree.add(10,1) tree.add(4,2) tree.add(5,2) tree.remove(2) tree.remove(1) print("Tree Test Completed.")
class TestBinaryTree(unittest.TestCase): def setUp(self): print "=========== Running BinaryTree Test ===========" self.b = BinaryTree() def tearDown(self): print "================================================" def test_add_integers_and_print(self): # Run by unittest - adds 10 nodes in tree, then prints to display they were added correctly # State before: Empty tree # State after: Tree with 10 nodes self.b.add(1, None) self.b.add(2, 1) self.b.add(3, 1) self.b.add(4, 2) self.b.add(5, 2) self.b.add(6, 3) self.b.add(7, 3) self.b.add(8, 4) self.b.add(9, 4) self.b.add(10, 5) self.b.print_tree() def test_delete_and_print(self): # Run by unittest - adds 10 nodes in tree, deletes 2, then prints to ensure they are correctly deleted # State before: Empty tree # State after: Tree with 8 nodes self.b.add(1, None) self.b.add(2, 1) self.b.add(3, 1) self.b.add(4, 2) self.b.add(5, 2) self.b.add(6, 3) self.b.add(7, 3) self.b.add(8, 4) self.b.add(9, 4) self.b.add(10, 5) self.b.delete(10) self.b.delete(8) self.b.print_tree()
def makeparsetree(expression): now = BinaryTree(None) parent = Stack() for item in expression: if item in openbraket: now.addleft(None) parent.push(now) now = now.getleft() elif item in endbraket: if not parent.isEmpty(): now = parent.pop() elif item in operators: now.setdata(item) parent.push(now) now.addright(None) now = now.getright() else : now.setdata(int(item)) now = parent.pop() """else: return "Invalid expression""" # print "Read ", item #debug line return now
recursive(current_root, preorder_right, inorder_right, 'right') recursive(btree.root, preorder, inorder, 'None') return btree ''' Still recursive solution ''' def solution2(preorder, inorder): pass if __name__ == '__main__': element_list = list(np.random.choice(100, size=20, replace=False)) btree = BinaryTree(element_list) preorder = btree.preorder_iterative(btree.root) inorder = btree.inorder_iterative(btree.root) print(preorder, inorder) reconstructed_btree = solution1(preorder, inorder) reorder = reconstructed_btree.preorder_iterative(reconstructed_btree.root) inorder = reconstructed_btree.inorder_iterative(reconstructed_btree.root) print(preorder, inorder) reconstructed_btree = solution2(preorder, inorder) preorder = reconstructed_btree.preorder_iterative(reconstructed_btree.root) inorder = reconstructed_btree.inorder_iterative(reconstructed_btree.root) print(preorder, inorder)
def __init__(self): BinaryTree.__init__(self) self.height = 1
#!/usr/bin/env python3 #Authors: M269 Module Team #Date: 19/1/13 from BinaryTree import BinaryTree #Create a node and reference representation of the #tree shown in Figure 6.6(a) on p. 238 of Ranum and Miller. #The nodes are added level by level working downwards. print('Creating tree') #Level 0 t = BinaryTree('a') #Level 1 t.insertLeft('b') t.insertRight('c') #Level 2 t.getLeftChild().insertLeft('d') t.getLeftChild().insertRight('e') t.getRightChild().insertLeft('f') #Function to convert from node and reference #to list of lists representation. def makeLists(tr): #If tree is empty the list is empty if tr == None: return [] #Otherwise call the function recursively
def __init__(self, nil=None): BinaryTree.__init__(self) self.n = 0 self.nil = nil
from BinaryTree import BinaryTree import sys def max_path_sum(r): max_sum = [-sys.maxint] # pass in max_sum as a list to modify it's value in recursion max_path_sum_helper(r, max_sum) return max_sum[0] def max_path_sum_helper(r, max_sum): if not r: return 0 # get left and right subtrees' max sum path left_max = max(0, max_path_sum_helper(r.left, max_sum)) right_max = max(0, max_path_sum_helper(r.right, max_sum)) # update max_sum max_sum[0] = max(max_sum[0], r.data + left_max + right_max) # can only return one subtree path, return the larger one return max(r.data + left_max, r.data + right_max) if __name__ == '__main__': t = BinaryTree() pre_order = [-1, 1, 23, 2, 24, 9, 7, 6] in_order = [23, 1, 24, 2, -1, 7, 9, 6] t.create_tree(pre_order, in_order) t.in_order_print(t.root) print print max_path_sum(t.root)
def generate_bt(points_to_insert): binary_tree = BinaryTree() for p in points_to_insert: binary_tree.add(p) return binary_tree
else: return r.parent def get_next(r): if r.right: return get_leftmost_child(r.right) else: return get_first_right_parent(r) if __name__ == '__main__': ''' The tree is: 20 / \ 10 30 / \ 5 15 / \ \ 3 7 17 ''' t = BinaryTree() pre_order = [20, 10, 5, 3, 7, 15, 17, 30] in_order = [3, 5, 7, 10, 15, 17, 20, 30] root = t.create_tree(pre_order, in_order) for node in in_order: r = t.get_TreeNode_NR(root, node) print "r is ", r print "r's next is", get_next(r)
def Encode_by_Tree(charcodelist): space = ' ' myTree_check_list = [] mytree = BinaryTree(space) check = True myTree_check_list.append(mytree) myTree_check_list.append(check) print(myTree_check_list) for i in range(0, len(charcodelist) - 1): print("#####################################") if (not check): break line = charcodelist[i] mychar = line[0] mycode = line[1] mycode = mycode + mychar temp = BinaryTree(space) temp = mytree for digit in range(0, len(mycode) - 1): if (digit == (len(mycode) - 2)): digit = digit + 1 print("-----------------------------------") if (mycode[digit] == '0'): print("Go left") if (temp.getLeftChild() == None): print("Add Left") temp.insertLeft(space) temp = temp.getLeftChild() else: if (temp.getLeftChild().getRootVal() == space): print("just go left ") temp = temp.getLeftChild() else: check = False print( " Erorr ______on going left________________________________________", mycode[len(mycode) - 1]) break else: if (mycode[digit] == '1'): print("Go Right") if (temp.getRightChild() == None): print("Add Right") temp.insertRight(space) temp = temp.getRightChild() else: if (temp.getRightChild().getRootVal() == space): print("just go Right") temp = temp.getRightChild() else: check = False print( " Erorr ______on going Right________________________________________", mycode[len(mycode) - 1]) break else: if (mycode[len(mycode) - 2] == '0'): try: if (temp.getLeftChild().getRootVal() != None): check = False print( " Erorr ______on Adding Left ________________________________________", mycode[len(mycode) - 1]) break except AttributeError: temp.insertLeft(mycode[digit]) print("Adding to the left of the tree ", mycode[digit]) if (mycode[len(mycode) - 2] == '1'): try: if (temp.getRightChild().getRootVal() != None): check = False print( " Erorr ______on Adding Right ________________________________________", mycode[len(mycode) - 1]) break except AttributeError: temp.insertRight(mycode[digit]) print("Adding to the Right of the tree ", mycode[digit]) print(charcodelist[i]) myTree_check_list[0] = mytree myTree_check_list[1] = check return myTree_check_list
print("found bacteria {}".format(bact.name)) line_length = _SPACE_PER_LEVEL - len(bact.name) horizontal_line = "" if ht != 0: #Build a line of approrpiate length for the diagram for j in range(0, line_length): horizontal_line += "-" horizontal_line += "|" line = bact.name + horizontal_line + line else: line = _EMPTY_LINE + line f.write(line) if __name__ == '__main__': timothy = Bacteria(_LENGTH, _POS_X, _POS_Y, _AGE, "timothy") tree = BinaryTree(timothy) # divide(tree) #Run for i units of time for i in range(_TIME): children = tree.getLiveBacteria() for child in children: if shouldDivide(child.root): divide(child) if (_DEBUG): print(child.root.name) print("Age: {}".format(str(child.root.age))) print("Length: {}".format(str(child.root.len))) tree.ageTree() print(tree.root)
def convertToBinaryTree(treeRoot, nodelist): if not treeRoot.children: node = next(x for x in nodelist if x.id == treeRoot.id) newNode = BinaryTree("tmp", BinaryTree(node.getVal())) # poprawi typ oda return newNode if len(treeRoot.children) == 1: newNode = convertToBinaryTree(treeRoot.children[0], nodelist) if newNode.right is None: newNode.right = BinaryTree(treeRoot.getVal()) else: parent = BinaryTree("tmpParent1", newNode, BinaryTree(treeRoot.getVal())) return parent parent = None for child in treeRoot.children: newNode = convertToBinaryTree(child, nodelist) if parent is None: parent = newNode if parent.right is None: parent.right = BinaryTree(treeRoot.getVal()) else: newParent = BinaryTree("tmpParent2", parent, newNode) parent = newParent return parent
from BinaryTree import BinaryTree from BinaryTree import Traversal if __name__ == '__main__': print("Binary TREE") bt = BinaryTree() bt.insert(3) bt.insert(1) bt.insert(2) bt.insert(4) bt.insert(5) bt.insert(10) bt.insert(7) bt.insert(73) bt.insert(23) bt.print() bt.print(traversal_type=Traversal.REVERSE) # bst.print(traversal_type=Traversal.PREORDER) # bst.print(traversal_type=Traversal.POSTORDER) # bst.print(traversal_type=Traversal.INORDER) # print('\n') # print('After deleting: ') # bst.set_root(bst.delete_node(bst.get_root(), 2)) # bst.set_root(bst.delete_node(bst.get_root(), 73)) # bst.set_root(bst.delete_node(bst.get_root(), 3)) # bst.set_root(bst.delete_node(bst.get_root(), 1)) # bst.set_root(bst.delete_node(bst.get_root(), 4)) # bst.print() # bst.set_root(bst.delete_node(bst.get_root(), 7))
que.put(node.get_right()) return node.data ### REVISIT THIS ####### def delete_node(root): if root is None: return else: que = queue.Queue() que.put(root) if not que.empty(): node = que.get() if node.get_left(): que.put(node.get_left()) if node.get_right(): que.put(node.get_right()) root.data, node.data = node.data, root.data del node if __name__ == "__main__": tree = BinaryTree() for i in range(1, 10): tree.add_node(i) print(deepest_node(tree.root)) delete_node(tree.root) tree.level_order()
from BinaryTree import BinaryTree, Node from getHeightOfBT import getHeightOfBT from printElementsAtAGivenLvl import printElementsAtAGivenLevel tree = BinaryTree() tree.createRootNode(2, None, None) tree.root.left = Node(7, None, None) tree.root.left.left = Node(2, None, None) tree.root.left.right = Node(6, None, None) tree.root.left.right.left = Node(5, None, None) tree.root.left.right.right = Node(11, None, None) tree.root.right = Node(5, None, None) tree.root.right.right = Node(9, None, None) tree.root.right.right.left = Node(4, None, None) # levelwiseLotOfBT # ************************************************************************************************************************ def levelwiseLotOfBT(node): treeHeight = getHeightOfBT(node) for level in range(1, treeHeight + 2): print("\n Level " + str(level) + ":-") printElementsAtAGivenLevel(node, level) # ************************************************************************************************************************ print("Levelwise LOT of the given tree is: ") levelwiseLotOfBT(tree.root)
# 4 5 # # Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3]. # 如何求一颗树的深度 def depth(rt): if rt is None: return 0 leftdepth = depth(rt.lchild) rightdepth = depth(rt.rchild) return max(leftdepth, rightdepth) + 1 def diameterOfBinaryT(rt): maxD = 0 ld = depth(rt.lchild) lr = depth(rt.rchild) maxD = max(maxD, ld + lr) return maxD if __name__ == "__main__": from BinaryTree import BinaryTree binary_tree = BinaryTree() for i in range(1, 5): binary_tree.insert(i) binary_tree.traverse() print(diameterOfBinaryT(binary_tree.root))
def new_node(self, x): u = BinaryTree.Node(x) u.left = u.right = u.parent = self.nil return u
def test(): tree = BinaryTree() tree.print() tree.insert(8) tree.insert(3) tree.insert(10) tree.insert(1) tree.insert(6) tree.insert(14) tree.insert(4) tree.insert(7) tree.insert(13) tree.print() try: tree.insert(14) # Repetido, debe mostrar mensaje de error except KeyError: print("El nodo con llave 14 ya se encuentra en el árbol") try: tree.insert(1) # Repetido, debe mostrar mensaje de error except KeyError: print("El nodo con llave 1 ya se encuentra en el árbol") print("Mínimo:", tree.minimum().key) print("Máximo:", tree.maximum().key) tree.search(4) tree.search(8) tree.search(13) tree.search(2) tree.search(15) tree.delete(7) # Borrando el 7 (sin hijos) tree.print() tree.delete(10) # Borrando el 10 (solo hijo der) tree.print() tree.delete(6) # Borrando el 6 (solo hijo izq) tree.print() tree.delete(3) # Borrando el 3 (ambos hijos) tree.print() try: tree.delete(3) # Borrando el 3 (nodo no existe) except KeyError: print("El nodo con llave 3 no se encuentra en el árbol") tree.print() tree.delete(8) # Borrando el 8 (raíz, ambos hijos) tree.print() tree.insert(100) tree.print()
from BinaryTree import BinaryTree def next_node(root): current = root if current.right is not None: current = current.right while current.left is not None: current = current.left return current # Go up until we find a parent who this is the left subtree of while current.parent is not None: if current.parent.left is current: return current.parent current = current.parent if __name__ == '__main__': root = BinaryTree(4) root.addleft(BinaryTree(2)) root.left.addright(BinaryTree(3)) root.left.addleft(BinaryTree(1)) root.addright(BinaryTree(6)) print('Expect 3:', next_node(root.left).data) print('Expect 4:', next_node(root.left.right).data) # Tree of one node root = BinaryTree(0) print('Expect None:', next_node(root))
along the longest path) recursively """ # Base case if root.left == None and root.right == None: return acc elif root.left != None and root.right != None: # Neither child is None return max(calc_height(root.left, acc+1), calc_height(root.right, acc+1)) elif root.left != None: # At least one child is None return calc_height(root.left, acc+1) else: return calc_height(root.right, acc+1) def is_balanced(root): if root.left != None and root.right != None: return abs(calc_height(root.left) - calc_height(root.right)) <= 1 elif root.left != None: return calc_height(root.left) <= 1 elif root.right != None: return calc_height(root.right) <= 1 else: return True if __name__ == '__main__': root = BinaryTree(1) root.right, root.left = BinaryTree(2), BinaryTree(3) print(is_balanced(root)) print('Unbalancing the tree...') root.right.right, root.right.right.right = BinaryTree(4), BinaryTree(5) print(is_balanced(root))
from TreeNode import TreeNode as Node from BinaryTree import BinaryTree as Tree complete_15_vals = [8,4,12,2,6,1,3,5,7,10,14,9,11,13,15] tree = Tree() for val in complete_15_vals: tree.insert(val) print(tree.pre_order()) print(tree.in_order()) print(tree.post_order())
def test_check_subtree_one_by_one(self): bst2 = BinaryTree() bst2.insert(7) bst2.insert(9) bst2.insert(6) self.assertTrue(check_subtree_one_by_one(self.bst1, bst2)) bst3 = BinaryTree() bst3.insert(5) bst3.insert(3) bst3.insert(6) bst3.root.right.data = 4 self.assertFalse(check_subtree_one_by_one(self.bst1, bst3))
node2 = BinaryTreeNode(5) node3 = BinaryTreeNode(9) node2.right = node3 node1.left = node2 root.left = node1 node4 = BinaryTreeNode(2) node5 = BinaryTreeNode(7) node6 = BinaryTreeNode(4) node4.left = node5 node4.right = node6 root.right = node4 bt = BinaryTree(root) print root.level_order() """ print 'height of the tree:', root.height() print 'full nodes count :',findFullNodeCount(root) print 'search :' print get_branch(root,3) print 'tree diameter:',get_diameter(root) print 'branches sums:',get_branch_sums(root) print 'has path sum:',has_path_sum(root,21) lca_res = lca(root,node6,node3) print 'lca between %d and %d is %s'% (node6.val,node3.val,lca_res) """ #print exterior_binary_tree(root)
def max_sum_helper(r, curr_sum, max_sum): if not r: return curr_sum += r.data if not r.left and not r.right: max_sum[0] = max(max_sum[0], curr_sum) return max_sum_helper(r.left, curr_sum, max_sum) max_sum_helper(r.right, curr_sum, max_sum) if __name__ == "__main__": """ The tree is: 1 / \ 2 3 / \ / \ 4 5 8 9 / \ / \ 6 7 10 11 / 12 """ t = BinaryTree() pre_order = [1, 2, 4, 5, 6, 12, 7, 3, 8, 9, 10, 11] in_order = [4, 2, 12, 6, 5, 7, 1, 8, 3, 10, 9, 11] root = t.create_tree(pre_order, in_order) print path_max_sum(root)
from BinaryTree import BinaryTree operations = [] operations_count = 0 with open('abce.in') as f: operations_count = int(f.readline()) for index, line in enumerate(f.readlines()): operation_number, *operation_params = [int(number) for number in line.split()] operations.append({'type': operation_number, 'params': operation_params}) tree = BinaryTree() with open('abce.out', 'w') as g: for operation in operations: if operation['type'] == 1: tree.insert(*operation['params']) elif operation['type'] == 2: tree.delete(*operation['params']) elif operation['type'] == 3: current = tree.find(tree.root, *operation['params']) g.write('{}\n'.format('1' if current else '0')) elif operation['type'] == 4: g.write('{}\n'.format(tree.predecessor(*operation['params']))) elif operation['type'] == 5: g.write('{}\n'.format(tree.successor(*operation['params'])))
def main(): """ #Test de construction d'un ABR n10 = BinaryTree.BinaryNode(10) n9 = BinaryTree.BinaryNode(9) n8 = BinaryTree.BinaryNode(8, n9, n10) n7 = BinaryTree.BinaryNode(7) n6 = BinaryTree.BinaryNode(6) n5 = BinaryTree.BinaryNode(5, n6, n7) n4 = BinaryTree.BinaryNode(4, n5, n8) n110 = BinaryTree.BinaryNode(110) n19 = BinaryTree.BinaryNode(19) n18 = BinaryTree.BinaryNode(18, n19, n110) n17 = BinaryTree.BinaryNode(17) n16 = BinaryTree.BinaryNode(16) n15 = BinaryTree.BinaryNode(15, n16, n17) n14 = BinaryTree.BinaryNode(14, n15, n18) #We create the binary tree from all the binary nodes tree = BinaryTree.BinaryTree(0, n4, n14) """ #Here we are making a Binary Search Tree (we will call them tree in the future) by ourself n0 = BinaryNode(0) n1 = BinaryNode(1, n0, None) n5 = BinaryNode(5) n3 = BinaryNode(3, n1, n5) n9 = BinaryNode(9) tree = BinaryTree(6, n3, n9) #We display the tree tree.display() #List theList = [5,3,6,9,1, 14, 15 ,18 ,12, 24, 87, 45, 14, 15, 25,26,27,28,29,30,31,32,32,34,35,36,37] #Check if a value exists in the given tree numberOfAttempts = 36 for i in range(0, numberOfAttempts): print("Research of", i, "(The first value is the result and the second the number of iterations/recursions):") print("Binary tree research:", tree.exists(i)) print("List research:", existsInList(theList, i)) print(" ") #Then do some stats binaryTreeAverage = 0 listAverage = 0 for i in range(0, numberOfAttempts): binaryTreeAverage += tree.exists(i)[1] listAverage += existsInList(theList, i)[1] print("The average for the Binary tree is :", binaryTreeAverage/numberOfAttempts) #Si on avait N valeurs la moyenne tendrait vers ln(N) print("The average for the List is :", listAverage/numberOfAttempts) #Si on avait N valeurs la moyenne tendrait vers N/2 print("\n\n") #Now we are making a tree with a list newTree = BinaryNode.fromList(theList) newTree.display() newTree.addNode(100) newTree.addNode(84) newTree.addNode(85) newTree.addNode(86) newTree.addNode(44) newTree.display() #We balance a tree using the list made of the tree's values newTree2 = newTree.balance() newTree2.display()
from BinaryTree import BinaryTree from BTreeNode import BTreeNode import math #set up binary tree # node1 = BTreeNode(12,None, None) node2 = BTreeNode(13,None, None) node3 = BTreeNode(11,None, None) node4 = BTreeNode(10,None, None) tree = BinaryTree(node1) tree.addNewNode(node2) tree.addNewNode(node3) tree.addNewNode(node4) print 'Node Count ' + str(tree.nodeCount) print 'Height ' + str(tree.getHeight()) print tree.findNodeAndParent(11, tree.rootNode) list = tree.findNodeAndParent(11, tree.rootNode) print 'Getting info out of the List' print list[0].getInformation() print list[1].getInformation() print '==========================================' tree.recursiveInOrderBinaryTreeLoop(tree.rootNode) print '=========================================='
def __init__(self): BinaryTree.__init__(self)
from BinaryTree import BinaryTree bt = BinaryTree() vals = [9, 5, 7, 2, 6, 10, 16, 1, 3, 8, 17] root = None for x in vals: root = bt.insert(root, x) # print("PreOrder") # bt.preOrder(root) # print() print("InOrder") bt.inOrder(root) print() # print("PostOrder") # bt.postOrder(root) # print() # bt.search(root, 31) root = bt.delete(root, 5) bt.inOrder(root)