Podcast sobre Pila (stack)

Kapitoly

La Magia del 'Deshacer'

La Regla de Oro: LIFO

Las Operaciones Básicas: Push y Pop

¿Cómo Funciona por Dentro?

La Velocidad de una Pila: O(1)

Un Ejemplo Paso a Paso

Aplicaciones en el Mundo Real

Resumen y Despedida

Přepis

Carlos: Alguna vez has estado escribiendo un ensayo, borras un párrafo entero por accidente y sientes ese pánico... hasta que presionas Control+Z y, mágicamente, todo vuelve a la normalidad. O cuando estás en tu navegador y le das al botón de "Atrás" para volver a la página anterior... ¿Te has preguntado cómo funciona eso?

Daniela: La respuesta es una estructura de datos sorprendentemente simple y poderosa llamada pila. Y el motivo por el que funciona se reduce a un principio muy fácil de entender.

Carlos: ¡Exacto! Y de eso vamos a hablar hoy. Estás escuchando Studyfi Podcast.

Daniela: Así es, Carlos. Hoy desmitificamos las pilas de datos. Piensa en una pila de platos en la cocina de un restaurante. Solo puedes poner un plato limpio encima de la pila, y solo puedes coger el plato que está hasta arriba, ¿verdad?

Carlos: Claro, si intentas sacar uno del medio... desastre total. Se cae toda la torre.

Daniela: ¡Exactamente! No puedes añadir uno en la base ni sacar uno de en medio sin mover todo. Esa idea tan simple es la esencia de una pila en programación.

Carlos: Entonces, esa es la regla principal, ¿coger siempre de arriba?

Daniela: Esa es la regla de oro. Se conoce como el principio LIFO: "Last In, First Out". En español, "El último en entrar es el primero en salir". El último plato que pusiste en la pila es el primero que vas a coger.

Carlos: Ah, lo contrario a una fila en el supermercado, donde el primero que llega es el primero al que atienden. Eso sería FIFO, "First In, First Out", ¿cierto?

Daniela: ¡Correcto! Esa es otra estructura llamada "cola". Confundirlas es un error muy común, pero la pila es exclusiva: el recién llegado siempre tiene prioridad para salir. ¡Nadie se puede colar!

Carlos: El paraíso de los impacientes.

Daniela: Totalmente. Y para manejar esta pila, tenemos dos operaciones súper importantes. La primera es push.

Carlos: ¿Push como... empujar?

Daniela: Exacto, push o apilar. Es la acción de añadir un nuevo elemento a la cima de la pila. Si pones un plato nuevo sobre la torre de platos, estás haciendo un push.

Carlos: Entendido. Y supongo que la otra operación es para sacar el plato, ¿no?

Daniela: Precisamente. Se llama pop o desapilar. Pop elimina el elemento de la cima de la pila y te lo entrega. Así que, después de un pop, el plato que estaba justo debajo se convierte en la nueva cima.

Carlos: ¿Y qué pasa si la pila de platos ya llega hasta el techo y quiero añadir uno más? O... ¿si no hay platos y quiero coger uno?

Daniela: ¡Excelente pregunta! Esos son dos errores clásicos. Si intentas hacer push en una pila que ya está llena, tienes un error llamado "desbordamiento de pila" o... *stack overflow*. ¿Te suena?

Carlos: ¡Claro! ¡Como la famosa web para programadores! Ahora todo tiene sentido.

Daniela: ¡De ahí viene el nombre! Y si intentas hacer pop en una pila vacía, obtienes un "subdesbordamiento de pila" o *stack underflow*. No puedes sacar algo que no existe.

Carlos: Tiene lógica. ¿Y si solo quiero ver cuál es el plato de arriba sin quitarlo? Para ver si está limpio, por ejemplo.

Daniela: También hay una operación para eso. Se llama peek. Te permite "espiar" el elemento de la cima sin modificar la pila. Además, tenemos isEmpty, que te dice si la pila está vacía, y isFull, para saber si ha llegado a su capacidad máxima.

Carlos: Vale, la analogía de los platos es genial, pero ¿cómo se ve esto en código? ¿Es un montón de ifs y elses?

Daniela: Es más sencillo de lo que crees. La forma más común de implementar una pila es usando un array, que es como una estantería con espacios numerados. Y además del array, solo necesitas una variable, que llamaremos cima.

Carlos: Cima, me gusta. ¿Y qué hace?

Daniela: La variable cima es un simple número que apunta al índice del último elemento que se añadió. Cuando la pila está vacía, podemos decir que cima vale -1, indicando que no hay nada.

Carlos: Ah, ok. Entonces, si hago push para añadir el primer elemento...

Daniela: Primero, el programa incrementa cima de -1 a 0. Luego, guarda tu elemento en la posición 0 del array. Si haces otro push, cima sube a 1 y el nuevo elemento va a la posición 1. Siempre apunta a la cima real.

Carlos: Y para hacer pop... supongo que es al revés. Coges el elemento que está en la posición que indica cima, y luego le restas 1 a cima.

Daniela: ¡Lo tienes! Así de simple. Cima sube con push y baja con pop. Es increíblemente eficiente.

Carlos: ¿Qué tan eficiente? Porque si tengo una pila con diez millones de elementos, ¿no se vuelve más lento añadir uno más?

Daniela: ¡Aquí viene lo mejor! No, no se vuelve más lento. Las operaciones push, pop y peek tienen algo que llamamos **complejidad temporal de O(1)**.

Carlos: O de... ¿uno? Suena rápido.

Daniela: Significa que tardan un tiempo constante. Da igual si la pila tiene 10 elementos o 10 millones. El tiempo para añadir o quitar el elemento de la cima es prácticamente el mismo. ¿Por qué?

Carlos: Porque... ¡solo tienes que mirar la variable cima! No tienes que recorrer toda la lista de elementos.

Daniela: ¡Exacto! Solo modificas el elemento en un extremo y actualizas un número. Es una de las estructuras más rápidas que existen para este tipo de tarea, y por eso es tan usada en aplicaciones donde el rendimiento es crítico.

Carlos: Vale, creo que lo entiendo. ¿Podemos hacer un ejemplo rápido con números?

Daniela: ¡Claro! Imagina una pila vacía con capacidad para 5 elementos. Empezamos con la pila vacía y cima en -1.

Carlos: Listo.

Daniela: Hacemos **Push(10)**. La pila ahora es y cima es 0. Luego, **Push(20)**. Ahora es y cima es 1. Hacemos **Push(30)**, la pila es y cima es 2.

Carlos: Fácil. Tres elementos apilados.

Daniela: Ahora, ¡Pop! ¿Qué pasa?

Carlos: Se va el último que entró... ¡el 30! La pila se queda con y cima vuelve a ser 1.

Daniela: ¡Perfecto! Ahora hacemos **Push(40)**. La pila es y cima vuelve a ser 2. Y si hacemos Peek...

Carlos: Vemos el 40, pero no se elimina. La pila sigue igual. ¿Qué pasa si la llenamos?

Daniela: Buena pregunta. Hacemos **Push(50)**. Pila: , cima es 3. Hacemos **Push(60)**. Pila: , cima es 4. ¡Está llena!

Carlos: Y ahora... si intentamos un **Push(70)**...

Daniela: ¡ERROR! ¡Stack Overflow! El programa se quejaría y no te dejaría añadirlo. La pila se queda como estaba.

Carlos: ¡Qué estricta es la pila!

Daniela: Es su mayor virtud.

Carlos: Ya mencionamos la función "Deshacer" y el botón "Atrás" del navegador. ¿Dónde más se usan las pilas?

Daniela: ¡En todas partes! La más importante es invisible para nosotros: la **pila de llamadas a funciones**. Cuando un programa ejecuta una función, y esa función llama a otra, y esa a otra más... el ordenador usa una pila para recordar a quién tiene que devolver el control.

Carlos: ¡Ah! Por eso cuando hay un error en un programa a veces te muestra un "call stack", ¿es esa la pila?

Daniela: Esa misma. Es fundamental para que los programas funcionen, sobre todo con recursividad. También se usan para evaluar expresiones matemáticas, como las que pones en una calculadora, y para verificar que en tu código todos los paréntesis y corchetes que abres, los cierras correctamente.

Carlos: Vaya, no me imaginaba que algo tan simple como una pila de platos estuviera detrás de tanto.

Daniela: A menudo las ideas más sencillas son las más poderosas en informática.

Carlos: Bueno, para resumir lo que hemos aprendido hoy: una pila es una estructura de datos que funciona con el principio LIFO: el último en entrar es el primero en salir.

Daniela: Sus operaciones principales son push para añadir y pop para quitar, y son súper rápidas, con una complejidad de O(1).

Carlos: Y aunque su implementación es sencilla, normalmente con un array y un puntero a la cima, sus aplicaciones son enormes: desde la función "deshacer" hasta la gestión interna de nuestros programas.

Daniela: Exactamente. La próxima vez que presiones Control+Z, sonríele a esa pequeña y eficiente pila que te acaba de salvar el día.

Carlos: Lo haré. Muchísimas gracias, Daniela, por explicárnoslo tan bien.

Daniela: Un placer, Carlos. ¡Hasta la próxima!

Carlos: Y gracias a todos por escuchar. ¡Nos vemos en el siguiente episodio de Studyfi Podcast!