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
