Algoritmos y Estructuras de Datos

LABORATORIO N°04

Pilas

DESARROLLO DE SOFTWARE Ing. Jhordan Mayhua Ubillas

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

CODIGO DEL CURSO:

Alumno(s) Nota

Diego Armando Apaza Quispe

Grupo B
Ciclo III
Fecha de entrega
 Laboratorio de Algoritmos y Estructuras de Datos
Página 1 de 14

I.- OBJETIVOS:
 Definir las reglas básicas para la implementación de pilas.
 Elaborar y Diseñar pilas con listas estáticas, dinámicas y enlazadas

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

1. Stack con Lista Simple

class StackSimpleArray:

def __init__(self,limit = 10):

self.stk = []
self.limit = limit

def isEmpty(self):
return len(self.stk) <= 0

def size(self):
return len(self.stk)

def push(self, item):

if len(self.stk) >= self.limit:
print('Stack Overflow!')
else:
self.stk.append(item)
print('Stack after Push', self.stk)

def pop(self):
if len(self.stk) <= 0:
print('Stack Underflow!')
return 0
else:
 Laboratorio de Algoritmos y Estructuras de Datos
Página 2 de 14

return self.stk.pop()

def peek(self):
if len(self.stk) < 0:
print('Stack Underflow!')
return 0
else:
return self.stk[-1]

our_stack = StackSimpleArray(5)
our_stack.push(1)
our_stack.push(21)
our_stack.push(14)
our_stack.push(31)
our_stack.push(19)
our_stack.push(3)
our_stack.push(99)
our_stack.push(9)

- Ejercicio: crear un stack que soporte 10 elementos, agregar 11 elementos ¿Qué pasa?
 Laboratorio de Algoritmos y Estructuras de Datos
Página 3 de 14

Cuando intentamos agregar el undécimo elemento al stack, el código verifica si la longitud actual del stack es
menor que la capacidad máxima permitida (10 en este caso). Al darse cuenta de que la longitud es mayor, imprime
un mensaje indicando que el stack está lleno. El undécimo elemento no se agrega realmente al stack.

- Ejercicio: crear un stack que soporte 15 elementos, agregar 5 elementos y retirar 6 elementos ¿Qué
pasa?
 Laboratorio de Algoritmos y Estructuras de Datos
Página 4 de 14

Comenzamos agregando 5 elementos al stack. Luego, intentamos retirar 6 elementos del stack. En el
proceso de retirar elementos, el código verifica si el stack tiene elementos antes de intentar retirar. Si no hay
elementos, se imprime un mensaje indicando que el stack está vacío. Por lo tanto, en este caso, el código
imprimirá el mensaje "¡El stack está vacío!" al intentar retirar el sexto elemento, ya que inicialmente solo
había 5 elementos en el stack y todos ellos fueron retirados en las iteraciones anteriores.

2. Stack con Lista Dinámica

class StackDynamicArray:

# Constructor
def __init__(self, limit = 10):
self.stk = []
self.limit = limit

def isEmpty(self):
return len(self.stk) <= 0

def push(self, item):

if len(self.stk) >= self.limit:
self.resize()
self.stk.append(item)
print('Stack after Push',self.stk)

def pop(self):
if len(self.stk) <= 0:
 Laboratorio de Algoritmos y Estructuras de Datos
Página 5 de 14

print('Stack Underflow!')
return 0
else:
return self.stk.pop()

def peek(self):
if len(self.stk) <= 0:
print('Stack Underflow!')
return 0
else:
return self.stk[-1]

def size(self):
return len(self.stk)

def resize(self):
newStk = list(self.stk)
self.limit = 2 * self.limit
self.stk = newStk

our_stack = StackDynamicArray(5)
our_stack.push(1)
our_stack.push(21)
our_stack.push(14)
our_stack.push(11)
our_stack.push(31)
our_stack.push(14)
our_stack.push(15)
our_stack.push(19)
our_stack.push(3)
our_stack.push(99)
our_stack.push(9)
print( our_stack.peek())
print( our_stack.pop())
print( our_stack.peek())
print( our_stack.pop())
 Laboratorio de Algoritmos y Estructuras de Datos
Página 6 de 14

- Ejercicio : crear un stack que soporte 10 elementos , agregar 11 elementos ¿ Qué pasa ?

Cuando intentas agregar el undécimo elemento, el stack se redimensiona automáticamente para aumentar su
capacidad y así poder acomodar el nuevo elemento.
 Laboratorio de Algoritmos y Estructuras de Datos
Página 7 de 14

- Ejercicio: crear un stack que soporte 15 elementos, agregar 5 elementos y retirar 6 elementos ¿Qué
pasa?

Al retirar el sexto elemento, el stack se queda vacío y un intento de retirar otro elemento resulta en un "Stack
Underflow", indicando que no hay suficientes elementos en el stack para retirar.

3. Stack con Lista Enlazada

# Node of a Single Linked List

class Node:

# Constructor
def __init__(self):
self.data = None
self.next = None

# Method for setting the data

def setData(self, data):
self.data = data

# Method for getting the data

def getData(self):
return self.data

# Method for setting the data

 Laboratorio de Algoritmos y Estructuras de Datos
Página 8 de 14

def setNext(self, next):

self.next = next

# Method for getting the data

def getNext(self):
return self.next

# return true if thenode point to another node

def hasNext(self):
return self.next != None

class StackLinkedList:

# Constructor
def __init__(self, data=None):
self.head = None
if data:
for d in data:
self.push(d)

def push(self, data):

temp = Node()
temp.setData(data)
temp.setNext(self.head)
self.head = temp

def pop(self):
if self.head is None:
raise IndexError
temp = self.head.getData()
self.head =self.head.getNext()
return temp

def peek(self):
if self.head is None:
raise IndexError
return self.head.getData()

def print( self ):

node = self.head
while node != None:
print(node.data, end =" => ")
node = node.next
print("NULL")

# Get length of linked list

def listLength(self):

current = self.head
count = 0

while current != None:

 Laboratorio de Algoritmos y Estructuras de Datos
Página 9 de 14

count = count + 1
current = current.getNext()

return count

our_stack = StackLinkedList()
our_stack.push(1)
our_stack.push(21)
our_stack.push(14)
our_stack.push(31)
our_stack.push(19)
our_stack.push(3)
our_stack.push(99)
our_stack.push(9)

our_stack.print()
print("length : " , our_stack.listLength())
print( our_stack.pop())
print( our_stack.pop())

- Ejercicio: crear un stack que soporte 5 elementos ¿tiene sentido declarar el tamaño?, agregar 11
elementos ¿Qué pasa?
 Laboratorio de Algoritmos y Estructuras de Datos
Página 10 de 14

- Ejercicio: crear un stack, agregar 5 elementos y retirar 6 elementos ¿Qué pasa?

 Laboratorio de Algoritmos y Estructuras de Datos
Página 11 de 14

4. Ejercicio propuesto

Realizar operaciones de tipo, crear un menú que permite realizar las siguientes
operaciones:

- Listar los elementos de la pila

- Agregar
- Eliminar
- Ver el tamaño de la pila
Laboratorio de Algoritmos y Estructuras de Datos
Página 12 de 14
Laboratorio de Algoritmos y Estructuras de Datos
Página 13 de 14
 Laboratorio de Algoritmos y Estructuras de Datos
Página 14 de 14

CONCLUSIONES:
1. Las pilas son estructuras de datos simples pero poderosas, útiles para modelar
procesos LIFO en programas informáticos y resolver una variedad de problemas.
2. La implementación de un menú interactivo facilita la interacción del usuario con las
operaciones de una pila, mejorando la usabilidad del programa.
3. Las operaciones básicas en una pila, como agregar y eliminar elementos, son
fundamentales para su funcionalidad y deben implementarse correctamente para evitar
errores.
4. La visualización del estado actual de una pila mediante la lista de sus elementos
facilita la depuración y comprensión del comportamiento del programa.
5. La validación de la existencia de elementos antes de realizar operaciones como
eliminar o consultar el elemento superior de la pila evita errores de tiempo de
ejecución.

Observaciones:
1. La interacción entre el usuario y el programa a través del menú puede mejorar
con una interfaz gráfica de usuario (GUI), proporcionando una experiencia más
intuitiva y atractiva.
2. Es esencial manejar adecuadamente situaciones de error, como la eliminación de
elementos de una pila vacía, para garantizar la robustez y la fiabilidad del
programa.
3. La implementación de una pila puede adaptarse a diversas necesidades y
escenarios mediante la adición de funcionalidades avanzadas, como la reversión
de elementos o la combinación de pilas.
4. El rendimiento de las operaciones en una pila puede variar según la
implementación específica y la cantidad de elementos almacenados, lo que
puede requerir optimizaciones en casos de uso intensivo.
5. La capacidad de expansión dinámica de una pila, agregando o eliminando
elementos según sea necesario, puede mejorar la eficiencia del almacenamiento
de datos en aplicaciones escalables.