Algoritmos y Estructuras de Datos

LABORATORIO N° 14

Heap Advanced

DESARROLLO DE SOFTWARE Ing. Jaime Farfán

PROGRAMA DE FORMACIÓN REGULAR jfarfan@tecsup.edu.pe
 Laboratorio de Algoritmos y Estructuras de Datos
Página 2 de 9

CODIGO DEL CURSO:

Alumno(s) Nota
Briceño Sanchez, Rodrigo
Castillo Llanos, Alberth
Coayla Godoy, Jose
Macedo Zeballos, Aisha
Peralta Tito, Rocio
Grupo A-B
Ciclo I
Fecha de entrega
I.- OBJETIVOS:
 Definir las reglas básicas a seguir para la construcción y la correcta interpretación de los Diagramas de
Flujo, resaltando las situaciones en que pueden, o deben, ser utilizados.
 Elaborar y Diseñar algoritmos con arreglos de una sola dimensión(unidimensional) denominada vectores

II.- SEGURIDAD:
Advertencia:
En este laboratorio está prohibida la manipulación del
hardware, conexiones eléctricas o de red; así como la
ingestión de alimentos o bebidas.

III.- FUNDAMENTO TEÓRICO:

 Revisar el texto guía que está en el campus Virtual.

IV.- NORMAS EMPLEADAS:

 No aplica

V.- RECURSOS:
 En este laboratorio cada alumno trabajará con un equipo con Windows 10.

VI.- METODOLOGÍA PARA EL DESARROLLO DE LA TAREA:

 El desarrollo del laboratorio es individual.

VII.- PROCEDIMIENTO:

EJERCICIO DE APLICACIÓN

Se tiene la siguiente clase

class Heap:
'''
Heap class
'''
def __init__(self):
self.heapList = []
self.size = 0

def parentIndex(self, index):

return (index-1) //2

def leftChildIndex(self, index):

return 2 * index + 1

def leftChild(self, index):

'''
Get value of left child
:param index:
:return:
'''
leftIndex = self.leftChildIndex(index)
if leftIndex < self.size:
return self.heapList[leftIndex]
return -1
def rightChildIndex(self, index):
return 2 * index + 2

def rightChild(self, index):

'''
Get value of right child
:param index:
:return:
'''
rightIndex = self.rightChildIndex(index)
if rightIndex < self.size:
return self.heapList[rightIndex]
return -1

def searchElement(self, itm):

i=0
while (i <= self.size):
if itm == self.heapList[i]:
return i
i += 1

def maximumChildIndex(self, idx):

valueLeftChild = self.leftChild(idx)
valueRightChild = self.rightChild(idx)

if valueLeftChild > valueRightChild :

return self.leftChildIndex(idx)
elif valueLeftChild < valueRightChild :
return self.rightChildIndex(idx)
else :
# return any child index
return self.leftChildIndex(idx)

def minimumChildIndex(self, idx):

valueLeftChild = self.leftChild(idx)
valueRightChild = self.rightChild(idx)
#print("valueLeftChild = %d" % valueLeftChild)
#print("valueRightChild = %d" % valueRightChild)

if valueRightChild == -1 :
return self.leftChildIndex(idx)

if valueLeftChild > valueRightChild :

return self.rightChildIndex(idx)
elif valueLeftChild < valueRightChild :
return self.leftChildIndex(idx)
else :
# return any child index
return self.rightChildIndex(idx)

def getTop(self):
'''
Get root value for Heap
:return:
'''
 if self.size == 0:
return -1
return self.heapList[0]

1.- Construcción el siguiente Heap

#
# 10
# 3 9
# 12 78
#

2.- Construir un Min Heap

2.1.- Agregar a la clase Heap los siguientes métodos:

def percolateDown(self, i):

pass

def buildHeap(self,list):
'''
Built heap from array
:param list:
:return:
'''
i = len(list) // 2
self.size = len(list)
self.heapList = list
print("")
while i >= 0:
tmp = self.heapList[i]
print("percolate-down ", tmp , " <<", self.heapList)
self.percolateDown(i)
 print("percolate-down ", tmp , " >>", self.heapList)
print("")
i=i-1

2.2.- Crear la clase hija MinHeap de Heap y agregar el siguiente método:

def percolateDown(self, i):

'''
Apply percolate up to heap
:return:
'''
while self.leftChildIndex(i) < self.size:
minimumChildIndex = self.minimumChildIndex(i)
if self.heapList[i] > self.heapList[minimumChildIndex]:
tmp = self.heapList[i]
self.heapList[i] = self.heapList[minimumChildIndex]
self.heapList[minimumChildIndex] = tmp
i = minimumChildIndex

2.3.- Ejecutar el siguiente Código que usa la clase MinHeap, ¿Qué sucede? , agrege
evidencias de ejecución:

LIST_ORIGIN = [3, 9, 10, 1, 7, 2, 8, 20, 5]

list = LIST_ORIGIN
print("input <<",list)
heap = MinHeap()
heap.buildHeap(list)
print("output >>",heap.heapList)

3.- Construir un Max Heap

Siguiendo los pasos del ejercicio 2, cree una clase MaxHeap y adaptelo para que cree un Max
Heap
4.- Eliminación de elementos raices de un Min Heap.

4.1- Agrege el siguiente método a la clase Heap

def delete(self):
'''
Delete an element from top
of heap and apply percolate doown
:return:
'''
ret = self.heapList[0]
self.heapList[0] = self.heapList[self.size-1]
self.size = self.size-1
self.heapList.pop()
self.percolateDown(0)
return ret

4.2.- Ejecute el siguiente código , ¿Qué es lo que esta realizando?, adjuntar evidencias

LIST_ORIGIN = [3, 9, 10, 1, 7, 2, 8, 20, 5]

list = LIST_ORIGIN
print(list)
heap = MinHeap()
heap.buildHeap(list)

print("=========================")
for i in range(len(heap.heapList)):
print(heap.heapList)
ret = heap.delete()
print("------------------------")
print("attend --> ", ret)

print(heap.heapList)

5.- Eliminación de elementos raices de un Max Heap.

Adaptar el código para realizar lo mismo con un Max Heap

6.- Insert elementos en un Min Heap

6.1.- Agregar a la clase Heap los siguientes métodos:

def percolateUp(self, i):

pass

def insert(self, k):

'''
Insert an element at the end
of heap and apply percolate up
:param k:
:return:
'''
self.heapList.append(k)
self.size = self.size + 1
self.percolateUp(self.size - 1)

6.2.- Agregar a la clase MinHeap el siguiente método:

def percolateUp(self, i):
'''
Apply percolate up to heap
:return:
'''
iParent = self.parentIndex(i)
while(iParent >= 0):
#print(iParent)
#print(i)
if self.heapList[iParent] > self.heapList[i]:
tmp = self.heapList[iParent]
self.heapList[iParent] = self.heapList[i]
self.heapList[i] = tmp
i = iParent
iParent = self.parentIndex(i)
#print(self.heapList)

6.3.- Ejecutar el siguiente Código, ¿ Qué sucede? Adjunte evidencias

LIST_ORIGIN = [3, 9, 10, 1, 7, 2, 8, 20, 5]

list = LIST_ORIGIN

heap = MinHeap()

for i in range(len(list)):
#print("c[%d] = %d" % (i,list[i]))
heap.insert(list[i])
print("--------------------------")
print(heap.heapList)

print("--------------------------")
print("input <<",list)
print("output >>",heap.heapList)
7.- Insert elementos en un Max Heap

Adapte la clase MaxHeap para que se pueda insertar elementos

CONCLUSIONES:
1. Los montones son estructuras de datos extremadamente versátiles y
útiles que se utilizan junto con otras estructuras de datos como gráficos y
árboles
2.Aprendimos que heap advance,son los montículos o también llamados
árboles binarios para los cuales cada nodo padre tiene un valor menor o
igual que cualquiera de sus hijos. Esta implementación utiliza matrices
para las cuales heap[k] <= heap[2*k+1] y heap[k] <= heap[2*k+2] para todo
k, contando los elementos desde cero. Para poder comparar, los
elementos inexistentes se consideran infinitos. La propiedad interesante
de un montículo es que su elemento más pequeño es siempre la raíz,
heap[0].
3. observamos que la mejorar la eficiencia de varias operaciones.