def test_WideAllNodes(self): self.assertEqual( [node.NodeKey for node in list(self.tree.WideAllNodes())], [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]) self.tree = BST(BSTNode(8, 80, None)) self.assertEqual( [node.NodeKey for node in list(self.tree.DeepAllNodes(0))], [8])
def setUp(self) -> None: self.tree = BST(None) self.tree.AddKeyValue(4, "value_4") self.tree.AddKeyValue(2, "value_2") self.tree.AddKeyValue(6, "value_6") self.tree.AddKeyValue(5, "value_5") self.tree.AddKeyValue(7, "value_7")
def main(): pass b = BST() b.insert(12) b.insert(9) b.insert(13) b.preorder()
def setUp(self) -> None: self.tree = BST(None) self.tree.AddKeyValue(4, "value_4") self.tree.AddKeyValue(2, "value_2") self.tree.AddKeyValue(6, "value_6") self.tree.AddKeyValue(1, "value_1") self.tree.AddKeyValue(3, "value_3")
def find_suspects(people): people_inside = BST() # min heap (ordered by exit time) building = Heap(key=lambda person: person.exit) # list of SuspectGroups suspects = [] for person in people: next_to_leave = building.top() while next_to_leave is not None and not next_to_leave.shares_time_with( person): same_time = [building.pop()] while building.top( ) is not None and next_to_leave.exits_at_same_time(building.top()): same_time.append(building.pop()) append_if_are_suspects(suspects, people_inside, next_to_leave) for next in same_time: people_inside.remove(next) next_to_leave = building.top() people_inside.insert(person) building.push(person) while len(people_inside) > 4: next_to_leave = [building.pop()] while building.top( ) is not None and next_to_leave[0].exits_at_same_time(building.top()): next_to_leave.append(building.pop()) append_if_are_suspects(suspects, people_inside, next_to_leave[0]) for next in next_to_leave: people_inside.remove(next) return suspects
def test_DeepAllNodes(self): # проверка post-order self.assertEqual( [node.NodeKey for node in list(self.tree.DeepAllNodes(1))], [1, 3, 2, 5, 7, 6, 4, 9, 11, 10, 13, 15, 14, 12, 8]) self.tree = BST(BSTNode(8, 80, None)) self.assertEqual( [node.NodeKey for node in list(self.tree.DeepAllNodes(0))], [8])
def binary_search(lst, lst2): bst = BST(names_1[0]) for i in range(len(names_1)): if i != 0: bst.insert(names_1[i]) for name_2 in names_2: if bst.contains(name_2): duplicates.append(name_2)
def test_DeepAllNodes(self): # проверка in-order self.assertEqual( [node.NodeKey for node in list(self.tree.DeepAllNodes(0))], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) self.tree = BST(BSTNode(8, 80, None)) self.assertEqual( [node.NodeKey for node in list(self.tree.DeepAllNodes(0))], [8])
def main(argv): tree = BST([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) tree.preorder_traversal(tree.root) print("Next largest value of node {} is: {}".format( tree.root.left.left.value, next_largest(tree.root.left.left).value)) print("Next largest value of node {} is: {}".format( tree.root.left.right.value, next_largest(tree.root.left.right).value)) print("Next largest value of node {} is: {}".format( tree.root.left.left.right.value, next_largest(tree.root.left.left.right).value))
def setUp(self): # Создание дерева из 15 злементов начиная от корня (8) self.tree = BST(BSTNode(8, 80, None)) self.tree.AddKeyValue(4, 40) self.tree.AddKeyValue(12, 120) self.tree.AddKeyValue(2, 20) self.tree.AddKeyValue(6, 60) self.tree.AddKeyValue(10, 100) self.tree.AddKeyValue(14, 140) self.tree.AddKeyValue(1, 10) self.tree.AddKeyValue(3, 30) self.tree.AddKeyValue(5, 50) self.tree.AddKeyValue(7, 70) self.tree.AddKeyValue(9, 90) self.tree.AddKeyValue(11, 110) self.tree.AddKeyValue(13, 130) self.tree.AddKeyValue(15, 150)
def get_one_blog_posts(blog_post_id): blog_posts = BlogPost.query.all() random.shuffle(blog_posts) bst = BST() for post in blog_posts: bst.insert({ "id": post.id, "title": post.title, "body": post.body, "user_id": post.user_id, }) post = bst.search_blog(blog_post_id) if not post: return jsonify({"message": "Blog Post not found"}), 404 return jsonify(post), 200
def setUp(self) -> None: self.tree = BST(None) self.tree.AddKeyValue(8, "") self.tree.AddKeyValue(4, "") self.tree.AddKeyValue(12, "") self.tree.AddKeyValue(2, "") self.tree.AddKeyValue(6, "") self.tree.AddKeyValue(1, "") self.tree.AddKeyValue(5, "") self.tree.AddKeyValue(7, "") self.tree.AddKeyValue(10, "") self.tree.AddKeyValue(14, "") self.tree.AddKeyValue(11, "") self.tree.AddKeyValue(13, "") self.tree.AddKeyValue(15, "") self.tree.AddKeyValue(16, "") self.assertEqual(8, self.tree.Root.NodeKey) self.assertEqual(4, self.tree.Root.LeftChild.NodeKey) self.assertEqual(2, self.tree.Root.LeftChild.LeftChild.NodeKey) self.assertEqual(1, self.tree.Root.LeftChild.LeftChild.LeftChild.NodeKey) self.assertEqual(6, self.tree.Root.LeftChild.RightChild.NodeKey) self.assertEqual( 7, self.tree.Root.LeftChild.RightChild.RightChild.NodeKey) self.assertEqual(5, self.tree.Root.LeftChild.RightChild.LeftChild.NodeKey) self.assertEqual(12, self.tree.Root.RightChild.NodeKey) self.assertEqual(10, self.tree.Root.RightChild.LeftChild.NodeKey) self.assertEqual( 11, self.tree.Root.RightChild.LeftChild.RightChild.NodeKey) self.assertEqual(14, self.tree.Root.RightChild.RightChild.NodeKey) self.assertEqual( 13, self.tree.Root.RightChild.RightChild.LeftChild.NodeKey) self.assertEqual( 15, self.tree.Root.RightChild.RightChild.RightChild.NodeKey) self.assertEqual( 16, self.tree.Root.RightChild.RightChild.RightChild.RightChild.NodeKey)
def main(argv): tree = BST([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) tree.preorder_traversal(tree.root) nodea = tree.root.left.left nodeb = tree.root.right.left.left print("Lowest common ancestor of {} and {} is: {}".format( nodea.value, nodeb.value, lowest_common_ancestor(nodea, nodeb))) print("Lowest common ancestor of {} and {} is: {}".format( nodea.value, nodeb.value, lowest_common_ancestor_recursive(nodea, nodeb))) nodea = tree.root.left.left nodeb = tree.root.left.right.left print("Lowest common ancestor of {} and {} is: {}".format( nodea.value, nodeb.value, lowest_common_ancestor(nodea, nodeb))) print("Lowest common ancestor of {} and {} is: {}".format( nodea.value, nodeb.value, lowest_common_ancestor_recursive(nodea, nodeb))) nodea = tree.root.left.left nodeb = tree.root.left.left.right print("Lowest common ancestor of {} and {} is: {}".format( nodea.value, nodeb.value, lowest_common_ancestor(nodea, nodeb))) print("Lowest common ancestor of {} and {} is: {}".format( nodea.value, nodeb.value, lowest_common_ancestor_recursive(nodea, nodeb)))
def setUp(self) -> None: self.tree = BST(BSTNode(4, "value_4", None))
def setUp(self) -> None: self.tree = BST(None) self.tree.AddKeyValue(4, "value_4")
# #Kristian Knudsen Damsgaard, 2019 # #Testing for the binary tree project # # from binary_search_tree import BinarySearchTree as BST from avl import AVL #TESTING BinarySearchTree ------------------------------------------------------------------------- tree = BST() # #Tests getNode() on empty tree # print(tree.getNode(0)) # #Tests getNode() with non-integer argument # tree.insertNode("ti", "data_ti") # #Tests insertNode() on empty tree # tree.insertNode(10, "data_10") # #Tests getNode() # print( "Key 10: " + str(tree.getNode(10).getKey()) ) # #Tests insertNode() on duplicate key # tree.insertNode(10, "data_10") # #Tests insertNode() on non-empty tree (left side) # tree.insertNode(9, "data_9") # print( "Key 9: " + str(tree.getNode(9).getKey()) ) # #Tests insertNode() on non-empty tree (right side) # tree.insertNode(11, "data_11") # print( "Key 11: " + str(tree.getNode(11).getKey()) ) # # Tests getParent() # print( "Parent of 9: " + str(tree.getNode(9).getParent().getKey()) )
def test_Count(self): # проверка подсчёта количества узлов дерева self.assertEqual(self.tree.Count(), 15) self.tree = BST(BSTNode(8, 80, None)) self.assertEqual(self.tree.Count(), 1)
class BinaryTree: def __init__(root: Node): self.root = Node self.left = None self.right = None def insert_node(n: Node): # TODO: implement generic binary tree insert. pass def breath_first_search(T: BST): queue = [T] result = [] while queue: cur_node = queue.remove(0) if cur.left is not None: queue.append(cur.left) if cur.right is not None: queue.append(cur.right) result.append(cur.key) return result if __name__ == "__main__": bst = BST(1) bst.insert(4) bst.insert(2) bst.insert(3) bst.insert(3)
import sys sys.path.append('..') from binary_search_tree import BST # Set up tree tree = BST(4) # Insert elements tree.insert(2) tree.insert(1) tree.insert(3) tree.insert(5) # Check search # Should be True assert (tree.search(4) == True), "Failed in tree.search" # Should be False assert (tree.search(6) == False), "Failed in tree.search" print("ALL TEST PASSED")
from binary_search_tree import BST if __name__ == '__main__': T1 = BST(7) T1.insert_bulk([1, 8, 23, 12, 5]) T2 = BST(54) T2.insert_bulk([1, 8, 23, 12, 5]) n1 = T1.minValue(T1.root) n2 = T2.minValue(T2.root) while (n1 is not None and n2 is not None): if n1.value == n2.value: print n1.value n1 = T1.GetInorderSuccesor(n1) n2 = T2.GetInorderSuccesor(n2) else: if n1.value > n2.value: n2 = T2.GetInorderSuccesor(n2) else: n1 = T1.GetInorderSuccesor(n1) print "This is it"
#!/usr/bin/env python __author__ = "bt3" from binary_search_tree import BST, Node from binary_tree import BT, Node def isBalanced(node, left=0, right=0): if not node: return (left - right) < 2 return isBalanced(node.left, left+1, right) and \ isBalanced(node.right, left, right+1) if __name__ == '__main__': bt = BST() for i in range(1, 10): bt.add(i) assert (isBalanced(bt.root) == True) bt = BT() for i in range(1, 10): bt.add(i) assert (isBalanced(bt.root) == False)
def setUp(self) -> None: self.tree = BST(None)
from binary_search_tree import BST bst = BST(9) bst.insert(3) bst.insert(2) bst.insert(5) bst.insert(4) bst.insert(6) bst.insert(7) bst.insert(9) bst.insert(8) bst.insert(11) bst.insert(13) bst.insert(12) bst.insert(10) bst.insert(15) bst.insert(14) arr = bst.inorder_traverse() Bbst = BST() print(arr) # print(Bbst.get_height()) def create_Bbst(a): n = len(a) if len(a) != 0: if n == 1: Bbst.insert(a[0]) else: mid = int(n / 2) Bbst.insert(a[mid]) create_Bbst(a[:mid])
def find_ancestor2(tree, n1, n2): if not tree: return False if n1 <= tree.item and n2 >= tree.item or (not tree.left and not tree.right): return tree.item if tree.left and (n1 < tree.item and n2 < tree.item): return find_ancestor(tree.left, n1, n2) or tree.item if tree.right and (n1 > tree.item and n2 > tree.item): return find_ancestor(tree.right, n1, n2) or tree.item if __name__ == '__main__': bst = BST() l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4] for i in l: bst.add(i) nodes = bst.preorder_array() print 'Original: ', l print 'Preorder: ', nodes print 'Method 1: ' print 'Ancestor for 3, 11:', find_ancestor(nodes, 3, 11) print 'Method 2: ' print 'Ancestor for 3, 11: ', find_ancestor2(bst.root, 3, 11)
""" source: https://leetcode.com/problems/same-tree/ Given the roots of two binary trees p and q, write a function to check if they are the same or not. Two binary trees are considered the same if they are structurally identical, and the nodes have the same value. """ from binary_search_tree import BST p = BST() p.insert(17) p.insert(12) p.insert(25) p.insert(9) p.insert(21) p.insert(27) q = BST() q.insert(17) q.insert(12) q.insert(25) q.insert(9) q.insert(21) # q.insert(27) def isSameTree(p, q): # algo1 # def fn(p, q):
def setUp(self) -> None: self.root = BST(12) self.empty_root = BST() self.sample = random.sample(range(1000), k=5)