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)
