Pilas (Stacks): Un Viaje por el Mundo de Gumball

---

¡Hola Chiquis!👋🏻 continuando con la semana de Estructura de Datos, hoy vamos a conocer sobre las Pilas (Stacks). Vamos a explorar cómo funcionan las pilas utilizando a los personajes de Gumball para hacer la explicación más divertida y comprensible.

En el universo de El Asombroso Mundo de Gumball, cada personaje tiene su propio rol y características únicas. De manera similar, en el mundo de la programación, las pilas (stacks) son estructuras de datos que siguen un principio específico para organizar y manipular elementos.   Imagina la casa de los Wattersons como una pila gigante. En esta pila, los objetos se apilan uno encima del otro, siguiendo un orden específico: el último en entrar es el primero en salir (LIFO, por sus siglas en inglés).

¿Qué es una Pila? Una pila es una estructura de datos lineal que sigue el principio LIFO. Piensa en ella como una torre de bloques: el bloque que colocas encima es el primero que quitarás.

Una pila es una estructura de datos lineal que sigue el principio de Last In, First Out (LIFO), es decir, el último elemento en entrar es el primero en salir. Imagina una pila de platos en la cocina de la familia Watterson: el último plato que colocas en la pila es el primero que tomas cuando necesitas uno.

Imaginemos que Gumball y sus amigos están apilados uno sobre otro en una pila. Cada vez que alguien necesita salir de la pila, el último en entrar es el primero en salir. Ejemplo:

import java.util.Stack;

public class PilaGumball {
    public static void main(String[] args) {
        Stack<String> pila = new Stack<>();
        // Gumball y sus amigos se apilan
        pila.push("Gumball");
        pila.push("Darwin");
        pila.push("Anais");
        pila.push("Nicole");
        pila.push("Richard");
        // Imprimir el estado inicial de la pila
        System.out.println("Pila inicial: " + pila);
        // Ver el elemento superior (peek)
        System.out.println("Elemento en la cima: " + pila.peek());
        // Eliminar el elemento superior (pop)
        System.out.println("Elemento eliminado: " + pila.pop());
        // Imprimir el estado de la pila después de un pop
        System.out.println("Pila después de un pop: " + pila);
        // Verificar si la pila está vacía
        System.out.println("¿La pila está vacía? " + pila.isEmpty());
    }
}

En este ejemplo, Gumball y sus amigos se apilan en la pila. Cuando eliminamos un elemento con pop, Richard, que fue el último en entrar, es el primero en salir.

Características de las Pilas:

• LIFO: El último elemento añadido es el primero en ser eliminado.
• Operaciones básicas: push (añadir un elemento), pop (eliminar el elemento superior), peek (ver el elemento superior sin eliminarlo), isEmpty (verificar si la pila está vacía).

Operaciones básicas de una pila:

• Push: Agregar un elemento a la cima de la pila. En nuestro ejemplo de Gumball, sería como poner un nuevo objeto en la pila de la casa.

Push (Añadir un elemento):

pila.push("Gumball");

Gumball se añade a la pila.

• Pop: Eliminar el elemento de la cima de la pila. Equivaldría a quitar el último objeto que se colocó en la pila.

Pop (Eliminar el elemento superior):

String personaje = pila.pop();

El personaje en la cima de la pila (el último añadido) se elimina y se guarda en la variable personaje.

• Peek: Ver el elemento que está en la cima de la pila, sin eliminarlo. Sería como mirar el objeto que está en la parte superior de la pila sin moverlo.

Peek (Ver el elemento superior sin eliminarlo):

String personaje = pila.peek();

Vemos quién está en la cima de la pila sin eliminarlo.

• isEmpty (Verificar si la pila está vacía):

boolean vacia = pila.isEmpty();

Verificamos si la pila está vacía.

Usos Comunes de las Pilas Las pilas se utilizan en muchos contextos en programación, incluyendo:

• Evaluación de expresiones: Para evaluar expresiones matemáticas o lógicas.
• Navegación de historiales: Como en los navegadores web, donde el historial de páginas visitadas se maneja como una pila.
• Manejo de recursión: Las llamadas recursivas se gestionan utilizando una pila.

Ejemplo de Evaluación de Expresiones:

public int evaluarExpresion(String expresion) {
    Stack<Integer> pila = new Stack<>();
    for (char c : expresion.toCharArray()) {
        if (Character.isDigit(c)) {
            pila.push(c - '0');
        } else {
            int b = pila.pop();
            int a = pila.pop();
            switch (c) {
                case '+': pila.push(a + b); break;
                case '-': pila.push(a - b); break;
                case '*': pila.push(a * b); break;
                case '/': pila.push(a / b); break;
            }
        }
    }
    return pila.pop();
}

En este ejemplo, evaluamos una expresión matemática utilizando una pila para manejar los operandos y operadores.

Analogías con Gumball

• El armario de Darwin: Cada vez que Darwin encuentra algo interesante, lo mete en su armario. El último objeto que metió será el primero que saque cuando lo necesite.
• La pila de tareas de Nicole: Nicole siempre tiene una pila de tareas por hacer. La tarea que está en la cima de la pila es la siguiente que realizará.
• La máquina expendedora de caramelos: Los caramelos se apilan uno encima del otro. Cuando compras uno, el último caramelo que se agregó es el primero que sale.

Implementación en Programación Las pilas se pueden implementar utilizando diferentes estructuras de datos, como arreglos o listas enlazadas. En la mayoría de los lenguajes de programación, existen estructuras de datos predefinidas para representar pilas.

Ejemplo:

stack = []
stack.append(1)  # Push: Agregar el número 1 a la pila
stack.append(2)
stack.append(3)

print(stack.pop())  # Pop: Imprime 3 y lo elimina de la pila
print(stack)        # Imprime [1, 2]

Aplicaciones de las Pilas

• Retroceso (backtracking): En algoritmos de búsqueda, las pilas se utilizan para almacenar estados anteriores y volver a ellos si es necesario.
• Evaluación de expresiones: Las pilas se utilizan para evaluar expresiones aritméticas y expresiones infijas.
• Gestión de llamadas a funciones: La pila de llamadas se utiliza para mantener un registro de las funciones que se están ejecutando.
• Exploración de laberintos: Las pilas se utilizan en algoritmos de búsqueda en profundidad para explorar un laberinto.

Tips Pilas (Stacks)

• Definición: Estructura de datos LIFO (Last In, First Out), donde los elementos se añaden y eliminan por un extremo.
• Características: Operaciones básicas: push (añadir) y pop (eliminar).
• Usos: Manejo de llamadas a funciones, retroceso en algoritmos, etc.
• Imagen:

Fuente: www.geeksforgeeks.org

En Resumen Las pilas son una estructura de datos fundamental en programación, y su funcionamiento se puede entender fácilmente a través de analogías cotidianas como la pila de platos en el fregadero o la pila de libros en un estante. Al comprender el concepto de pila, podrás resolver una amplia variedad de problemas algorítmicos.

Conclusión Las pilas son una estructura de datos fundamental en programación, y entender su funcionamiento es crucial para resolver muchos problemas de manera eficiente. Utilizando la analogía de El Asombroso Mundo de Gumball, hemos visto cómo las pilas organizan y manipulan elementos siguiendo el principio LIFO. 

¡Gracias por leer y déjame tus comentarios! 👇🏻

🚀 ¿Te ha gustado? Comparte tu opinión. Artículo completo, visita: https://lnkd.in/ewtCN2Mn https://lnkd.in/eAjM_Smy 👩💻 https://lnkd.in/eKvu-BHe https://dev.to/orlidev https://lnkd.in/ecHHabTD https://pin.it/2BuZ9N4n8 https://linktr.ee/orlidevs ¡No te lo pierdas!

Referencias: Imágenes creadas con: Copilot ( microsoft.com )

#PorUnMillóndeAmigos #MakeYourselfVisible