C Academy · Lección

Cómo funciona la recursión

Casos base y pila de llamadas

Cómo funciona la recursión es una lección gratuita de C Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

¿Qué es la recursividad?

La recursividad ocurre cuando una función se llama a sí misma para resolver un problema. Cada llamada trabaja con una parte más pequeña del problema original.

En C, cualquier función puede llamarse a sí misma, siempre que exista una forma de que las llamadas terminen finalmente.

El caso base

Toda función recursiva necesita un caso base: una condición en la que deja de llamarse a sí misma y devuelve el resultado directamente.

Sin un caso base, la función se llamaría eternamente y el programa se bloquearía.

int countdown(int n) {
    if (n == 0) return 0; /* base case */
    return countdown(n - 1);
}

El caso recursivo

El caso recursivo es la parte en la que la función se llama a sí misma con un argumento modificado.

Ese argumento debe avanzar hacia el caso base; de lo contrario, la recursividad nunca termina.

int sum_to(int n) {
    if (n == 0) return 0;       /* base case */
    return n + sum_to(n - 1);   /* recursive case */
}

Un primer programa completo

Ejecutemos un programa completo que suma los números del 1 al 5 mediante recursividad.

El resultado debería ser 15.

#include <stdio.h>

int sum_to(int n) {
    if (n == 0) return 0;
    return n + sum_to(n - 1);
}

int main(void) {
    printf("%d\n", sum_to(5));
    return 0;
}

Seguir el rastro de las llamadas

Resulta útil seguir la recursividad manualmente. Para sum_to(3):

sum_to(3) = 3 + sum_to(2)
sum_to(2) = 2 + sum_to(1)
sum_to(1) = 1 + sum_to(0)
sum_to(0) = 0

Después, las llamadas devuelven los resultados hacia arriba: 1, luego 3 y finalmente 6.

La pila de llamadas

Cada llamada a una función obtiene su propio espacio en la pila de llamadas, donde se almacenan sus parámetros y variables locales.

Al profundizar, los marcos se van acumulando. Cuando una llamada devuelve el resultado, su marco se elimina y el control vuelve a quien la llamó.

Profundización y desenrollado

La recursividad tiene dos fases. La profundización ocurre mientras las llamadas avanzan hacia el caso base.

El desenrollado ocurre cuando el caso base devuelve el resultado y cada llamada termina su trabajo usando el valor devuelto.

#include <stdio.h>

int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

int main(void) {
    printf("%d\n", factorial(4));
    return 0;
}

Los valores devueltos regresan

El valor devuelto por una llamada más profunda lo utiliza la llamada que la realizó.

Por eso el orden es importante: la llamada más profunda termina primero y, después, los resultados se combinan al volver por la pila.

int power(int base, int exp) {
    if (exp == 0) return 1;
    return base * power(base, exp - 1);
}

Imprimir durante la recursividad

Puede imprimir antes o después de la llamada recursiva. Imprimir antes muestra los números al descender; imprimir después los muestra al ascender.

#include <stdio.h>

void down(int n) {
    if (n == 0) return;
    printf("%d ", n);
    down(n - 1);
}

int main(void) {
    down(5);
    printf("\n");
    return 0;
}

Imprimir al ascender

Coloque printf después de la llamada recursiva y el orden se invertirá. La llamada más profunda imprimirá primero.

Esto imprime 1 2 3 4 5 en lugar de 5 4 3 2 1.

#include <stdio.h>

void up(int n) {
    if (n == 0) return;
    up(n - 1);
    printf("%d ", n);
}

int main(void) {
    up(5);
    printf("\n");
    return 0;
}

Dos reglas que debe recordar

Una función recursiva correcta sigue dos reglas:

1. Tiene al menos un caso base que devuelve el resultado sin recurrir.
2. Cada llamada recursiva acerca el argumento a un caso base.

Si incumple cualquiera de las dos reglas, el programa entra en un bucle infinito.

Comprobación rápida

Compruebe su comprensión de los conceptos básicos de la recursividad.

Resumen

La recursividad resuelve un problema llamándose a sí misma con una entrada más pequeña. Siempre necesita un caso base que la detenga y un caso recursivo que avance hacia él.

Cada llamada utiliza un marco de la pila; los resultados regresan mientras las llamadas se desenrollan.

Preguntas frecuentes

¿La lección «Cómo funciona la recursión» es gratis?

Sí — el texto completo de «Cómo funciona la recursión» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Cómo funciona la recursión»?

Casos base y pila de llamadas Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Cómo funciona la recursión»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C Academy