def rb_file_reader(file): # this function loads file in to red and black tree
rb_tree = RedBlackTree() # stores the red black tree in to variable
for line in file:
word = line.strip('\n').lower()
rb_tree.rbt_insert(word)
file.close()
return rb_tree
def __init__(self):
self.map = RedBlackTree()
logging.basicConfig(
format="%(levelname)-10s %(asctime)s %(filename)s %(lineno)d %(message)s",
level=logging.DEBUG
)
self.log = logging.getLogger(sys.argv[0])
def test_inserting_unsorted_values_should_alter_root(self):
"""Testing the rotate methods"""
rbt = RedBlackTree()
rbt.insert(9)
rbt.insert(11)
rbt.insert(10)
self.assertTrue(rbt.get_root().value == 10)
class RedblackMap(object):
"""An implementation of a hashtable using a BetterMap
backed by a red black tree"""
def __init__(self):
self.map = RedBlackTree()
logging.basicConfig(
format="%(levelname)-10s %(asctime)s %(filename)s %(lineno)d %(message)s",
level=logging.DEBUG
)
self.log = logging.getLogger(sys.argv[0])
def get(self, k):
"""Looks up the key (k) and returns the corresponding value,
or raises KeyError if the key is not found."""
return self.map.search_by_key(k)
def add(self, k, v):
"""Resize the map if necessary and adds the new item."""
kv = KeyVal(k, v)
self.map.insert(kv)
bk_tree = pickle.load(open("bk_tree.p", 'rb'))
print("BK Tree constructed!")
else:
csv_file = "Brooklyn_Public_Library_Catalog.csv"
#Provide a script where you load the dataset
print("Constructing dataset........", end='', flush=True)
dataset = Dataset(csv_file, query_processor)
dataset.load()
print("Dataset Loaded!")
#process it into an efficient binary search tree
print("Constructing RB-Tree...", end='', flush=True)
binary_search_tree = RedBlackTree()
temp_dataset = dataset.get_token_bookids()
for i in range(len(temp_dataset)):
binary_search_tree.insert(temp_dataset[i][0], temp_dataset[i][1])
print("RB-Tree constructed!")
#create a BK-tree
print("Constructing BK-Tree...", end='', flush=True)
bk_tree = BKTree(levenshtein_distance_DP)
english_dictionary_list = dataset.get_dictionary()
for i in range(len(english_dictionary_list)):
bk_tree.insert(english_dictionary_list[i])
print("BK-Tree constructed!")
if CONSTRUCT_DEBUG_MODE:
pickle.dump(dataset, open("dataset.p", 'wb'))
def main():
rb_tree = RedBlackTree()
# корень
node_10_value = Autoservice(10, 'Переделкино', 'Вася Пупкин', 'Омск')
root = Node(value=node_10_value, color=BLACK, parent=None, left=NIL_LEAF, right=NIL_LEAF)
node_10 = root
# левое поддерево
node_5_value = Autoservice(5, 'Сломай меня полностью', 'Иннокентий Пересядько', 'Якутск')
node_5 = Node(value=node_5_value, color=BLACK, parent=root, left=NIL_LEAF, right=NIL_LEAF)
# правое поддерево
node_20_value = Autoservice(20, 'Загони под шины', 'Яков Явенчучечков', 'Ханты-Мансийск')
node_20 = Node(value=node_20_value, color=RED, parent=root, left=NIL_LEAF, right=NIL_LEAF)
node_15_value = Autoservice(15, 'Вест Коуст Кастомс', 'Евакий Иксзибитов', 'Бирюлёво')
node_15 = Node(value=node_15_value, color=BLACK, parent=node_20, left=NIL_LEAF, right=NIL_LEAF)
node_25_value = Autoservice(25, 'Подкуй братуху', 'Каракантанбек Изумнетралитанаев', 'Владивосток')
node_25 = Node(value=node_25_value, color=BLACK, parent=node_20, left=NIL_LEAF, right=NIL_LEAF)
node_20.left = node_15
node_20.right = node_25
node_12_value = Autoservice(12, 'Железный сивый мерин', 'Эщкере Капиталистов', 'Староперуново')
node_12 = Node(value=node_12_value, color=RED, parent=node_15, left=NIL_LEAF, right=NIL_LEAF)
node_17_value = Autoservice(17, 'Вах Какой Машына', 'Джамшут Равшанов', 'Перезауехово')
node_17 = Node(value=node_17_value, color=RED, parent=node_15, left=NIL_LEAF, right=NIL_LEAF)
node_15.left = node_12
node_15.right = node_17
root.left = node_5
root.right = node_20
rb_tree.root = root
node_19_value = Autoservice(19, 'На созвоне & вопросики порешаем & тоси-боси', 'Капитан Глазозоркость', 'Готтэм')
print('Before:\n' + '-' * 80)
for i in list(rb_tree):
print(i)
rb_tree.add(node_19_value)
"""
____10B____ ____10B____
5B __20R__ 5B __20R__
__15B__ 25B -- КРАСИМ В --> __15R__ 25B
12R 17R 12B 17B
добавляем-->19R 19R
Общее
направление: ____10B____
LR=>RL 5B ___15R___
правая ротация 12B __20R__
17B 25B
19R
_____15B_____
Левая ротация к 10R __20R__
5B 12B 17B 25B
19R
"""
print('After:\n' + '-' * 80)
for i in list(rb_tree):
print(i)
print('Trying to find \n{}\n in tree: \n{}'.format(node_17_value, rb_tree.find_node(node_17_value)))
print()
print('Is \n{}\n in tree? {}'.format(node_17_value, rb_tree.contains(node_17_value)))
print('Tree root has children: {}'.format(rb_tree.root.has_children()))
print('Tree root has {} children'.format(rb_tree.root.count_children()))
values = [
node_10_value,
node_5_value,
node_20_value,
node_15_value,
node_25_value,
node_12_value,
node_17_value
]
print('-' * 80)
rb_tree = RedBlackTree()
for value in values:
rb_tree.add(value)
for i in list(rb_tree):
print(i)
print('-' * 80)
print('-' * 80)
for value in values:
for i in list(rb_tree):
print(i)
rb_tree.remove(value)
print('-' * 80)
def test_redblacktree():
test_passed = True
test_database = pickle.load( open( 'testdatabase.p', 'rb' ) )
test_database = test_database['redblacktree']
keys = test_database['keys']
result = test_database['result']
RBT = RedBlackTree()
for key in keys:
RBT.insert(key,None)
nodes = []
nodes.append(RBT._root)
nodes_checked = 0
while len(nodes) > 0:
node = nodes.pop()
if not node is None:
nodes_checked += 1
nodes.append(node._left)
nodes.append(node._right)
target = result[node._key]
if node._parent is None:
if not target['p'] is None:
test_passed = False
else:
if not node._parent._key == target['p']:
test_passed = False
if node._left is None:
if not target['l'] is None:
test_passed = False
else:
if not node._left._key == target['l']:
test_passed = False
if node._right is None:
if not target['r'] is None:
test_passed = False
else:
if not node._right._key == target['r']:
test_passed = False
if not node._black == target['b']:
test_passed = False
RBT = RedBlackTree()
RBT.insert('1','a')
RBT.insert('1','b')
RBT.insert('1','c')
if len(RBT.get('1')) != 3:
test_passed = False
return test_passed
def test_bfs(func, size):
rbt = RedBlackTree()
for i in range(1, size):
rbt.insert(random_string(14))
this_func = eval(func)
this_func(rbt.get_root(), visit_node)
def test_find_should_return_none_for_nonexistent_value(self):
search_value = 5
rbt = RedBlackTree()
for x in [7, 11, 19, 10]:
rbt.insert(x)
self.assertTrue(rbt.search(search_value) is None)
def test_find_should_work_for_existing_value(self):
search_value = 9
rbt = RedBlackTree()
for x in [7, 11, 19, 10, search_value]:
rbt.insert(x)
self.assertTrue(rbt.search(search_value))
def test_node_inserted_should_be_red(self):
rbt = RedBlackTree()
rbt.insert(9)
rbt.insert(11)
self.assertTrue(rbt.get_root().get_right().is_red())
def test_inserting_greater_value_should_create_right_node(self):
rbt = RedBlackTree()
rbt.insert(9)
rbt.insert(11)
self.assertTrue(rbt.get_root().get_right().value == 11)
def test_inserting_lesser_value_should_create_left_node(self):
rbt = RedBlackTree()
rbt.insert(5)
rbt.insert(4)
self.assertTrue(rbt.get_root().get_left().value == 4)
def test_first_node_should_be_black(self):
rbt = RedBlackTree()
rbt.insert(5)
rbt.insert(4)
self.assertTrue(rbt.get_root().is_black())
from redblacktree import RedBlackTree
import os
def print_tree(node):
"""Ascending order"""
if node.value == None:
return
print_tree(node.right)
print(node)
print_tree(node.left)
try:
tree = RedBlackTree()
except:
print('erro')
number = 1
while (number):
print(
"Digite:\n1- Para adicionar a árvore.\n2- Para remover da árvore\n0- Para sair\n"
)
number = int(input())
if number == 1:
print("Digite o valor que queira adicionar.")
value = int(input())
tree.add(value)
root = tree.root
print_tree(root)
elif number == 2:
def getDictTree(tree, node):
children = []
if node.left is not tree.nil or node.right is not tree.nil:
for child in [node.left, node.right]:
if child is not tree.nil:
children.append(getDictTree(tree, child))
else:
children.append({"key": "none", "children": []})
nodedict = {}
if hasattr(node, "colour"):
nodedict["colour"] = node.colour
nodedict["key"] = node.key
nodedict["children"] = children
return nodedict
if __name__ == "__main__":
N = 300
trees = {
"bintree": BinaryTree(),
"redblacktree": RedBlackTree(),
"avltree": AvlTree()
}
run(trees, 150)
import json
for name, tree in trees.items():
f = open('/Users/tims/workspace/datavis/data/' + name + '.json', 'w')
f.write(json.dumps(getDictTree(tree, tree.root), indent=True))
f.close()
