def dequeue(Q):
currentNode = Q.head
if length(Q) == 0:
return None
elif (length(Q) == 1):
deleteElement = access(Q, length(Q)-1)
Q.head = currentNode.nextNode
return deleteElement
else:
deleteElement = access(Q, length(Q)-1)
currentPosition = 0
while (currentNode != None) and (currentPosition < length(Q)-2):
currentNode = currentNode.nextNode
currentPosition += 1
# una vez ubicado en el nodo anterior al nodo a eliminar, apunto el puntero del currentNode al nodo que se encuentra siguiente al nodo a eliminar. Ésta operación desvincula o elimina el nodo.
currentNode.nextNode = currentNode.nextNode.nextNode
return deleteElement
def maxChild(BH,i,currentsize):
""" Determina dado un nodo i, cual de sus hijos es el mayor y devuelve la posicion
"""
if i * 2 + 1 > currentsize:
return i * 2
else:
if linkedlist.access(BH.bheaplist,i*2) > linkedlist.access(BH.bheaplist,i*2+1):
return i * 2
else:
return i * 2 + 1
def shiftUp(BH, i):
""" Recorre el arbol desde los nodos hacia la raiz y va reemplazando el nodo i por su padre
siempre y cuando i sea mayor. La operacion matematica i // 2 nos permite rapidamente encontrar al padre.
"""
while i // 2 > 0:
padre = linkedlist.access(BH.bheaplist, i // 2)
hijo = linkedlist.access(BH.bheaplist, i)
if padre < hijo:
linkedlist.update(BH.bheaplist, padre, i)
linkedlist.update(BH.bheaplist, hijo, i // 2)
i = i // 2
def test_access_from_list(self):
""" -- Accede a un elemento en una lista y verifica que acces() devuelva el valor correcto
"""
L = LinkedList()
add(L, "hola")
add(L, "jorge")
res = access(L, 1)
self.assertEqual(res, "hola")
def shiftDown(BH, i, currentsize=None):
""" Recorre el arbol desde la raiz y hacia los nodos (arriba hacia abajo) va reemplazando el nodo i por sus hijos
siempre y cuando alguno de sus hijos sea mayor.
"""
if currentsize == None:
currentsize = linkedlist.length(BH.bheaplist) - 1
while (i * 2) <= currentsize:
#indice del hijo mayor
mc = maxChild(BH, i, currentsize)
padre = linkedlist.access(BH.bheaplist, i)
hijoMayor = linkedlist.access(BH.bheaplist, mc)
if hijoMayor > padre:
linkedlist.update(BH.bheaplist, hijoMayor, i)
linkedlist.update(BH.bheaplist, padre, mc)
i = mc
def delMax(BH):
"""
Recupera el mayor elemento del heap. Este siempre se encontrara al comienzo (posicion 1).
Para manter la esctrucura del arbol binario se reemplaza el nodo raiz por el ultimo nodo.
Luego mediante la funcion shiftDown se va recorriendo el arbol hasta encontrar la posicion
correcta de dicho nodo. De esta manara se garantiza la propiedad heap.
"""
retval = linkedlist.access(BH.bheaplist, 1)
ultimo = linkedlist.access(BH.bheaplist, length(BH))
linkedlist.delete(BH.bheaplist, ultimo)
linkedlist.update(BH.bheaplist, ultimo, 1)
shiftDown(BH, 1)
return retval
def heapsort(L):
BH = Bheap()
listaInterna = linkedlist.LinkedList()
#copiar valores
for i in range(linkedlist.length(L) - 1, -1, -1):
linkedlist.add(listaInterna, linkedlist.access(L, i))
heapify(BH, listaInterna)
for i in range(length(BH)):
if length(BH) == 1:
primero = linkedlist.access(BH.bheaplist, 1)
linkedlist.add(listaInterna, primero)
else:
shiftDown(BH, 1)
# intercambia el primero con el ultimo
primero = linkedlist.access(BH.bheaplist, 1)
ultimo = linkedlist.access(BH.bheaplist, length(BH))
linkedlist.update(BH.bheaplist, primero, length(BH))
linkedlist.update(BH.bheaplist, ultimo, 1)
# se coloco esta liena para que sea mas facil leer el codigo
ultimo = primero
# se agrega el primero a listaInterna y se elimina el ultimo elemento
# del Bheap
linkedlist.add(listaInterna, ultimo)
linkedlist.delete(BH.bheaplist, ultimo)
# actualizar valores
for i in range(linkedlist.length(L)):
linkedlist.update(L, linkedlist.access(listaInterna, i), i)
# URL : https://repl.it/@BrunoFuentes/Binary-Heaps-y-HeapSort
def pop(S):
currentNode = S.head
if (length(S) == 0):
return None
else:
#accedo al elemento de la posicion 0
deleteElement = access(S, 0)
S.head = currentNode.nextNode
return deleteElement
def test_access_from_empty_list(self):
""" -- Accede a un elemento que no se encuentra en la lista y verifica que access() devuelve None
"""
L = LinkedList()
res = access(L, 1)
self.assertEqual(res, None)