Pilas

El término "pila" (stack en inglés) se refiere a una estructura de datos lineal que sigue el
principio de LIFO (Last In, First Out), es decir, el último elemento en entrar es el primero en
salir. Funciona de manera similar a una pila de platos: puedes agregar o quitar elementos
solo desde el tope de la pila, generalmente admite dos operaciones principales:

1. Push: Agrega un elemento a la parte superior de la pila.

2. Pop: Elimina y devuelve el elemento en la parte superior de la pila.

Además de estas operaciones básicas, también es común tener operaciones como "peek"
que permiten ver el elemento en la parte superior de la pila sin eliminarlo, y "isEmpty" para
verificar si la pila está vacía.

Las pilas son utilizadas en una variedad de aplicaciones informáticas, incluyendo la gestión
de llamadas de funciones en la memoria durante la ejecución de programas, la evaluación
de expresiones matemáticas, el seguimiento de historiales en navegadores web y la
implementación de algoritmos como la inversión de cadenas o la resolución de problemas
de laberintos, entre otros.

Características
1. LIFO (Last In, First Out): La característica fundamental de una pila es su principio de
funcionamiento. El último elemento que se inserta en la pila es el primero en ser
eliminado.

2. Operaciones limitadas: Las operaciones principales en una pila suelen ser push (agregar
un elemento) y pop (eliminar un elemento). Estas operaciones están restringidas a trabajar
solo en el extremo superior de la pila.
 3. Estructura de datos simple: Las pilas son estructuras de datos simples y eficientes,
generalmente implementadas como estructuras de arrays o listas en los lenguajes de
programación.

4. No se permite el acceso aleatorio: A diferencia de otras estructuras de datos como los

arrays o las listas enlazadas, no es posible acceder a los elementos de una pila
arbitrariamente. Solo se puede acceder al elemento superior.

5. Eficiencia en tiempo constante: Las operaciones push y pop en una pila suelen tener una
complejidad temporal constante, lo que significa que su rendimiento no depende del
tamaño total de la pila.

6. Uso en llamadas de funciones: Las pilas son fundamentales en la gestión de llamadas de

funciones en la memoria durante la ejecución de programas. Cada vez que se llama a una
función, se crea un marco de pila para almacenar las variables locales y la información de
retorno, y cuando la función termina, ese marco de pila se elimina.

7. Aplicaciones variadas: Las pilas se utilizan en una variedad de aplicaciones informáticas,

que van desde la gestión de la memoria en sistemas operativos hasta la evaluación de
expresiones matemáticas en compiladores y calculadoras, entre otros.

Representación
Las pilas pueden representarse de varias formas en la programación, siendo las más comunes:

1. Array (arreglo): En esta representación, se utiliza un arreglo unidimensional para

almacenar los elementos de la pila. Se reserva un tamaño fijo para el arreglo y se utiliza un
índice para mantener un seguimiento del tope de la pila. Esta implementación es simple y
eficiente en cuanto a acceso, pero puede requerir redimensionamiento del arreglo si la pila
crece más allá de su tamaño inicial.

class Stack:
def __init__(self, capacity):
self.capacity = capacity
self.array = [None] * capacity
self.top = -1

def push(self, item):

if self.top == self.capacity - 1:
 print("Stack Overflow")
return
self.top += 1
self.array[self.top] = item

def pop(self):
if self.top == -1:
print("Stack Underflow")
return None
item = self.array[self.top]
self.top -= 1
return item

2. Lista enlazada: En esta representación, cada nodo de la lista contiene un elemento de la

pila y un enlace al siguiente nodo. El tope de la pila se representa mediante el primer nodo
de la lista. Esta implementación permite una gestión dinámica del tamaño de la pila, pero
puede ser menos eficiente en cuanto a acceso que la implementación con array.

class Node:
def __init__(self, data):
self.data = data
self.next = None

class Stack:
def __init__(self):
self.top = None

def push(self, item):

new_node = Node(item)
new_node.next = self.top
self.top = new_node

def pop(self):
if self.is_empty():
print("Stack Underflow")
return None
item = self.top.data
self.top = self.top.next
return item

def is_empty(self):
return self.top is None
 Métodos para modificar el
comportamiento de una pila:
Tratar una pila en modo FIFO:

1. Implementar una cola usando dos pilas: utilizar dos pilas para simular el comportamiento
de una cola. Los elementos se agregan a una pila (pila de entrada) y luego se eliminan de
otra pila (pila de salida). Cuando la pila de salida está vacía y se necesita eliminar un
elemento, puedes transferir todos los elementos de la pila de entrada a la pila de salida y
luego eliminar el elemento superior de la pila de salida.

2. Implementar una cola usando una pila: También es posible implementar una cola
utilizando solo una pila. Esto se puede lograr mediante la reversión de los elementos de la
pila temporalmente cuando necesitas eliminar un elemento. Después de eliminar el
elemento, puedes revertir los elementos nuevamente para mantener el orden original.

class QueueUsingStack:
def __init__(self):
self.stack_in = []
self.stack_out = []

def enqueue(self, item):

self.stack_in.append(item)

def dequeue(self):
if not self.stack_out:
if not self.stack_in:
print("Queue is empty")
return None
while self.stack_in:
self.stack_out.append(self.stack_in.pop())
return self.stack_out.pop()

queue = QueueUsingStack()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)

print(queue.dequeue())
print(queue.dequeue())
El modo LIFO (Last In, First Out) es el comportamiento natural de una pila, donde el último
elemento que se inserta es el primero en ser eliminado.

class Stack:
def __init__(self):
self.items = []

def push(self, item):

self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()
else:
print("Stack is empty")
return None

def peek(self):
if not self.is_empty():
return self.items[-1]
else:
print("Stack is empty")
return None

def is_empty(self):
return len(self.items) == 0

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

stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

print("Tamaño de la pila:", stack.size())

print("Elemento superior de la pila:", stack.peek())

print("Pop:", stack.pop())
print("Pop:", stack.pop())

print("Tamaño de la pila después de pops:", stack.size()