def dijkstra(aGraph, start): #print("Dijkstra's shortest path") # Define como zero a distancia para o ponto inicial start.set_distance(0) # Inicializa a pripority queu unvisited_queue = avl.AVL() for v in aGraph: unvisited_queue.insert([v.get_distance(),v.get_id(),v]) while unvisited_queue.root.height != 0: #Este loop será feito uma vez para cada vértice do Grafo - O(n) # Pega o vertice com a menor distancia da priority queu # Pops a vertex with the smallest distance # O(n) - percorre o vetor unvisited_queue inteiro por lista - O(n) no pior caso #print("elementos na queue: %i" %len(unvisited_queue)) #uv = heapq.heappop(unvisited_queue) distancia_minima = sys.maxsize uv = [] node = [] node = unvisited_queue.delete_min() uv = node.vertex if uv == None: break current = uv current.set_visited() modify = False #Para todo vértice na lista de adjacencia do vertice atual: - for next in current.adjacent: # este for leva no máximo # Pula caso já tenha sido visitado if next.visited: continue new_dist = current.get_distance() + current.get_weight(next) if new_dist < next.get_distance(): next.set_distance(new_dist) next.set_previous(current) modify = True unvisited_queue = avl.AVL() for v in aGraph: if v.get_visited() == False: unvisited_queue.insert([v.get_distance(),v.get_id(),v]) print(unvisited_queue)
def get_avl_tree(file): english_words = avl.AVL() with open(file) as f: for curr_line in f: curr_line = curr_line.replace('\n', '') english_words.insert(curr_line) return english_words
def __insertAVL(x, A): if A == None: return (avl.AVL(x, None, None, 0), True) elif x == A.key: return (A, False) elif x < A.key: (A.left, dh) = __insertAVL( x, A.left ) # Recursive call, everything below in this branch is postorder if not dh: return (A, False) else: A.bal += 1 # When here, it means there has been a height change in left subtree if A.bal == 2: # Only case when rotation is useful if A.left.bal == 1: A = rr(A) else: A = lrr(A) return (A, A.bal == 1) # Only case when height has changed else: # x > A.key (A.right, dh) = __insertAVL(x, A.right) if not dh: return (A, False) else: A.bal -= 1 if A.bal == -2: if A.right.bal == -1: A = lr(A) else: A = rlr(A) return (A, A.bal == -1)
def test_avl_insert(self): tree = avl.AVL() tree.insert('b', 'b_val') self.assertEqual(tree.root.value, 'b_val') tree.insert('c', 'c_val') self.assertEqual(tree.root.right.key, 'c') tree.insert('a', 'a_val') self.assertEqual(tree.root.left.value, 'a_val')
def __to_avl(B): if B == None: return None, -1 else: A = avl.AVL(B.key, None, None, 0) A.left, height_left = __to_avl(B.left) A.right, height_right = __to_avl(B.right) A.bal = height_left - height_right return A, 1 + max(height_left, height_right)
def __init__(self, mode): ''' Select BST mode by passing "bst" as argument; otherwise select AVL mode. ''' if mode == "bst": logging.info("running in BST mode") self._tree = bst.BST() else: logging.info("running in AVL mode") self._tree = avl.AVL()
def test1(self): tree = avl.AVL() tree.insert(8) tree.insert(6) tree.insert(7) tree.insert(5) tree.insert(3) tree.insert(0) tree.insert(9) result = tree.find_min() self.assertEqual(result.key, 0)
def test_avl_search(self): tree = avl.AVL() tree.insert('b', 'b_val') tree.insert('c', 'c_val') tree.insert('a', 'a_val') search_a = tree.search('a') self.assertEqual(search_a.value, 'a_val') search_a = tree.search('b') self.assertEqual(search_a.value, 'b_val') search_a = tree.search('c') self.assertEqual(search_a.value, 'c_val')
def test3(self): tree = avl.AVL() tree.insert(8) tree.insert(6) tree.insert(7) tree.insert(5) tree.insert(3) tree.insert(0) tree.insert(9) tree.delete(0) tree.delete(3) tree.delete(8) result = tree.__str__().split() wanted = ['7.', '/', '\\', '5', '9', '/\\', '/\\', '6', '/\\'] self.assertEqual(result, wanted)
def test_avl_searches(self): """test if the avl tree searchs works for a randomly chosen key/value pair """ f = open("rand.txt", "r") lines = f.readlines() result = [] for x in lines: result.append(x.rstrip().split('\t')) f.close() choice = random.choice(result) tree = avl.AVL() tree.insert(choice[1]) g = tree.find(choice[1]) self.assertNotEqual(g, choice[1])
def dijkstra(G, s): #Inicialização for node in G.nodes(): G.node[node]['d'] = sys.maxsize G.node[node]['py'] = None G.node[s]['d'] = 0 S = [] #Guarda o caminho mais curto Q = avl.AVL() for node in G.nodes(): Q.insert([G.node[node]['d'], node, node]) while Q.root != None: tree_node = Q.delete_min() u = tree_node.label S.append(u) print(u) #print(G.neighbors(u)) for v in G.neighbors(u): if G.node[v]['d'] > G.node[u]['d'] + G.edge[u][v]['weight']: #Localiza vértice a ser atualizado node = Q.find([G.node[v]['d'], v]) #remove vertice desatualizado if node != None: Q.remove(node) #Atualiza distância do vertíce G.node[v]['d'] = G.node[u]['d'] + G.edge[u][v]['weight'] Q.insert([G.node[v]['d'], v, v]) else: G.node[v]['d'] = G.node[u]['d'] + G.edge[u][v]['weight'] G.node[v]['py'] = u return S
# Jonpierre Grajales # Project 1 Part 2 import node as node import genarray as gen import bst as bstt import avl as avlt from datetime import datetime avl = avlt.AVL(None) bst = bstt.BST(None) array = gen.getRandomArray(10000) print("RECURSIVE RUNNING...") for val in array: avl.insertIter(val) bst.insertRec(val) print("RECURSIVE DONE!") avl = avlt.AVL(None) bst = bstt.BST(None) array = gen.getRandomArray(10000) print("ITERATIVE RUNNING...") for val in array: avl.insertIter(val) bst.insertIter(val) print("ITERATIVE DONE!")
non_result = [] for x in lines: non_result.append(x.rstrip().split('\t')) ff.close() """ ########## binary tree ########## """ # initializing binary tree BT_tree = None for num in result: BT_tree = bt.add(BT_tree, num[0], value=num[1]) """ ########## AVL tree ########## """ # initializing avl tree AVL_tree = avl.AVL() for num in result: AVL_tree.insert(num[1]) """ ########## hash table ########## """ Table = ht.ChainedHash(10000, hf.h_rolling) for num in result: Table.add(num[0], num[1]) """ ########## benchmarking ########## """ norm_time = np.zeros((3, len(range(0, N)))) non_time = np.zeros((3, len(range(0, N)))) insert_time = np.zeros((3, len(range(0, N))))
for i in range(0, 100): choice = random.choice(result) # choosing rand from file key = choice[0] # extracting key val = bt.search(Tree, key) t2 = time.time() print('Insertion time ' + str(t1-t0)) print('Search time ' + str(t2-t1)) """ ########## AVL tree ########## """ if args.struc == 'AVL': # initializing avl tree tree = avl.AVL() # print(tree) t3 = time.time() for num in result: tree.insert(num[1]) # print() # print(tree) t4 = time.time() print("Insert time " + str(t4-t3)) t5 = time.time() for i in range(0, 100): choice = random.choice(result) # choosing rand from file g = tree.find(choice[1])
import avl import pickle from typing import Any mBBDD = avl.AVL() #Crea una base de datos. (CREATE) def createDatabase(database: str) -> int: try: if not database.isidentifier(): raise Exception() res = mBBDD.agregar(database) if res == 0: grabaBD() return res #0 operación exitosa, 1 error en la operación, 2 base de datos existente except: return 1 #Error en la operación #Renombra la base de datos databaseOld por databaseNew. (UPDATE) def alterDatabase(databaseOld: str, databaseNew) -> int: try: if not databaseOld.isidentifier() or not databaseNew.isidentifier(): raise Exception() nodoBD = mBBDD.obtener(databaseOld) #AGREGARXXX if nodoBD: #AGREGARXXX if databaseNew not in mBBDD: v = nodoBD.valor #AGREGARXXX d = nodoBD.datos #AGREGARXXX res = mBBDD.quitar(databaseOld)
def do_comPath(self, arg): 'calculates commercial path to every node' if not arg: print("please refer to the help for command documentation") return None arglist = arg.split() if len(arglist) != 2: print( "wrong argument number, please refer to the help for command documentation" ) return None try: start = int(arglist[0]) end = int(arglist[1]) nodeStart = self.nodes[start] nodeEnd = self.nodes[end] except Exception as ex: # one of the nodes is not in the nodeList print("node does not exist or node is not integer") return None # nodeList = list(self.nodes.values()) OLD NODELIST # nodeList = [] nodeList = avl.AVL() for node in self.nodes.values(): node.resetDistPrev() nodeStart.dist = 0 nodeStart.prev = None nodeStart.lastRelationship = 4 nodeStart.is_in_collection = 1 # insert_node_ordered_array(nodeList,nodeStart) nodeList.insert(nodeStart.dist, nodeStart) reached = False while nodeList and not reached: min = nodeList.find_minimum( ) # currNode = take_smallest(nodeList)#takeSmallerRelationshipNode(nodeList)#TODO change this to be a ordered array or something min = nodeList.find_minimum() min = nodeList.find_minimum() currNode = nodeList.delete(min.key, min.value) currNode.is_in_collection = False if reached and currNode.lastRelationship >= nodeEnd.lastRelationship: break for edge in list(currNode.edges.values()): relative = edge.getRelative(currNode) if currNode.lastRelationship == 1 or currNode.lastRelationship == 4: if relative.n_next_hops > currNode.n_next_hops + 1: # +1 for each edge relative.n_next_hops = currNode.n_next_hops + 1 relative.prev = currNode relative.lastRelationship = edge.getRelationship( relative) if relative.is_in_collection: nodeList.delete(relative.n_next_hops, relative) nodeList.insert(relative.n_next_hops, relative) relative.is_in_collection = True elif currNode.lastRelationship == 2: if ( relative.lastRelationship == 2 or relative.lastRelationship == 0 ) and relative.n_next_hops > currNode.n_next_hops + 1 and edge.getRelationship( currNode) != 2: relative.n_next_hops = currNode.n_next_hops + 1 relative.prev = currNode relative.lastRelationship = 2 if relative.is_in_collection: nodeList.delete(relative.n_next_hops, relative) nodeList.insert(relative.n_next_hops, relative) relative.is_in_collection = True elif currNode.lastRelationship == 3: if edge.getRelationship( currNode ) == 1 and relative.n_next_hops > currNode.n_next_hops + 1: # if current node is provider relative.n_next_hops = currNode.n_next_hops + 1 relative.prev = currNode relative.lastRelationship = edge.getRelationship( relative) if relative.is_in_collection: nodeList.delete(relative.n_next_hops, relative) nodeList.insert(relative.n_next_hops, relative) relative.is_in_collection = True if relative.ID == nodeEnd.ID and not math.isinf( relative.n_next_hops): reached = True if reached: path = [nodeEnd.ID] currNode = nodeEnd.prev connectioninfo = [0, 0, 0] # provider->client, equal, client->provider lastNode = nodeEnd while currNode != None: path.insert(0, currNode.ID) usedEdge = currNode.getEdge(lastNode) connectioninfo[usedEdge.getRelationship(currNode) - 1] += 1 # TODO add connection statistics lastNode = currNode currNode = currNode.prev print( "reached node {} from {} with {} jumps using path {} ,jumps (p->c,p->p,c->p){}" .format(nodeEnd.ID, nodeStart.ID, nodeEnd.n_next_hops, path, connectioninfo)) return
def __init__(self): """Initially empty range index.""" self.data = avl.AVL()
import os import time import avl as tree import hashtb as ht import tkinter as tk from pathlib import Path import numpy as np from PIL import Image from wordcloud import WordCloud, STOPWORDS import matplotlib import matplotlib.pyplot as plt currdir = os.path.dirname(__file__) omap = tree.AVL() obj = ht.HashTable() # turns the set of txt files from avl.py into a touple for easy manipulation spch = [] for item in sorted(tree.speeches): spch.append(item) wordCount = 0 treeTime, hashTime = 0.0, 0.0 def parse(text): global treeTime global hashTime global wordCount wordCount = 0
# search start = time.time() for key in keys: container.search(key) end = time.time() print('search: ' + str(end - start)) # search not exist start = time.time() for key in keys: container.search(key + '_not') end = time.time() print('search NOT: ' + str(end - start)) sys.exit(0) elif (args.data_structure == 'AVL'): # insert container = avl.AVL() start = time.time() keys = [] for l in open(args.dataset): keys.append(l) if (index < args.data_number): container.insert(l, l + '_val') index = index + 1 end = time.time() print('insert: ' + str(end - start)) # search start = time.time() for key in keys: container.search(key) end = time.time() print('search: ' + str(end - start))
# Jonpierre Grajales # Project 1 Part 2 import node as node import genarray as gen import bst as bst import avl as avl from datetime import datetime avl = avl.AVL(None) bst = bst.BST(None) array = gen.getSortedArray(10000) now = datetime.now() FMT = '%H:%M:%S' print("Creating BST, PLEASE WAIT") bstStart = now.strftime("%H:%M:%S") for val in array: bst.insertIter(val) for val in array: bst.deleteIter(val) now = datetime.now() bstFinish = now.strftime("%H:%M:%S") BSTtdelta = datetime.strptime(bstStart, FMT) - datetime.strptime( bstFinish, FMT) print("BST runtime was: ", BSTtdelta, "seconds")
def __init__(self): """Initially empty range index.""" print("AVL-tree based range index") self.tree = avl.AVL()
def test_avl_inserts(self): """test if the avl tree insert works""" tree = avl.AVL() tree.insert(10) self.assertNotEqual(tree, None)