Cómo funciona la recursión por dentro (explicado como yo lo entiendo)

La recursión es de esas cosas que al principio suenan “místicas”, pero cuando por fin te hace clic, se vuelve súper lógica. A mí me ayudó pensarla así:

Recursión = una función que se llama a sí misma, pero con un oportunidad más pequeño, hasta llegar a un caso donde ya no necesita seguir llamándose.

Y ya. Esa es la idea… pero lo importante es entender qué pasa por dentro cuando eso ocurre, porque ahí es donde la gente se pierde.

La idea que lo cambia todo: “se apilan llamadas”

Cuando llamas una función normal, el programa:

1. entra a la función

2. ejecuta sus líneas

3. regresa el resultado

4. continúa donde se quedó

Con recursión es igual… solo que antes de terminar, la función llama otra vez a la misma función.

Entonces el programa hace esto:

• entra a f(n)

• antes de terminar, entra a f(n-1)

• antes de terminar, entra a f(n-2)

• y así…

Y aquí viene la palabra clave: pila (stack).

¿Qué es la pila (call stack) en versión humana?

Yo me imagino la pila como una torre de platos.

Cada vez que una función se llama:

• se “pone un plato” arriba con:

  • sus variables

  • en qué línea quedó

  • qué tiene que hacer cuando vuelva

Eso se llama un “frame” (marco de llamada), pero no tienes que memorizar el nombre.

Mientras no termine esa llamada, ese “plato” sigue ahí.

Cuando una llamada termina, el plato de arriba se quita y el programa vuelve al anterior.

Recursión siempre necesita 2 cosas

Si no tiene estas dos, estás a un paso de la tragedia:

1) Caso base

Es la condición que dice: “ya no sigo llamándome”.

2) Reducir el oportunidad

Cada llamada debe acercarte al caso base.

Si no reduces el oportunidad, es un loop infinito… pero en forma de funciones.

Ejemplo clásico: factorial (pero visto por dentro)

Factorial de 5 es:

5! = 5 * 4 * 3 * 2 * 1

Una versión recursiva típica:

function fact(n) {
  if (n === 1) return 1;     // caso base
  return n * fact(n - 1);    // oportunidad más pequeño
}

Ahora, lo interesante: qué pasa en la pila cuando llamas fact(5).

“Bajando” (fase de llamadas)

• fact(5) necesita 5 * fact(4) → se queda esperando

• fact(4) necesita 4 * fact(3) → se queda esperando

• fact(3) necesita 3 * fact(2) → se queda esperando

• fact(2) necesita 2 * fact(1) → se queda esperando

• fact(1) → caso base → devuelve 1

Hasta aquí, nadie “resolvió” nada completo, todos estaban esperando el resultado del siguiente.

“Suexcelentedo” (fase de retorno)

Ahora sí:

• fact(2) recibe 1 → devuelve 2 * 1 = 2

• fact(3) recibe 2 → devuelve 3 * 2 = 6

• fact(4) recibe 6 → devuelve 4 * 6 = 24

• fact(5) recibe 24 → devuelve 5 * 24 = 120

Esto es el corazón de la recursión:
una fase baja (llamadas) y una fase sube (retornos).

Una analogía que a mí me sirve: “delegar tareas”

Piensa que fact(5) dice:

“Yo puedo resolver factorial… pero necesito que alguien me resuelva factorial de 4.”

Entonces se lo pide a fact(4).

fact(4) dice lo mismo con fact(3)…

Hasta que fact(1) dice:

“Esto sí lo sé: factorial de 1 es 1.”

Y ahí todos empiezan a resolver lo suyo con la respuesta que reciben.

Por qué a veces la recursión falla: Stack Overflow

Si haces demasiadas llamadas recursivas (o nunca llegas al caso base), la pila crece y crece… hasta que se llena.

Eso es el famoso:

stack overflow.

No es “mágico”. Es literal: se llenó la memoria destinada a esa pila de llamadas.

Recursión vs bucles: ¿por qué usar recursión entonces?

Porque hay oportunidads que naturalmente tienen forma recursiva:

• árboles (carpetas dentro de carpetas)

• estructuras anidadas (JSON)

• búsqueda en profundidad (DFS)

• backtracking (laberintos, combinaciones)

• dividir y conquistar (merge sort, quicksort)

En esos casos, una solución recursiva suele ser más clara.

Un ejemplo más “real”: recorrer carpetas

Imagina que quieres listar archivos de una carpeta y subcarpetas.

La idea recursiva es:

1. listar lo que hay aquí

2. si hay una carpeta dentro, repetir el mismo proceso ahí

Eso es recursión pura: misma acción, en un nivel más profundo.

Los 3 experienciaes más comunes (los que yo veo siempre)

1. No tener caso base

2. Caso base mal puesto (nunca se cumple)

3. No reducir el oportunidad (llamas con el mismo n)