¿Que es una Pila o Stack?
Una pila (o stack, en inglés) es una estructura de datos lineal que sigue el principio LIFO (Last In, First Out), lo que significa que el último elemento en entrar es el primero en salir. Imagina una pila de platos: el último que colocas en la pila es el primero que tomas.
Las pilas son muy utilizadas en programación debido a su simplicidad y eficiencia para resolver problemas como manejo de expresiones, algoritmos de retroceso (backtracking), control de llamadas en funciones recursivas, y más.
Estructura de una Pila
La pila tiene dos operaciones principales:
Push: Agregar un elemento al tope de la pila.
Pop: Eliminar el elemento del tope de la pila.
Además, a menudo incluye una operación para consultar el elemento superior sin eliminarlo (Peek) y verificar si la pila está vacía (isEmpty).
Restricción: El acceso a los elementos de la pila está limitado: solo se puede operar con el último elemento (el de la parte superior).
Implementación
Una pila puede implementarse de varias formas:
Con arreglos: Se utiliza un array dinámico con un índice para controlar la cima.
Con listas enlazadas: Cada nodo apunta al siguiente, y la cima se mueve dinámicamente.
Aplicaciones de las pilas
Gestión de recursividad: Los lenguajes de programación usan pilas para rastrear llamadas a funciones recursivas.
Historial de navegación: Navegadores web usan pilas para implementar las acciones "Atrás" y "Adelante".
Deshacer y rehacer: En editores de texto o diseño gráfico.
Algoritmos: Se utilizan en algoritmos de búsqueda como DFS (Depth First Search).
Paréntesis balanceados: Verifica expresiones matemáticas o código fuente.
Evaluación de expresiones: Cálculo de expresiones matemáticas en notación postfija.
Ventajas
Simplicidad y rapidez para operaciones en la cima.
Uso eficiente de memoria para tareas específicas.
Desventajas
Acceso limitado, no se pueden manipular elementos intermedios directamente.
Tamaño fijo si se usa un arreglo (a menos que sea dinámico).
Ejemplos de Pilas en Diferentes Lenguajes
A continuación, veremos cómo implementar y utilizar una pila en diferentes lenguajes de programación.
JavaScript
En JavaScript, podemos usar arrays para simular una pila, ya que tienen métodos nativos como push y pop.
class Pila {
constructor() {
this.elementos = [];
}
push(dato) {
this.elementos.push(dato); // Agregar elemento
}
pop() {
return this.elementos.pop(); // Eliminar el último elemento
}
peek() {
return this.elementos[this.elementos.length - 1]; // Consultar el último elemento
}
isEmpty() {
return this.elementos.length === 0; // Verificar si está vacía
}
}
const pila = new Pila();
pila.push(10);
pila.push(20);
console.log(pila.peek()); // Muestra 20
console.log(pila.pop()); // Elimina y muestra 20
console.log(pila.isEmpty()); // Muestra false
C#
En C#, puedes usar la clase Stack del espacio de nombres System.Collections.Generic.
using System;
using System.Collections.Generic;
class Program {
static void Main() {
Stack<int> pila = new Stack<int>();
pila.Push(10);
pila.Push(20);
Console.WriteLine(pila.Peek()); // Muestra 20
Console.WriteLine(pila.Pop()); // Elimina y muestra 20
Console.WriteLine(pila.Count == 0); // Verifica si está vacía: false
}
}
PHP
No tiene una clase de pila específica, pero puedes usar un array como pila.
class Pila {
private $elementos = [];
public function push($dato) {
array_push($this->elementos, $dato); // Agregar elemento
}
public function pop() {
return array_pop($this->elementos); // Eliminar el último elemento
}
public function peek() {
return end($this->elementos); // Consultar el último elemento
}
public function isEmpty() {
return empty($this->elementos); // Verificar si está vacía
}
}
$pila = new Pila();
$pila->push(10);
$pila->push(20);
echo $pila->peek(); // Muestra 20
echo $pila->pop(); // Elimina y muestra 20
echo $pila->isEmpty(); // Muestra false
Java
En Java, puedes usar la clase Stack de la biblioteca estándar, o implementarla manualmente con listas.
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Stack<Integer> pila = new Stack<>();
pila.push(10);
pila.push(20);
System.out.println(pila.peek()); // Muestra 20
System.out.println(pila.pop()); // Elimina y muestra 20
System.out.println(pila.isEmpty()); // Muestra false
}
}
C
las pilas se implementan usando arrays y punteros para manejar la posición del tope.
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
typedef struct {
int elementos[MAX];
int tope;
} Pila;
void push(Pila* pila, int dato) {
if (pila->tope == MAX - 1) {
printf("Pila llena\n");
return;
}
pila->elementos[++pila->tope] = dato;
}
int pop(Pila* pila) {
if (pila->tope == -1) {
printf("Pila vacía\n");
return -1;
}
return pila->elementos[pila->tope--];
}
int peek(Pila* pila) {
if (pila->tope == -1) {
printf("Pila vacía\n");
return -1;
}
return pila->elementos[pila->tope];
}
int main() {
Pila pila = {{0}, -1};
push(&pila, 10);
push(&pila, 20);
printf("%d\n", peek(&pila)); // Muestra 20
printf("%d\n", pop(&pila)); // Elimina y muestra 20
printf("%d\n", pila.tope == -1); // Verifica si está vacía: 0 (false)
return 0;
}
C++
Puedes usar la clase std::stack o implementar una pila con vectores.
#include <iostream>
#include <stack>
using namespace std;
int main() {
stack<int> pila;
pila.push(10);
pila.push(20);
cout << pila.top() << endl; // Muestra 20
pila.pop();
cout << pila.top() << endl; // Muestra 10
cout << pila.empty() << endl; // Verifica si está vacía: 0 (false)
return 0;
}
Las pilas son una estructura de datos simple pero poderosa, ideal para problemas que requieren un enfoque LIFO. Aunque algunos lenguajes proporcionan implementaciones listas para usar, otros permiten implementar la pila desde cero para un mayor control. Dominar el uso de pilas es esencial tanto para principiantes como para expertos, ya que son una herramienta fundamental en el diseño y la optimización de algoritmos.
