def AVL_read_file(): #method to read file
word_file = open("words.txt", "r")
avl = AVLTree()
for line in word_file:
word = line.replace("\n", "")
avl.AVL_insert(word)
return avl
def test_search(self):
niveau = Niveau()
avl_tree = AVLTree()
root = avl_tree.insert(None, 'Apeldoorn', 0)
new_root = avl_tree.insert(root, 'Arnhem', 1)
avl_tree.root = new_root
niveau.variabelen = avl_tree
expected = [1]
variables = 'Arnhem'
result = niveau.search(variables)
self.assertEqual(expected, result)
def test_left_rotate(self):
expected = self.create_node(12, 2)
expected.left = self.create_node(10, 1)
expected.left.left = self.create_node(9, 2)
expected.left.right = self.create_node(11, 2)
expected.right = self.create_node(13, 2)
expectedValues = self.get_values_in_order(expected)
root = self.create_node(10, 1)
root.right = self.create_node(12, 2)
root.right.left = self.create_node(11, 2)
root.right.right = self.create_node(13, 2)
root.left = self.create_node(9, 2)
avl_tree = AVLTree()
k2 = avl_tree.left_rotate(root)
resultValues = self.get_values_in_order(k2)
self.assertEqual(resultValues, expectedValues)
def create_tree(self, keys, initial_number):
avl_tree = AVLTree()
avl_tree.root = avl_tree.insert(None, initial_number, initial_number)
for key in keys:
if key == initial_number:
continue
tmp = avl_tree.insert(avl_tree.root, key, key)
avl_tree.root = tmp
return avl_tree
def user_tree(user_input):
if user_input is "A" or "RB":
if user_input is "A":
print("Generating tree...")
english_words = AVLTree()
with open("words.txt") as f:
for avl_line in f:
english_words.insert(Node(
avl_line.rstrip('\n'))) ##Appends into AVL tree
return english_words
elif user_input is "RB":
print("Generating tree...")
english_words = RedBlackTree()
with open("words.txt") as m:
for rb_line in m:
english_words.insert(RBTNode(
rb_line.rstrip('\n'))) ##Appends into RB tree
return english_words
else:
print("Invalid Argument")
return None
return english_words
def __init__(self):
self.indexes = []
self.filtered_criteria = []
self.variabelen = AVLTree()
self.name = ""
class Niveau(object):
def __init__(self):
self.indexes = []
self.filtered_criteria = []
self.variabelen = AVLTree()
self.name = ""
def create_niveau(self, content, niveau):
self.name = niveau
column_number = self.get_column_index(content)
variabelen = self.get_variables(column_number, content)
increment = 0
for variable in variabelen:
self.add(variable, increment)
increment += 1
self.set_filter_criteria(column_number, content)
def filter(self, variabelen):
self.indexes = []
for variable in variabelen:
indexes = self.search(variable)
self.add_indexes_to_filtered_list(indexes)
return self.indexes
def get_variables(self, column_number, content):
variabelen = []
var = iter(content)
next(var)
for row in var:
if row is None:
continue
variabelen.append(row[column_number])
return variabelen
def get_column_index(self, content):
column_number = 0
for column in content[column_number]:
if column == self.name:
break
column_number += 1
return column_number
def add(self, variable, increment):
if self.variabelen.root is None:
root = self.variabelen.insert(None, variable, increment)
self.variabelen.root = root
return
root = self.variabelen.root
root = self.variabelen.insert(root, variable, increment)
self.variabelen.root = root
def set_filter_criteria(self, column_number, content):
var = iter(content)
next(var)
for row in var:
if row[column_number] is None:
continue
if row[column_number] not in self.filtered_criteria:
self.filtered_criteria.append(row[column_number])
def search(self, variable):
index = self.variabelen.find(variable).value
return index
def add_indexes_to_filtered_list(self, indexes):
for index in indexes:
self.indexes.append(index)
def search_time(dic, d, Tree, orderedList=False):
"""
Measures the time it takes to search word in the given list
:param dic: the word (value of the node) to be searched
:param d: the word list, it can be random or ordered list
:param Tree: a tree object (can be BinarySearchTree or AVLTree)
:param orderedList: a flag to indicate whether wList is an ordered list or not, by default is not
:return: measured time from start to finish
"""
size = len(d)
if Tree == "AVLTree":
tree = AVLTree()
elif Tree == "BinarySearchTree":
tree = BinarySearchTree()
else:
print("Unsupported tree type: {}".format(Tree))
return 0
if orderedList:
list_str = 'ordered list'
else:
list_str = 'random list'
try:
for i in range(size):
tree[i] = d[i]
except RecursionError as e:
print('Exception caught while building the {} with size {}: {}'.format(
Tree, size, e))
tree_dic.write(
'Error in building {}, size {:5d}, {}, word: "{}"\n'.format(
Tree, size, list_str, dic))
return 0
print('{}, height of tree: {}, size of tree: {}'.format(
Tree, tree.height(tree.root), len(tree)))
tree.set_balanceFactor()
start = time.clock()
try:
if orderedList:
dKey = tree.search_ordered_list(dic)
else:
dKey = tree.search_random_list(dic)
if dKey:
print('yes, {} is in tree, found at key {}'.format(dic, dKey))
else:
print("no, {} is not found in tree".format(dic))
except RecursionError as e:
print('Exception caught during search with size {}: {}'.format(
size, e))
tree_dic.write(
'Error during search {}, size {:5d}, {}, word: "{}"\n'.format(
Tree, size, list_str, dic))
return 0
stop = time.clock()
d_time = stop - start
print('Searching for word "{}" in size {} tree took {:5f} seconds'.format(
dic, size, d_time))
if dKey:
word_str = 'word in tree'
else:
word_str = 'word not in tree'
tree_dic.write(
'\nSearch time: {:5f} seconds \n{}: size {}\n{}, word: "{}"\n'.format(
d_time, list_str, size, word_str, dic))
sizes = d_sizes
this_size = sizes.index(size)
if this_size < len(sizes) - 1:
nextSize = sizes[this_size + 1]
predict_bigO_time(size, d_time, nextSize)
return d_time