def root_insert(self, segment, bottom_segment=None):
if self.current_state_tree is None:
self.current_state_tree = RedBlackTree()
segment.key = segment.update_key(self.x)
if bottom_segment is not None:
bottom_segment.key = bottom_segment.update_key(self.x)
self.intersections_to_delete.append((segment, bottom_segment))
self.current_state_tree.insert(segment, bottom_segment, self.x)
def user_in(user_input, words_file):
# print(user_input == "AVL") #USED TO DEBUG
if user_input == 'AVL':
AVL_list = read_file(words_file)
english_words = AVLTree.AVLTree()
for i in AVL_list:
# a = i.split()
english_words.insert(AVLTree.Node(i))
# print_ascend (english_words.root) #used to debug
return english_words
elif user_input == 'RBT':
RBT_list = read_file(words_file)
english_words = RedBlackTree.RedBlackTree()
for i in RBT_list:
# a = i.split
english_words.insert(i)
# print_ascend (english_words.root) #used to debug
return english_words
else:
print ('Invalid entry')
print('Must be either AVL or RBT')
def loadRedBlackTree(words):
tree = rbt.RedBlackTree()
for key, word in words.items():
tree.insert(word, compWords)
return tree
def __init__(self, list, satellite = None):
list2 = []
if satellite == None:
for i in list:
list2.append([i, [0]])
else:
for i in list:
list2.append([i[0],[0,[i[1]]]])
self.satellite = satellite
self.null_node = RedBlackTree.Node(None)
self.null_node.color = "BLACK"
self.null_node.satellite_data = [0]
self.root = self.null_node
for i in list2:
self.insert(i[0],i[1])
def insert(self, value, satellite_data):
"""insert an element and remain the properties of red black tree"""
insert_node = RedBlackTree.Node(value,satellite_data)
current_node = self.root
last_node = None
left_right = 0 #to indicate which child the new node should insert in
while current_node != self.null_node:
if value <= current_node.key:
last_node = current_node
current_node = current_node.left
left_right = 0
else:
last_node = current_node
current_node = current_node.right
left_right = 1
if last_node == None:
self.root = insert_node
insert_node.parent = self.null_node
insert_node.left = self.null_node
insert_node.right = self.null_node
else:
if left_right == 0:
last_node.left = insert_node
insert_node.parent = last_node
insert_node.left = self.null_node
insert_node.right = self.null_node
else:
last_node.right = insert_node
insert_node.parent = last_node
insert_node.right = self.null_node
insert_node.left = self.null_node
original_insert = insert_node
while insert_node != self.null_node:
insert_node.satellite_data[0] += 1
insert_node = insert_node.parent
self.insert_fixup(original_insert)
#################################################################
# Author: Yuhan Huang
# Date: 2019.12.30
# Github homepage: https://github.com/Krokette29
#################################################################
import random
from RedBlackTree import *
# test for randomly insertion and deletion
treeRBT = RedBlackTree()
num_nodes = 20
# insertion
key_list = [random.randint(1000, 2000) for i in range(num_nodes)]
value_list = [random.randint(0, 100) for i in range(1, num_nodes + 1)]
random.shuffle(key_list)
print("key list: {}".format(key_list))
print("value list: {}".format(value_list))
for i in range(num_nodes):
treeRBT.insert(key_list[i], value_list[i])
treeRBT.check_all()
treeRBT.show_paths()
# show all information of all nodes
# for i in treeRBT:
# i.show_info()
# deletion
delete_list = [i for i in range(num_nodes)]
parent = tree.getParent(problem[0]) if problem[0] > 0 else (
problem[0] == 0)
print('Found problem at', problem,
'' if parent else 'but missing expected parent')
tree.printTree()
def printProgress(trial, trials, satisfied):
print(('{} of {} trial{} complete, {:3.1f}% with '
'{} satisfying all rules, {:3.1f}%').format(
trial, trials, '' if trials == 1 else 's', 100 * trial / trials,
satisfied, 100 * satisfied / trial))
if __name__ == '__main__':
# random.seed(3.14159) # Use fixed seed for testing consistency
tree = RedBlackTree(title='Red-Black Tree Tester')
values = [int(arg) for arg in sys.argv[1:] if arg.isdigit()
] if len(sys.argv) > 1 else [i for i in range(1, 96, 3)]
rulesSatisfied = 0
nNodes = 2 ** tree.MAX_LEVEL - 1
trials = 1000
for trial in range(trials):
tree.emptyAndFill(nNodes)
satisfied = len(tree.canvas.itemconfigure(tree.measures[3],
'text')[-1]) > 0
height = tree.getHeight(0)
tree.startAnimations()
if satisfied:
rulesSatisfied += 1
print('Trial', trial, 'satisfied the rules')
from RedBlackTree import *
from Candidato import *
from random import randint
import re
eleitores = RedBlackTree()
titulosUsados = BinaryTree()
candidatos = {}
def addTitulo(numero):
if numero.isdigit():
if len(numero) == 4:
numero = int(numero)
if eleitores.search(numero) == None:
eleitores.insert(numero)
print("Título adicionado com sucesso!")
return True
else:
print("Título já cadastrado!")
return False
else:
print("O título deve ser composto de 4 digitos numéricos!")
return False
else:
print("O título deve conter apenas números!")
return False
def removerTitulo(numero):
if numero.isdigit():
def setUp(self):
self.rbt = RedBlackTree()
self.rbt.insertValue(10)
class Broom:
epsilon = 10**(-10)
def __init__(self):
self.x = 0
self.rb_tree = None
self.heap = None
self.intersections_tree = None
self.intersections_array = []
self.intersections_tmp = []
def intersections_insert(self, point, segment1, segment2):
if self.intersections_tree is None:
self.intersections_tree = DuplicateRedBlackTree()
if point is not None and self.intersections_tree.find_node(point) is None:
self.intersections_tree.insert(point)
self.heap_insert_intersection(point, segment1, segment2)
self.intersections_array.append(point)
self.intersections_tmp.append((point, segment1, segment2))
def intersections_in_order(self):
self.intersections_tree.in_order()
def intersections_find(self, point):
return self.intersections_tree.find_node(point)
def heap_insert_point(self, point, segment):
if segment.p == point:
state = 0
else:
state = 1
if self.heap is None:
self.heap = []
node = HeapNode(point, segment, state)
heappush(self.heap, node)
def heap_insert_intersection(self, point, segment1, segment2):
if self.heap is None:
self.heap = []
node = HeapNode(point, segment1, 2, segment2)
heappush(self.heap, node)
def heap_take_min(self):
return heappop(self.heap)
def root_insert(self, segment, bottom_segment=None):
if self.rb_tree is None:
self.rb_tree = RedBlackTree()
self.rb_tree.insert(segment, bottom_segment, x=self.x)
def root_delete(self, segment, state=None):
if state is None:
self.rb_tree.delete(segment, x=self.x)
elif state == 2:
self.rb_tree.delete(segment, x=self.x)
def root_in_order(self):
self.rb_tree.in_order()
def root_find(self, segment):
if self.rb_tree is None:
return None
segment.key = segment.update_key(self.x)
return self.rb_tree.find_node(segment.key, x=self.x)
def root_successor(self, segment):
segment.key = segment.update_key(self.x)
curr_node = self.rb_tree.find_node(segment.key, x=self.x)
if curr_node.bottom_segment is not None and curr_node.bottom_segment == segment:
return curr_node.segment
else:
succ_node = self.rb_tree.successor(curr_node)
if succ_node is None:
return None
return succ_node.bottom_segment if succ_node.bottom_segment is not None else succ_node.segment
def root_predecessor(self, segment):
segment.key = segment.update_key(self.x)
curr_node = self.rb_tree.find_node(segment.key, x=self.x)
if curr_node.bottom_segment is not None and curr_node.segment == segment:
return curr_node.bottom_segment
else:
pred_node = self.rb_tree.predecessor(curr_node)
if pred_node is None:
return None
return pred_node.segment
import RedBlackTree as RBT
temp = RBT.RedBlackTree()
temp.put(4, "Am")
temp.put(1, "Hello")
temp.put(2, "World")
temp.put(3, "I")
temp.put(5, "Your")
temp.put(6, "Creator")
print(
temp.get(1) + " " + temp.get(2) + ", " + temp.get(3) + " " + temp.get(4) +
" " + temp.get(5) + " " + temp.get(6) + ".")
except:
tree.insert(word,embedding_array)
line = f.readline()
f.close()
#Main method stars here. User is asked the type of Tree to use and methods are called for implementation
while True:
_input = input("For Red-Black Tree type 0" + "\n" + "For AVL Tree type 1" + "\n" + "Your selection: ")
if _input is not '0' and _input is not '1':
print("Invalid, type 0 or 1" )
continue
else:
break
if _input is "0": #Red-Black Tree
tree = RedBlackTree()
read_file()
print("RedBlack Tree has "+ str(len(tree)) + ' nodes')
print('and')
print("It's height is " + str(tree._height()))
output_file = open("RedBlack_tree.txt", "w+", encoding = 'utf-8')
tree._write()
output_file.close()
while True:
_inputuser = input("Please enter the depth of nodes you would like printed to file: ")
# Checks if the input is valid for the tree.
if int(_inputuser) >= int(tree._height()) or int(_inputuser) < 0:
print("Depth is not valid, please choose another depth size" )
continue
def __init__(self, testalgo=False):
self.testalgorithms = testalgo
self.rb = RedBlackTree()
class RedBlackTreeTests:
def __init__(self, testalgo=False):
self.testalgorithms = testalgo
self.rb = RedBlackTree()
def run(self):
if self.testalgorithms:
self.rb.printTree() # should be empty
for num in [5,10,7,6, 7, 8]:
self.rb.insert(num)
self.rb.printTree() # should now have [5,6,7,8,10]
# should print "7 is in the list"
if self.rb.contains(7):
print "7 is in the list"
else:
print "7 is not in the list"
# should print "-10 not in the list"
if self.rb.contains(-10):
print "-10 is in the list"
else:
print "-10 not in the list"
# should print [5,6,7,8,10]
self.rb.printTree()
# should delete 7.
self.rb.delete(7)
# should print "7 has been succesfully deleted"
if not self.rb.contains(7):
print "7 has been succesfully deleted"
# should print [5,6,8,10]
self.rb.printTree()
# should delete 5
self.rb.delete(5)
self.rb.delete(20)
# should print [6,8,10]
self.rb.printTree()
# should delete 8
self.rb.delete(100)
self.rb.delete(5)
self.rb.delete(8)
# should print [6,10]
self.rb.printTree()
# should delete [6, 10]
self.rb.delete(6)
self.rb.delete(8)
self.rb.delete(10)
self.rb.delete(-1)
# should print [] (empty)
self.rb.printTree()
# should print False
print self.rb.contains(8)
def test_left_rotate():
print("Test left rotate")
rb = RedBlackTree(5)
left = RedBlackTree(3)
right = RedBlackTree(7)
rb.addLeftTree(left)
rb.addRightTree(right)
left_left = RedBlackTree(2)
left_right = RedBlackTree(4)
left.addLeftTree(left_left)
left.addRightTree(left_right)
rb.left_rotate()
assert rb.getParent() == left
assert rb.getRightTree() == right
assert rb.getLeftTree() == left_right
assert rb.getParent().getLeftTree() == left_left
assert rb.getParent().getParent() == None
assert rb.getRightTree().getLeftTree() == None
assert rb.getRightTree().getRightTree() == None
assert rb.getLeftTree().getRightTree() == None
assert rb.getLeftTree().getLeftTree() == None
assert rb.getParent().getLeftTree().getRightTree() == None
assert rb.getParent().getLeftTree().getLeftTree() == None
rb1 = RedBlackTree(5)
right = RedBlackTree(7)
rb1.addRightTree(right)
rb1.left_rotate()
assert rb1.getParent() == None
assert rb1.getRightTree() == right
assert rb1.getLeftTree() == None
parent = RedBlackTree(10)
parent.binaryInsert(24)
parent.binaryInsert(3)
parent.binaryInsert(29)
parent.binaryInsert(16)
parent.binaryInsert(12)
parent.binaryInsert(17)
other_center = parent.getLeftTree()
central = parent.getRightTree()
left = central.getLeftTree()
right = central.getRightTree()
left_right = left.getRightTree()
left_left = left.getLeftTree()
assert parent.getValue() == 10
assert other_center.getValue() == 3
assert central.getValue() == 24
assert left.getValue() == 16
assert right.getValue() == 29
assert left_right.getValue() == 17
assert left_left.getValue() == 12
central.left_rotate()
assert central.getRightTree() == right
assert central.getLeftTree() == left_right
assert central.getParent() == left
assert left.getLeftTree() == left_left
assert left.getParent() == parent
assert parent.getRightTree() == left
assert left.getRightTree() == central
assert right.getParent() == central
assert left_right.getParent() == central
assert left_left.getParent() == left
assert parent.getParent() == None
assert parent.getLeftTree() == other_center
assert other_center.getParent() == parent
print("pass left rotate")
def root_insert(self, segment, bottom_segment=None):
if self.rb_tree is None:
self.rb_tree = RedBlackTree()
self.rb_tree.insert(segment, bottom_segment, x=self.x)
def test_tree():
print("test tree initialization")
rb = RedBlackTree(0)
assert rb.getValue() == 0
left = RedBlackTree(1)
left.getValue() == 1
rb.addLeftTree(left)
assert left.getParent() == rb
assert rb.getValue() == 0
assert rb.leftTree == left
right = RedBlackTree(-1)
right.getValue() == -1
rb.addRightTree(right)
assert rb.rightTree == right
assert rb.getValue() == 0
assert right.getParent() == rb
right.getValue() == -1
left.getValue() == 1
rb = RedBlackTree(10)
rb.binaryInsert(7)
assert rb.getLeftTree().getValue() == 7
rb.binaryInsert(12)
assert rb.getRightTree().getValue() == 12
rb.binaryInsert(14)
assert rb.getRightTree().getRightTree().getValue() == 14
print("pass tree initialization")
from Point import *
from RedBlackTree import *
rb_tree = RedBlackTree()
p1 = Point(1, 2)
p2 = Point(1, 4)
rb_tree.add(p1)
rb_tree.add(p2)
for node in rb_tree:
print(node)
class RedBlackTreeTest(unittest.TestCase):
def setUp(self):
self.rbt = RedBlackTree()
self.rbt.insertValue(10)
def tearDown(self):
del self.rbt
def test_RBTreeGen(self):
self.assertTrue(self.rbt.root is not None)
def test_RBTreeInsertNode(self):
self.assertEqual(10, self.rbt.root.value)
def test_RBTChildNodeInsert(self):
self.rbt.insertValue(20)
self.assertEqual(20, self.rbt.getNode(20).value)
def test_RootIsBlack(self):
self.assertTrue(self.rbt.root.isBlack())
def test_printingRBT(self):
self.rbt.insertValue(20)
self.rbt.insertValue(30)
self.rbt.insertValue(40)
self.rbt.print()
self.assertTrue(True)
def test_balancing(self):
self.rbt.insertValue(20)
self.rbt.insertValue(30)
self.rbt.insertValue(40)
self.rbt.insertValue(50)
self.assertEqual(20, self.rbt.root.value)
