def search_tree(path): words_list, words_random = reaf_file(path) tree_1 = LinkedBST() for i in words_list: tree_1.add(i) start = time.time() for i in words_random: search_word = tree_1.find(i) variant_1 = time.time() - start #------------------------------- random.shuffle(words_list) tree_2 = LinkedBST() for i in words_list: tree_2.add(i) start = time.time() for i in words_random: search_word = tree_2.find(i) variant_2 = time.time() - start #------------------------------- tree_2.rebalance() start = time.time() for i in words_random: search_word = tree_2.find(i) variant_3 = time.time() - start return variant_1, variant_2, variant_3
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 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)
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 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 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
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 test_9NodeTree_test(self): t1 = LinkedBST() t1.add("F") t1.add("B") t1.add("A") t1.add("D") t1.add("C") t1.add("E") t1.add("G") t1.add("I") t1.add("H") expectedHeight = 3 self.assertEqual(t1.height(), expectedHeight)
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 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
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 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
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(): 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)
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 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)}")
def test_postorder_traversal_not_levelorder(self): t1 = LinkedBST() t1.add("W") #root t1.add("U") t1.add("T") t1.add("V") t1.add("Y") t1.add("X") t1.add("Z") s1 = "" for node in t1.postorder(): s1 = s1 + node + " " s2 = "W U Y T V X Z " self.assertTrue(s1 != s2)
def test_levelorder_traversal(self): t1 = LinkedBST() t1.add("W") #root t1.add("U") t1.add("T") t1.add("V") t1.add("Y") t1.add("X") t1.add("Z") s1 = "" for node in t1.levelorder(): s1 = s1 + node + " " s2 = "W U Y T V X Z " self.assertEqual(s1, s2)
def test_preorder_traversal_left_to_right(self): t1 = LinkedBST() t1.add("W") #root t1.add("U") t1.add("T") t1.add("V") t1.add("Y") t1.add("X") t1.add("Z") s1 = "" for node in t1.preorder(): s1 = s1 + node + " " s2 = "Z X Y V T U W " self.assertNotEqual(s1, s2)
def test_levelorder_traversal_not_postorder(self): t1 = LinkedBST() t1.add("W") #root t1.add("U") t1.add("T") t1.add("V") t1.add("Y") t1.add("X") t1.add("Z") s1 = "" for node in t1.levelorder(): s1 = s1 + node + " " s2 = "T V U X Z Y W " self.assertNotEqual(s1, s2)
def test_inorder_traversal_not_preorder(self): t1 = LinkedBST() t1.add("W") #root t1.add("U") t1.add("T") t1.add("V") t1.add("Y") t1.add("X") t1.add("Z") s1 = "" for node in t1.inorder(): s1 = s1 + node + " " s2 = "W U T V Y X Z " self.assertNotEqual(s1, s2)
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 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)) for item in tree: print("Predecessor of " + item + ": ", tree.predecessor(item)) print("Successor of " + item + ": ", tree.successor(item)) item = "Q" print("Predecessor of " + item + ": ", tree.predecessor(item)) print("Successor of " + item + ": ", tree.successor(item))
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)
def main(): """ Main function that saves all tests` result into file """ new_file = open("time_research.txt", "w+") random_words = choose_words('words.txt', 10000) f = open('words.txt', 'r') words_last = f.readlines()[:1000] f.close() words = [] for w in words_last: k = w.rstrip() words.append(k) new_file.write("Searching in a list: " + str(find_in_list(words, random_words)) + "\n") word_tree1 = LinkedBST() for w in words: word_tree1.add(w) new_file.write("Searching in a sorted tree: " + str(find_in_tree(word_tree1, random_words)) + "\n") word_tree2 = LinkedBST() for w in words: word_tree2.add(w) word_tree2 = word_tree2.rebalance() new_file.write("Searching in a balanced tree: " + str(find_in_tree(word_tree2, random_words)) + "\n") word_tree3 = LinkedBST() shuffle(words) for w in words: word_tree3.add(w) new_file.write("Searching in a shuffled tree: " + str(find_in_tree(word_tree3, random_words)) + "\n") new_file.close()
from linkedbst import LinkedBST if __name__ == '__main__': tree = LinkedBST() tree.add(5) tree.add(3) tree.add(1) tree.add(4) tree.add(8) tree.add(10) tree.add(12) tree.add(0) tree.add(13) tree.add(14) tree.add(5) tree.add(6) tree.add(7) tree.add(9) tree.add(15) tree.add(4.5) print(tree) print("isBalanced()", tree.isBalanced()) print("height is", tree.height()) print() tree = tree.rebalance() print(tree, "\n") print(tree.successor(5)) print(tree.inorder()) print(tree.range_find(2, 10))
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\nin_order traversal: ", end="") for item in tree.in_order(): print(item, end=" ") # print("\n\npreorder traversal: ", end="") # for item in tree.pre_order(): print(item, end = " ") # print("\n\npostorder traversal: ", end="") # for item in tree.post_order(): print(item, end = " ") # print("\n\nlevelorder traversal: ", end="") # for item in tree.level_order(): 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)) random.shuffle(lyst) tree = LinkedBST(lyst) print("\nAdded ", lyst, "\n" + str(tree)) lyst = [113, 30, 68, 74, 45, 91, 88] # random.shuffle(lyst) tree = LinkedBST(lyst) print(tree, tree.height()) print(tree.is_balanced()) print(tree.range_find(30, 91)) print(tree.successor(113)) print(tree.predecessor(113)) tree.rebalance() print(tree)
else: lst_test1 = timeit.repeat( '{}(lst_words, random_lst)'.format(test_name), 'from __main__ import {}, lst_words, random_lst'.format( test_name), number=100, repeat=5) average_test_list = sum(lst_test1) / len(lst_test1) print(test_name) print(average_test_list) print() if __name__ == '__main__': lst_words, random_lst = read_dictionary("words.txt") lst_words_random = copy.copy(lst_words) random.shuffle(lst_words_random) tree_random = LinkedBST() for word in lst_words_random: tree_random.add(word) tree = LinkedBST() for word in lst_words: tree.add(word) tree_balanced = tree.rebalance() test_all()
def build_tree(file): """Function to build a tree with given elements""" tree = LinkedBST() for i in file: tree.add(i) return tree