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)