Pilas: Definición, características, representación. Tratamiento de una pila: Modo fifo, modo lifo. EJEMPLOS Operaciones a realizar con estructura de pila. EJEMPLOS Diseñar Algoritmos elementales para el tratamiento de pila.

1. III CORTE 20% DECLARACIÓN DE PILAS
Una pila (o “stack” en inglés) es una lista ordenada o estructura de datos que
permite almacenar y recuperar datos. El modo de acceso a sus elementos es de
tipo LIFO (del inglés Last In, First Out, último en entrar, primero en salir) . Esta
estructura se aplica en multitud de supuestos en el área de la informática
debido a su simplicidad y capacidad de dar respuesta a numerosos procesos.
Para el manejo de los datos, la pila cuenta con dos operaciones básicas:
 Apilar (o “push”), que coloca un objeto en la pila.
 Desapilar (o “pop”), que retira el último elemento apilado.
En cada momento, solamente se tiene acceso a la parte superior de la pila, es
decir, al último objeto apilado (denominado “Top of Stack” o “TOS” en
inglés). La operación “pop” permite la obtención de este elemento, que es
retirado de la pila permitiendo el acceso al anterior (apilado con anterioridad),
que pasa a ser el último, el nuevo TOS.
Caracteristicas de las pilas:
1. Modo de acceso LIFO (Last In, First Out): El último elemento en entrar
es el primero en salir. Esto significa que sólo se puede acceder al último
elemento que se ha añadido a la pila
2. Operaciones básicas: Las pilas tienen dos operaciones fundamentales:
 Push (Apilar): Añade un elemento a la parte superior de la pila.
 Pop (Desapilar): Elimina y devuelve el elemento que está en la parte
superior de la pila.
3. Acceso limitado: Sólo se puede acceder a la parte superior de la pila
(denominado “Top of Stack” o “TOS” en inglés). No se puede acceder a
los elementos que están debajo del TOS a menos que se retiren los
elementos que están encima.
4. Estructura dinámica: Una pila puede crecer y encogerse durante la
ejecución de un programa. Comienza como una pila vacía y su tamaño va
incrementando a medida que se agregan datos.
Estas características hacen que las pilas sean útiles en diversas aplicaciones en
informática, como la evaluación de expresiones, la implementación de
recursividad y el manejo de llamadas a funciones.

2. Como se representan las pilas:
Las pilas en informática pueden ser representadas en memoria de dos formas
principales:
1. Arreglos: Representar pilas usando arreglos es relativamente más sencillo que
usando listas enlazadas. El único problema que existe es la limitante de espacio
en memoria, ya que al definir un tamaño máximo ya no es posible insertar más
elementos.
2. Listas enlazadas: Son llamadas también estructuras dinámicas, ya que el
espacio en memoria se crea hasta que se inserta el elemento. A diferencia de
los arreglos, las listas enlazadas no tienen una limitación de tamaño
predefinida, lo que las hace más flexibles.
En ambos casos, sólo se puede acceder al último elemento que se ha añadido a la pila
(el “Top of Stack” o “TOS”) y los elementos se añaden y se eliminan desde este punto.
Tratamiento de una pila (Modo Fifo):
El tratamiento de una pila en modo FIFO (First In, First Out) no es posible, ya que las
pilas siguen el principio LIFO (Last In, First Out). En una pila, el último elemento que se
añade es el primero en ser eliminado.
Sin embargo, existe una estructura de datos que sigue el principio FIFO llamada “cola”
o “queue” en inglés. En una cola, el primer elemento que se añade es el primero en ser
eliminado. Esto es similar a una cola de personas en un supermercado, donde la
primera persona en la cola es la primera en ser atendida.
Las operaciones básicas en una cola son:
 Enqueue (Encolar): Añade un elemento al final de la cola.
 Dequeue (Desencolar): Elimina y devuelve el primer elemento de la cola.
Estas operaciones permiten manipular los datos en la cola de acuerdo con las
necesidades del programa.

3. Ejemplo de tratamiento en Modo fifo:
class Pila:
def __init__(self):
self.items = []
def estaVacia(self):
return self.items == []
def apilar(self, item):
self.items.append(item)
def desapilar(self):
return self.items.pop()
def inspeccionar(self):
return self.items[len(self.items)-1]
def tamano(self):
return len(self.items)
Tratamiento de una pila en (Modo lifo):
El tratamiento de una pila en modo LIFO (Last In, First Out) es la forma estándar de manejar
una pila en informática. Aquí están las operaciones básicas:
1. Push (Apilar): Esta operación agrega un elemento a la parte superior de la pila.
2. Pop (Desapilar): Esta operación elimina y devuelve el elemento que está en la parte
superior de la pila.
3. Peek o Top: Esta operación devuelve el valor del elemento actual en la parte superior
de la pila, sin eliminarlo.
4. IsEmpty (Está vacía): Esta operación verifica si la pila está vacía.
5. Size (Tamaño): Esta operación devuelve el número de elementos en la pila.
Estas operaciones permiten manipular los datos en la pila de acuerdo con las necesidades del
programa. Es importante recordar que las pilas siguen el principio LIFO (Last In, First Out), lo
que significa que el último elemento que se añade a la pila es el primero en ser eliminado.

4. Ejemplo de tratamiento en Modo lifo:
class Pila:
def __init__(self):
self.items = []
def estaVacia(self):
return self.items == []
def apilar(self, item):
self.items.append(item)
def desapilar(self):
return self.items.pop()
def inspeccionar(self):
return self.items[len(self.items)-1]
def tamano(self):
return len(self.items)
Operaciones a realizar con estructura de pilas en la informática:
Las operaciones que se pueden realizar con una estructura de datos de pila son las siguientes:
1. Insertar un elemento (PUSH): Esta operación agrega un elemento a la pila. Los pasos
para realizar esta operación son:
o Verificar que la pila no se encuentre llena (es decir que el tope sea menor a
máximo -1).
o Incrementar el tope.
o Insertar el elemento.
2. Eliminar un elemento (POP): Esta operación elimina un elemento de la pila. Los pasos
para realizar esta operación son:
o Verificar que la pila no esté vacía (es decir que el tope sea diferente de -1).
o Mostrar el dato que se va a eliminar (el elemento que se encuentra en el
tope).
o Decrementar el tope.
3. TOP / PEEK: Esta operación devuelve el valor del elemento actual en la parte superior
de la pila, sin eliminarlo realmente.
Además, existen operaciones auxiliares para verificar el estado de la pila:
 Pila llena: Se verifica si el tope es igual a máximo -1.
 Pila vacía: Se verifica si el tope es igual a -1.

5. Ejemplo:
class Pila:
def __init__(self):
self.pila = []
# Operación PUSH
def apilar(self, dato):
self.pila.append(dato)
# Operación POP
def desapilar(self):
if self.pila:
return self.pila.pop()
else:
return "La pila está vacía"
# Operación PEEK
def cima(self):
if self.pila:
return self.pila[-1]
else:
return "La pila está vacía"
# Crear una pila
p = Pila()
# Apilar datos
p.apilar("dato 1")
p.apilar("dato 2")
p.apilar("dato 3")
# Ver la cima de la pila
print(p.cima()) # Salida: "dato 3"
# Desapilar datos
print(p.desapilar()) # Salida: "dato 3"
print(p.desapilar()) # Salida: "dato 2"
print(p.desapilar()) # Salida: "dato 1"
Este código define una clase Pila que tiene métodos para las
operaciones push, pop y peek. Luego, crea una instancia de Pila, apila algunos datos,
muestra la cima de la pila y finalmente desapila todos los datos

6. Diseñar Algoritmos elementales para el tratamiento de pila:
1. Algoritmo para insertar un elemento en la pila (PUSH):
def push(pila, elemento):
pila.append(elemento)
2. Algoritmo para eliminar un elemento de la pila (POP):
def pop(pila):
if len(pila) > 0:
return pila.pop()
else:
return "Error: la pila está vacía".
3. Algoritmo para ver el elemento en la cima de la pila (PEEK):
def peek(pila):
if len(pila) > 0:
return pila[-1]
else:
return "Error: la pila está vacía"
4. Algoritmo para verificar si la pila está vacía:
def is_empty(pila):
return len(pila) == 0
(Todos los códigos están basados en python)