edubun
Español

Pilas

Comprobar que los paréntesis de {[()()]} se emparejan bien lleva una pila y 8 push y pop, uno por cada símbolo.

El último en entrar, el primero en salir

Piensa en una pila de platos. Pones un plato limpio encima y, cuando necesitas uno, lo tomas de arriba. El plato que pusiste al final es el primero en salir. Una pila es una estructura de datos con exactamente esa regla, llamada último en entrar, primero en salir (LIFO, por sus siglas en inglés). Ofrece dos operaciones principales: push pone un valor encima, y pop quita el valor de arriba y lo devuelve. Muchas pilas también ofrecen peek, que mira el valor de arriba sin quitarlo.

En las notas del 6.006 del MIT, la pila es un caso particular de la interfaz de secuencia: insert last(x) y delete last(). Eso ya te dice cómo construir una. Pon los valores en un arreglo dinámico y trata el final del arreglo como la cima. En la unidad anterior, el final era el extremo barato, así que push y pop cuestan 1 paso cada uno (amortizado, por la copia ocasional). El tamaño de la pila no importa. Hacer pop en una pila de 3 valores o de 3 millones es el mismo paso único.

const stack = [];
stack.push(4);
stack.push(8);
stack.push(5);
console.log(stack.pop());           // 5, el último que entró
console.log(stack[stack.length - 1]); // peek: 8
console.log(stack.length);          // 2
Cargando

Arrastra para girar. Desplaza o pellizca para acercar.

Una pila dibujada como un montón. Push y pop solo trabajan en la cima. Elige una cadena de paréntesis y pulsa Comprobar paréntesis para ver cómo una pila decide si está equilibrada.

Comprobar paréntesis

Un uso clásico de la pila es comprobar que los paréntesis estén equilibrados, algo que hacen todos los editores de código y compiladores. Lee el texto de izquierda a derecha. Cada símbolo de apertura, (, [ o {, se mete en la pila. Cada símbolo de cierre debe coincidir con el de apertura que está en la cima: si coincide, se saca ese símbolo de apertura; si la pila está vacía o el de arriba es de otro tipo, la cadena no está equilibrada. Al final la pila debe quedar vacía; si no, algún símbolo de apertura nunca se cerró.

Prueba las cadenas en el laboratorio. {[()()]} necesita 4 push y 4 pop, 8 pasos, y termina con la pila vacía. ([)] falla en el tercer carácter: el ) llega cuando [ está en la cima. (() llega hasta el final con un ( de sobra. ¿Por qué una pila sirve para esto? Los paréntesis se anidan, y el que se abrió más recientemente debe ser el primero en cerrarse. Eso es último en entrar, primero en salir.

Dónde más aparecen las pilas

  • La pila de llamadas. Cuando la función a llama a b y b llama a c, la computadora apila un registro por cada llamada. Cuando c termina, su registro se saca y b continúa donde se había quedado. Una recursión infinita llena esta pila, y ese es el error de "desbordamiento de pila" (stack overflow).
  • Deshacer. Un editor apila cada cambio. Deshacer saca el cambio más reciente y lo revierte.
  • El botón Atrás. Un navegador apila cada página que dejas; Atrás saca la última.
  • Búsqueda en profundidad. El curso de algoritmos usó una pila para llegar lo más hondo posible en un laberinto antes de retroceder.
ContextoLa pila como idea de computación suele atribuirse a Friedrich L. Bauer y Klaus Samelson, en Múnich. Mientras estudiaban cómo traducir fórmulas aritméticas, guardaban las operaciones pendientes en un almacén donde lo último que entra es lo primero que sale, y lo llamaron Keller, que en alemán significa sótano. Solicitaron una patente del método en 1957, que se les concedió en Estados Unidos en 1962. Más o menos al mismo tiempo, el procesamiento de listas de Allen Newell, Cliff Shaw y Herbert Simon en la RAND Corporation también se apoyaba en pilas, porque sus programas estaban llenos de recursión.
  1. ¿En qué orden devuelve los valores una pila?
    • El primero en entrar, el primero en salir
    • El último en entrar, el primero en salir
    • El más pequeño primero
    • En orden aleatorio
  2. Empieza vacía. Push 4, push 8, push 5, pop, push 2. ¿Qué hay en la cima?
    • 4
    • 8
    • 5
    • 2
  3. Después de esas operaciones, ¿cuántos valores hay en la pila?
  4. Push A, luego B, luego C, y después pop hasta vaciarla. Ordena los valores que salen.
  5. ¿Cuántos push y pop en total lleva comprobar {[()()]} con el método de los paréntesis?
  6. Al comprobar ([)] desde la izquierda, ¿dónde falla?
    • En el primer (
    • En [
    • En )
    • En el ] final
  7. ¿Qué está mal en (() ?
    • Llega un símbolo de cierre con la pila vacía
    • Al final queda un ( en la pila
    • Faltan corchetes
    • Nada; está equilibrada
  8. Hacer pop en una pila (guardada en un arreglo dinámico) que contiene 1000 valores, ¿cuántos pasos lleva?
  9. La función main llama a draw, y draw llama a line. Mientras line se ejecuta, ¿qué registro está en la cima de la pila de llamadas?
    • main
    • draw
    • line
    • ninguna
  10. ¿En qué año solicitaron Bauer y Samelson su patente del método de la pila?
    • 1946
    • 1957
    • 1962
    • 1972
Ideas clave
  • Una pila es último en entrar, primero en salir: push en la cima, pop desde la cima.
  • Construida sobre el final de un arreglo dinámico, push y pop cuestan 1 paso cada uno.
  • Para comprobar paréntesis se apilan los de apertura y se hace pop con cada cierre; {[()()]} lleva 8 pasos.
  • La pila de llamadas, deshacer y el botón Atrás son pilas.
Fuentes de este curso (11)
  • MIT OpenCourseWare 6.006 Introduction to Algorithms, Spring 2020 (Demaine, Ku, Solomon)
  • lecture notes 2 Data Structures (interface vs data structure, Sequence and Set interfaces, stack = insert_last/delete_last, queue = insert_last/delete_first, array, linked list, dynamic array, amortized Θ(1) append)
  • 4 Hashing (chaining, pigeonhole collisions, chain length n/m)
  • 6 Binary Trees Part 1 (height, traversal order, O(h) operations) and 7 Binary Trees Part 2: AVL (Adelson-Velsky and Landis, 1962) at ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2020/pages/lecture-notes
  • MDN Web Docs, Array.prototype.shift (shifts all values left by 1)
  • Array.prototype.unshift, Map (insertion order, Map vs Object, spec requires sublinear average access) and Set (developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects)
  • ECMAScript 2025 Language Specification (tc39.es/ecma262)
  • 24.1 Map Objects and 24.2 Set Objects ("must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements")
  • Array.prototype.shift steps (Repeat, while k < len: move element k to k - 1)
  • D. E. Knuth, The Art of Computer Programming vol. 3 (2nd ed. 1998) section 6.4 History (H. P. Luhn, IBM internal memorandum January 1953, hashing with chaining; digit pairs added mod 10, 31415926 -> 4548) via gwern.net copy, and IEEE Spectrum, "Hans Peter Luhn and the Birth of the Hashing Algorithm" (2018)
  • "A brief history of the stack", SIGCIS (sigcis.org/files/A brief history.pdf: Bauer and Samelson applied for the patent in 1957, US 3,047,228 granted July 31, 1962; IPL list processing by Newell, Simon and Shaw at RAND 1956) and Wikipedia, Information Processing Language (Newell, Shaw, Simon, RAND and Carnegie Institute of Technology, about 1956).

Fecha de consulta: 2026-10-18