class TreeSortedSet(AbstractCollection, AbstractSet): "A tree-based implementation of a sorted set." def __init__(self, sourceCollection=None): self._items = LinkedBST() AbstractCollection.__init__(self, sourceCollection) def __contains__(self, item): return item in self._items def add(self, item): if not item in self: self._items.add(item) self._size += 1 def __iter__(self): return self._items.inorder() def remove(self, item): if not item in self: raise KeyError(str(item) + "not in set.") self._items.remove(item) self._size -= 1 def clear(self): self._items = LinkedBST() self._size = 0
def test_tree_find(data: Tree, items): '''look for items in data and time it''' start = time() for item in items: data.find(item) end = time() return end - start
def computer_logic(self, data): def recurse(tree, field): if self.status(field) == NOTHING: pass elif self.status(field) == COMPUTER: pass elif self.status(field) == FIRST_PLAYER: pass else: pass def making_tree(field): node = BSTNode(field) field1 = copy(field) field2 = copy(field) if self.status(field) == NOTHING: cell = choice(Board.possible_cells(field)) cell2 = choice(Board.possible_cells(field)) field1.turn(cell) field2.turn(cell2) node.left = making_tree(field1) node.right = making_tree(field2) return node field1 = self._field tree = LinkedBST() tree.add(field1) return recurse(field1)
def __init__(self, sourceCollection=None): """Sets the initial state of self, which includes the contents of sourceCollection, if it's present.""" self._items = LinkedBST() AbstractBag.__init__(self, sourceCollection) if not self._items.isBalanced(): self._items.rebalance()
def main(): data = ['R', 'G', 'T', 'F', 'J', 'S', 'W', 'A', 'P', 'Z'] tree = LinkedBST(data) print("Tree prior to rebalance:") print(tree) print("Tree after rebalance:") tree.rebalance() print(tree)
def build_tree(word_list): """ Creating a Binary tree with the words in the given list """ tree = LinkedBST() for word in word_list: tree.add(word) return tree
def make_bst(): """ Make BST from words from words.txt """ lst = find_word("words.txt") bst = LinkedBST() for i in set(lst): bst.add(i) return bst
def construct_tree(dict_lst, balance=False): ''' :param dict_lst: list of words :param balance: True or False of balance :return: tree based on list ''' tree = LinkedBST(dict_lst) if balance: tree.rebalance() return tree
def test_balanced_tree(words): tree = LinkedBST() words_in_tree = copy.deepcopy(words) while words_in_tree: i = len(words_in_tree) // 2 tree.add(words_in_tree[i]) del words_in_tree[i] start = time.time() for i in range(10000): random.choice(words) in tree return time.time() - start
def search_in_bst(words, randomed): ''' Searches 10 000 random chosen words in the dictionary using LinkedBST. :param words:list :param randomed:randomised list :return:int ''' random.shuffle(words) tree = LinkedBST(words) start = time.time() for el in randomed: tree.find(el) end = time.time() return end - start
class Words: def __init__(self): self.tree = LinkedBST() self.words_list = None def read_file(self): # This function reads the file with words. with open('words.txt', "r") as file: self.words_list = file.readlines(100000) for i in random.sample(self.words_list, len(self.words_list)): self.tree.add(i) def random_words(self): # This method selects randomly 10,000 words from the file. random_words1 = random.choice(self.words_list) for numb in range(10001): for items in self.words_list: if items == random_words1: pass def linear_tree_time(self): for numb in range(10001): self.tree.find(self.words_list[ random.randint(0, len(self.words_list) - 1)]) def tree_balanced_time(self): self.tree.rebalance() for i in range(10001): self.tree.find(self.words_list[ random.randint(0, len(self.words_list) - 1)])
def time_search_bst(words, dictionary): ''' Calculates a working time of a search in a binary search tree :param words: list :param dictionary: list :return: float work time ''' curr = time.time() dictionary = random.shuffle(dictionary) tree = LinkedBST(dictionary) for w in words: tree.find(w) return round(time.time() - curr, 3)
def search_in_balanced_bst(words, randomed): ''' Searches 10 000 random chosen words in the dictionary using balanced LinkedBST. :param words:list :param randomed:randomised list :return:int ''' tree = LinkedBST(words) tree.rebalance() start = time.time() for el in randomed: if tree.find(el): continue end = time.time() return end - start
def __init__(self): """ Class initialisation. Setting up variables. """ self.words_lst = list(self.read_file("words.txt")) self.tree = LinkedBST() self.unsorted_tree = LinkedBST() self.timer = 0 for elem in self.words_lst[:990]: self.tree.add(elem) shuffled = random.sample(self.words_lst, 990) for elem in shuffled: self.unsorted_tree.add(elem)
def binary_outorder(random_words, words_lst): """ This function determines how much time is needed to find some number random words using binary tree :param random_words: :param words_lst: :return: """ binar = LinkedBST() for item in words_lst: binar.add(item) new_time = time() i = 0 for item in random_words: if binar.find(item) is not None: i += 1 return time() - new_time
def test_random_tree(words): random.shuffle(words) tree = LinkedBST(words) start = time.time() for i in range(10000): random.choice(words) in tree return time.time() - start
def test_sorted_tree(words): tree = LinkedBST(words) start = time.time() for i in range(10000): random.choice(words) in tree return time.time() - start
def test_inorder_traversal_not_postorder(self): t1 = LinkedBST() t1.add("F") #root t1.add("E") t1.add("D") t1.add("C") t1.add("B") t1.add("A") s1 = "C D E A B F " for node in t1.inorder(): s1 = s1 + node + " " s2 = "C E D F A B " self.assertNotEqual(s1, s2)
class TreeSortedBag(AbstractBag): """A binary search tree-based implementation of a sorted bag.""" # Uses a LinkedBST to contain the bag's items. # The tree is rebalanced after items are added during istantiation. # The iterator uses an inorder traversal to ensure visiting items # in ascending order. # Searches, insertions, and removals are logarithmic on average, # and linear in the worst case. # Constructor def __init__(self, sourceCollection=None): """Sets the initial state of self, which includes the contents of sourceCollection, if it's present.""" self._items = LinkedBST() AbstractBag.__init__(self, sourceCollection) if not self._items.isBalanced(): self._items.rebalance() # Accessor methods def __iter__(self): """Supports iteration over a view of self.""" return self._items.inorder() # Mutator methods def clear(self): """Makes self become empty.""" self._size = 0 self._items.clear() def add(self, item): """Adds item to self.""" self._items.add(item) self._size += 1 def remove(self, item): """Precondition: item is in self. Raises: KeyError if item in not in self. Postcondition: item is removed from self.""" # Check precondition and raise if necessary if not item in self._items: raise KeyError(str(item) + " not in bag") self._items.remove(item) self._size -= 1
def main(): with open("words.txt", encoding="UTF-8", errors="ignore") as f: words = [word.strip() for word in f] bst = LinkedBST() for item in set(words): bst.add(item) test_words = [] for i in range(10 ** 4): test_words.append(choice(words)) print("Start test") print(f"linear_search time = " f"{linear_search(words,test_words)}") print(f"unbalanced_bst_search time = " f"{unbalanced_bst_search(bst,test_words)}") print(f"balanced_bst_search time = " f"{balanced_bst_search(bst,test_words)}")
class TreeSortedDict(AbstractDict): # Uses composition, where the dictionary contains a tree object. # The tree contains items, each of which contains a key and a value. # Each dictionary method calls the corrseponding method on the tree. def __init__(self, sourceCollection = None): self._items = LinkedBST() AbstractDict.__init__(self, sourceCollection) def __contains__(self, key): item = Item(key, None) return item in self._items def add(self, item): if not item in self: self._items.add(item) self._size += 1 def __getitem__(self, key): if not key in self: raise KeyError("Missing" + str(key)) item = Item(key, None) return self._items.find(item).value def __setitem__(self, key, value): item = Item(key, value) if key in self: self._items.replace(item, item) else: self._items.add(item) self._size += 1 def __iter__(self): return iter(map(labmda item: item.key, self._items.inorder())) def pop(self, key): if not key in self: raise KeyError("Missing " + str(key)) item = self._items.remove(Item(key, None)) self._size -= 1 return item.value
def all_test(sorted_words, n=1000): ''' Returns: timeX, де Х означає: a) час пошуку 10000 випадкових слів у впорядкованому за абеткою словнику (пошук у списку слів з використанням методів вбудованого типу list). b) час пошуку 10000 випадкових слів у словнику, який представлений у вигляді бінарного дерева пошуку. Бінарне дерево пошуку будується на основі послідовного додавання в дерево слів зі словника який впорядкований за абеткою. с) час пошуку 10000 випадкових слів у словнику, який представлений у вигляді бінарного дерева пошуку. Бінарне дерево пошуку будується на основі послідовного додавання в дерево слів зі словника який не впорядкований за абеткою (слова у дерево додаються випадковим чином). d) час пошуку 10000 випадкових слів у словнику, який представлений у вигляді збалансованого бінарного дерева пошуку. ''' shuffled_words = sorted_words.copy() shuffle(shuffled_words) test_words = shuffled_words[:n] timeA = test_list_find(sorted_words, test_words) tree = Tree() for word in sorted_words: tree.add(word) timeB = test_tree_find(tree, test_words) tree.clear() for word in shuffled_words: tree.add(word) timeC = test_tree_find(tree, test_words) tree.rebalance() timeD = test_tree_find(tree, test_words) return timeA, timeB, timeC, timeD
class TreeSortedDict(AbstractDict): """Represents a tree-based sorted dictionary.""" # Uses composition, where the dictionary contains a tree object. # The tree contains items, each of which contains a key and a value. # Each dictionary method calls the corrseponding method on the tree. def __init__(self, sourceCollection=None): """Will copy items to the collection from sourceDictionary if it's present.""" self._items = LinkedBST() AbstractDict.__init__(self, sourceCollection) # Accessors def __contains__(self, key): """Returns True if key is in self or False otherwise.""" item = Item(key, None) return item in self._items def __iter__(self): """Serves up the keys in the dictionary.""" return iter(map(lambda item: item.key, self._items.inorder())) def __getitem__(self, key): """Precondition: the key is in the dictionary. Raises: a KeyError if the key is not in the dictionary. Returns the value associated with the key.""" if not key in self: raise KeyError("Missing: " + str(key)) item = Item(key, None) return self._items.find(item).value # Mutators def __setitem__(self, key, value): """If the key is in the dictionary, replaces the old value with the new value. Othwerise, adds the key and value to it.""" item = Item(key, value) if key in self: self._items.replace(item, item) else: self._items.add(item) self._size += 1 def pop(self, key): """Precondition: the key is in the dictionary. Raises: a KeyError if the key is not in the dictionary. Removes the key and returns the associated value if the key in in the dictionary.""" if not key in self: raise KeyError("Missing: " + str(key)) item = self._items.remove(Item(key, None)) self._size -= 1 return item.value
def main(): lst = read_file("words.txt") words = random_words(lst) tree = LinkedBST(words) s1 = time.time() search_list(lst, words) e1 = time.time() s2 = time.time() search_tree(tree, words) e2 = time.time() s3 = time.time() search_bst(tree, words) e3 = time.time() print('Search list:', e1 - s1) print('Search tree:', e2 - s2) print('Search balanced tree:', e3 - s3)
def search_tree(): f = open("words.txt") data = f.readlines() random.shuffle(data) tree = LinkedBST() start = time.time() for word in data: tree.add(word) for i in main(): ind = tree.find(i) simple_tree = time.time() - start tree.rebalance() start = time.time() for i in main(): ind = tree.find(i) rebalanced_tree = time.time() - start return simple_tree, rebalanced_tree
def main(): # this section shows the rebalance() method. lyst = list(range(1, 16)) # lyst = ["A","B","C","D","E","F","G"] random.shuffle(lyst) tree1 = LinkedBST(lyst) print("Original unbalanced BST:") print(tree1) tree1.rebalance() print("BST after rebalance():") print(tree1) # this sections shows the various traversal methods. inorderList = list(tree1.inorder()) print("Inorder", inorderList) preorderList = list(tree1.preorder()) print("Preorder", preorderList) postorderList = list(tree1.postorder()) print("Postorder", postorderList) levelorderList = list(tree1.levelorder()) print("Levelorder", levelorderList)
def search(file): with open(file, 'r') as f: done = f.readlines() for i in range(len(done)): done[i] = done[i].rstrip().lower() words = [] for i in range(10000): words.append(random.choice(done)) words = list(set(words)) tree = LinkedBST(set(done)) def first(): start_time = time.time() for word in words: num = done.index(word) fin_time = time.time() - start_time return fin_time def second(): start_time = time.time() for word in words: tree.find(word) fin_time = time.time() - start_time return fin_time def third(): new_tree = copy.deepcopy(tree) new_tree.rebalance() start_time = time.time() for word in words: new_tree.find(word) fin_time = time.time() - start_time return fin_time print('1 : ', first()) print('2 : ', second()) print('3 : ', third())
def main(): with open('words.txt', ) as words: words = words.readlines() to_find = [] while len(to_find) < 10000: word = random.choice(words) if word not in to_find: to_find.append(word) search_list_test(words, to_find) random.shuffle(words) tree = LinkedBST() for word in words: tree.add(word) search_tree_test(tree, to_find) tree.rebalance() search_tree_test(tree, to_find)
def main(): tree = LinkedBST() print("Adding D B A C F E G") tree.add("D") tree.add("B") tree.add("A") tree.add("C") tree.add("F") tree.add("E") tree.add("G") print("\nString:\n" + str(tree)) print("\nLength:", len(tree)) print("Height:", tree.height()) print("Balanced:", tree.isBalanced()) tree = LinkedBST(range(1, 16)) print("\nAdded 1..15:\n" + str(tree)) print("\nLength:", len(tree)) print("Height:", tree.height()) print("Balanced:", tree.isBalanced()) tree.rebalance() print("\nAfter rebalance:\n" + str(tree)) print("\nLength:", len(tree)) print("Height:", tree.height()) print("Balanced:", tree.isBalanced()) lyst = list(range(1, 16)) import random random.shuffle(lyst) tree = LinkedBST(lyst) print("\nAdded ", lyst, "\n" + str(tree)) print("\nLength:", len(tree)) print("Height:", tree.height()) print("Balanced:", tree.isBalanced())
def main(): tree = LinkedBST() print("Adding D B A C F E G") tree.add("D") tree.add("B") tree.add("A") tree.add("C") tree.add("F") tree.add("E") tree.add("G") print("\nExpect True for A in tree: ", "A" in tree) print("\nString:\n" + str(tree)) clone = LinkedBST(tree) print("\nClone:\n" + str(clone)) print("Expect True for tree == clone: ", tree == clone) print("\nFor loop: ", end="") for item in tree: print(item, end=" ") print("\n\ninorder traversal: ", end="") for item in tree.inorder(): print(item, end = " ") print("\n\npreorder traversal: ", end="") for item in tree.preorder(): print(item, end = " ") print("\n\npostorder traversal: ", end="") for item in tree.postorder(): print(item, end = " ") print("\n\nlevelorder traversal: ", end="") for item in tree.levelorder(): print(item, end = " ") print("\n\nRemoving all items:", end = " ") for item in "ABCDEFG": print(tree.remove(item), end=" ") print("\n\nExpect 0: ", len(tree)) tree = LinkedBST(range(1, 16)) print("\nAdded 1..15:\n" + str(tree)) lyst = list(range(1, 16)) import random random.shuffle(lyst) tree = LinkedBST(lyst) print("\nAdded ", lyst, "\n" + str(tree))
def __init__(self, sourceCollection = None): self._items = LinkedBST() AbstractDict.__init__(self, sourceCollection)