def test_search_with_3_strings(self): # Create a complete binary search tree of 3 items in level-order items = ['B', 'A', 'C'] tree = BinarySearchTree(items) assert tree.search('A') == 'A' assert tree.search('B') == 'B' assert tree.search('C') == 'C' assert tree.search('D') is None
def test_search_with_3_items(self): # Create a complete binary search tree of 3 items in level-order items = [2, 1, 3] tree = BinarySearchTree(items) assert tree.search(1) == 1 assert tree.search(2) == 2 assert tree.search(3) == 3 assert tree.search(4) is None
def test_search_with_7_items(self): # Create a complete binary search tree of 7 items in level-order items = [4, 2, 6, 1, 3, 5, 7] tree = BinarySearchTree(items) # for item in items: # print(item) # assert tree.search(item) == item assert tree.search(8) is None
def test_delete(self): tree = BinarySearchTree([2, 4]) assert tree.height() == 1 tree.delete(4) assert tree.height() == 0 tree.delete(2) assert tree.height() == 0 items = [18, 1, 53, 40, 63] tree.insert(10) tree = BinarySearchTree(items) tree.delete(1) assert tree.search(1) is None tree.delete(10) assert tree.search(10) is None tree.insert(57) tree.insert(98) tree.delete(63) assert tree.search(63) is None
def test_delete_ints(self): tree = BinarySearchTree([6, 4, 7, 3, 1, 20, 34]) assert tree.root.data == 6 assert tree.size == 7 tree.delete(7) assert tree.size == 6 assert tree.search(7) == None assert tree.items_in_order() == [1, 3, 4, 6, 20, 34] tree.delete(20) assert tree.size == 5 assert tree.items_in_order() == [1, 3, 4, 6, 34]
class RouteFinder(object): def __init__(self, file): self.routes = [] with open(file, 'r') as f: contents = f.read().split() for content in contents: split = content.split(',') self.routes.append((split[0], split[1])) self.routes_tree = BinarySearchTree(self.routes) def find_best_route(self, number): return self._find_best_route_recursive(number) def _find_best_route_recursive(self, number): if number == '+': return None else: route = self.routes_tree.search(number) if route is not None: return route else: return self._find_best_route_recursive(number[:-1])
class TreeSet(object): """Class for sets implemented with binary trees""" def __init__(self, items=None): """Initialize a new Set""" self.tree = BinarySearchTree(items) # self.size = self.tree.size def __repr__(self): """Return a string representation of this set""" items = ['({!r})'.format(item) for item in self.tree.items_in_order()] return ', '.join(items) def __iter__(self): """Allow the set to be iterated over (i.e. in for loops)""" return iter([value for value in self.tree.items_level_order()]) def __eq__(self, other): """Allow sets to be compared to other sets""" return self.tree.items_in_order() == other.tree.items_in_order() @property def size(self): """Use tree size property""" return self.tree.size def contains(self, item): """Return a boolean indicating whether item is in this set Best case time complexity: O(1) if item is in the tree root Worst case: O(logn) if item is a leaf """ return self.tree.search(item) is not None def add(self, item): """Add the item to the set if not present Best case time complexity: O(1) if tree is empty Worst case: O(n) if tree is poorly balanced """ if not self.contains(item): self.tree.insert(item) def remove(self, item): """Remove element from this set, if present, or else raise KeyError Best case time complexity: O(1) if item is in the tree root Worst case: O(logn) if item isn't there """ if not self.contains(item): raise KeyError("Item not found") else: self.tree.delete(item) def union(self, other_set): """Return a new set that is the union of this set and other_set Best and worst case time complexity: O(n+m), where n is the size of self, and m is the size of other_set, because every item has to be accounted for """ new_set = TreeSet(self) for item in other_set: new_set.add(item) return new_set def intersection(self, other_set): """Return a new set that is the intersection of this and other_set Best and worst case time complexity: O(m) where m is the size of other_set, because it iterates over the other set. """ new_set = TreeSet() for item in other_set: if self.contains(item): new_set.add(item) return new_set def difference(self, other_set): """Return a new set that is the difference of this set and other_set Best and worst case time complexity: O(n + logm) where n is the size of self, and m is the size of other_set, because it iterates over self and checks if other_set contains the items """ new_set = TreeSet() for item in self: if not other_set.contains(item): new_set.add(item) return new_set def is_subset(self, other_set): """Return a boolean indicating if other_set is a subset of this Best case time complexity: O(1) if other_set is larger than self Worst case: O(m) where m is the size of other_set, as it has to iterate over each element of it """ if other_set.size > self.size: return False for item in other_set: if not self.contains(item): return False return True