def rehash(map):
"""
Se aumenta la capacidad de la tabla al doble y se hace rehash de
todos los elementos de la tabla.
"""
try:
newtable = lt.newList('ARRAY_LIST', map['comparefunction'])
capacity = nextPrime(map['capacity'] * 2)
for _ in range(capacity):
entry = me.newMapEntry(None, None)
lt.addLast(newtable, entry)
oldtable = map['table']
map['size'] = 0
map['currentfactor'] = 0
map['table'] = newtable
map['capacity'] = capacity
for pos in range(lt.size(oldtable)):
entry = lt.getElement(oldtable, pos + 1)
if (entry['key'] is not None and entry['key'] != '__EMPTY__'):
hash = hashValue(map, entry['key'])
pos = findSlot(map, entry['key'], hash, map['comparefunction'])
lt.changeInfo(map['table'], abs(pos), entry)
if (pos < 0):
map['size'] += 1
map['currentfactor'] = map['size'] / map['capacity']
return map
except Exception as exp:
error.reraise(exp, 'Probe:rehash')
def put(map, key, value):
""" Ingresa una pareja llave,valor a la tabla de hash.
Si la llave ya existe en la tabla, se reemplaza el valor
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
value: el valor asociado a la pareja
Returns:
El map
Raises:
Exception
"""
try:
hash = hashValue(map, key) # Se obtiene el hascode de la llave
entry = me.newMapEntry(key, value)
pos = findSlot(map, key, hash, map['comparefunction'])
lt.changeInfo(map['table'], abs(pos), entry)
if (pos < 0): # Se reemplaza el valor con el nuevo valor
map['size'] += 1
map['currentfactor'] = map['size'] / map['capacity']
if (map['currentfactor'] >= map['limitfactor']):
rehash(map)
return map
except Exception as exp:
error.reraise(exp, 'Probe:put')
def put(map, key, value):
""" Ingresa una pareja llave,valor a la tabla de hash.
Si la llave ya existe en la tabla, se reemplaza el valor
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
value: el valor asociado a la pareja
Returns:
El map
Raises:
Exception
"""
if map['ints']:
hashv = key % map['capacity']
else:
hashv = hashValue(map, key)
bucket = lt.getElement(map['table'], hashv)
entry = me.newMapEntry(key, value)
pos = lt.isPresent(bucket, key)
if pos > 0: # La pareja ya exista, se reemplaza el valor
lt.changeInfo(bucket, pos, entry)
else:
lt.addLast(bucket, entry) # La llave no existia
map['size'] += 1
return map
def delMax(heap):
"""
Retorna el menor elemento del heap y lo elimina.
Se reemplaza con el último elemento y se hace sink.
Args:
heap: El arreglo con la informacion
Returns:
El menor elemento eliminado
Raises:
Exception
"""
try:
if (heap['size'] > 0):
max = lt.getElement(heap['elements'], 1)
last = lt.getElement(heap['elements'], heap['size'])
lt.changeInfo(heap['elements'], 1, last)
lt.changeInfo(heap['elements'], heap['size'], None)
heap['size'] -= 1
sink(heap, 1)
return max
return None
except Exception as exp:
error.reraise(exp, 'heap:delMax')
def rehash(map):
"""
Se aumenta la capacidad de la tabla al doble y se hace rehash de
todos los elementos de la tabla.
"""
try:
newtable = lt.newList("ARRAY_LIST", map["comparefunction"])
capacity = nextPrime(map["capacity"] * 2)
for _ in range(capacity):
entry = me.newMapEntry(None, None)
lt.addLast(newtable, entry)
oldtable = map["table"]
map["size"] = 0
map["currentfactor"] = 0
map["table"] = newtable
map["capacity"] = capacity
for pos in range(lt.size(oldtable)):
entry = lt.getElement(oldtable, pos + 1)
if entry["key"] is not None and entry["key"] != "__EMPTY__":
hash = hashValue(map, entry["key"])
pos = findSlot(map, entry["key"], hash, map["comparefunction"])
lt.changeInfo(map["table"], abs(pos), entry)
if pos < 0:
map["size"] += 1
map["currentfactor"] = map["size"] / map["capacity"]
return map
except Exception as exp:
error.reraise(exp, "Probe:rehash")
def exchange(iheap, i, j):
"""
Intercambia los elementos en las posiciones i y j del heap
"""
try:
element_i = lt.getElement(iheap['elements'], i)
element_j = lt.getElement(iheap['elements'], j)
lt.changeInfo(iheap['elements'], i, element_j)
map.put(iheap['qpMap'], element_i['key'], j)
lt.changeInfo(iheap['elements'], j, element_i)
map.put(iheap['qpMap'], element_j['key'], i)
except Exception as exp:
error.reraise(exp, 'indexheap:exchange')
def changeInfo(lst, pos, element):
""" Cambia la informacion contenida en el nodo de la lista que se encuentra en la posicion pos.
Args:
lst: La lista a examinar
pos: la posición de la lista con la información a cambiar
newinfo: La nueva información que se debe poner en el nodo de la posición pos
Raises:
Exception
"""
try:
lt.changeInfo(lst, pos, element)
except Exception as exp:
error.reraise(exp, 'List->changeInfo: ')
def remove(map, key):
""" Elimina la pareja llave,valor, donde llave == key.
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
Returns:
El map
Raises:
Exception
"""
hash = hashValue(map, key)
pos = findSlot(map, key, hash, map['comparefunction'])
if pos > 0:
entry = me.newMapEntry('__EMPTY__', '__EMPTY__')
lt.changeInfo(map['table'], pos, entry)
map['size'] -= 1
return map
def put(map, key, value):
""" Ingresa una pareja llave,valor a la tabla de hash.
Si la llave ya existe en la tabla, se reemplaza el valor
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
value: el valor asociado a la pareja
Returns:
El map
Raises:
Exception
"""
hash = hashValue(map, key) # Se obtiene el hascode de la llave
entry = me.newMapEntry(key, value)
pos = findSlot(map, key, hash, map['comparefunction'])
lt.changeInfo(map['table'], abs(pos), entry)
if (pos < 0): # Se reemplaza el valor con el nuevo valor
map['size'] += 1
return map
def remove(map, key):
"""Elimina la pareja llave,valor, donde llave == key.
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
Returns:
El map
Raises:
Exception
"""
try:
hash = hashValue(map, key)
pos = findSlot(map, key, hash, map["comparefunction"])
if pos > 0:
entry = me.newMapEntry("__EMPTY__", "__EMPTY__")
lt.changeInfo(map["table"], pos, entry)
map["size"] -= 1
return map
except Exception as exp:
error.reraise(exp, "Probe:remove")
def increaseKey(iheap, key, newindex):
"""
Incrementa el indice de un llave
Args:
iheap: El heap a revisar
key: la llave a incrementar
newindex: El nuevo indice de la llave
Returns:
El numero de elementos
Raises:
Exception
"""
try:
val = map.get(iheap['qpMap'], key)
elem = lt.getElement(iheap['elements'], val['value'])
elem['index'] = newindex
lt.changeInfo(iheap['elements'], val['value'], elem)
sink(iheap, val['value'])
return iheap
except Exception as exp:
error.reraise(exp, 'indexheap:increaseKey')
