Saltar al contenido
Home » Pilas

Pilas

Introducción

Una pila es una estructura de datos lineal que sigue el principio LIFO. Los elementos se agregan y eliminan desde la parte superior de la pila. Este concepto se asemeja a apilar platos, donde el último plato colocado es el primero en retirarse. Las operaciones básicas asociadas con una pila son:

  • Push: Agrega un elemento en la parte superior de la pila.
  • Pop: Elimina y devuelve el elemento superior de la pila.
  • Peek: Obtiene el elemento superior sin eliminarlo.

Casos de Uso de las Pilas

Las pilas tienen aplicaciones en una variedad de escenarios:

  • Pila de Llamadas a Funciones: En lenguajes de programación, las pilas administran la ejecución de funciones. Cada llamada a función se coloca en la pila y, cuando una función se completa, se retira de la pila.
  • Evaluación de Expresiones: Las pilas se utilizan para evaluar expresiones, incluyendo notaciones infija, posfija y prefija.
  • Operaciones de Deshacer y Rehacer: Las pilas pueden almacenar el historial de acciones, lo que permite la funcionalidad de deshacer y rehacer en aplicaciones.

Tipos de Implementaciónes

  • Utilizando Arreglos: Una forma común de implementar una pila es mediante el uso de un arreglo. Se mantiene un puntero que apunta al elemento superior de la pila. Al agregar un elemento, se incrementa el puntero, y al eliminarlo, se decrementa.
  • Manejo de Desbordamiento y Subdesbordamiento de la Pila: Es crucial gestionar los escenarios de desbordamiento de la pila (al agregar a una pila llena) y de subdesbordamiento de la pila (al eliminar de una pila vacía) para prevenir errores y bloqueos.
  • Implementación Genérica de la Pila: Las genéricas de Java te permiten crear una pila capaz de contener elementos de cualquier tipo de datos. Esto mejora la reutilización y flexibilidad de tu implementación de pila.

Ejemplos

				
					 import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.List;
public class Pila<T> {
    private List<T> listaPila;
    public Pila() {
        listaPila = new ArrayList<>();
    }
    public void push(T elemento) {
        listaPila.add(elemento);
    }
    public T pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return listaPila.remove(listaPila.size() - 1);
    }
    public T peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return listaPila.get(listaPila.size() - 1);
    }
    public boolean isEmpty() {
        return listaPila.isEmpty();
    }
    public int tama&#xF1;o() {
        return listaPila.size();
    }
    public static void main(String[] args) {
        Pila<Integer> pila = new Pila<>();
        pila.push(10);
        pila.push(20);
        pila.push(30);
        System.out.println("Tama&#xF1;o de la pila: " + pila.tama&#xF1;o()); // Salida: Tama&#xF1;o de la pila: 3
        System.out.println("Elemento en la cima: " + pila.peek());   // Salida: Elemento en la cima: 30
        int elementoSacado = pila.pop();
        System.out.println("Elemento sacado: " + elementoSacado); // Salida: Elemento sacado: 30
        System.out.println("&#xBF;La pila est&#xE1; vac&#xED;a? " + pila.isEmpty()); // Salida: &#xBF;La pila est&#xE1; vac&#xED;a? false
    }
}

Errores Comunes 

  • Olvidar Verificar si la Pila Está Vacía: Siempre verifica si la pila está vacía antes de realizar operaciones de eliminación o consulta para evitar excepciones en tiempo de ejecución.
  • Uso de Pilas frente a Otras Estructuras de Datos: Aunque las pilas son excelentes para ciertos escenarios, considera si otras estructuras de datos podrían ser más adecuadas para tu problema específico.

Análisis de Rendimiento

  • Complejidad Temporal de las Operaciones de la Pila: Las operaciones de agregar, eliminar y consultar en una pila implementada mediante arreglos tienen una complejidad temporal constante de O(1).
  • Consumo de Memoria: La memoria requerida por una pila depende del número de elementos que contiene y de los detalles de la implementación.

Conclusión

En este tutorial, hemos explorado la estructura de datos pila en Java, desde sus conceptos fundamentales hasta casos de uso en el mundo real y detalles de implementación. Comprender las pilas te brinda una herramienta poderosa para resolver diversos desafíos de programación de manera eficiente. Al dominar las pilas, has dado un paso significativo para convertirte en un programador competente capaz de administrar datos de manera elegante en tus aplicaciones.

Etiquetas: