C Academy · Leçon

Récursion ou itération

Sachez quand choisir l’une ou l’autre.

Récursion ou itération est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

Deux façons de répéter

De nombreux problèmes peuvent être résolus par récursion ou par itération. L’itération utilise des boucles ; la récursion utilise des appels de fonction.

Les deux peuvent produire le même résultat, mais elles diffèrent par leur style, leur utilisation de la mémoire et leur vitesse.

Factorielle avec une boucle

Voici la factorielle écrite de manière itérative avec une boucle for. La fonction ne s’appelle pas elle-même ; une seule variable accumule le produit.

#include <stdio.h>

long factorial(int n) {
    long result = 1;
    for (int i = 2; i <= n; i++)
        result *= i;
    return result;
}

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

Factorielle avec récursion

La version récursive est plus courte et reprend directement la définition mathématique.

Les deux affichent 720 pour factorial(6), mais utilisent des mécanismes différents.

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

Différences de mémoire

L’itération utilise généralement une quantité fixe et réduite de mémoire : seulement quelques variables locales.

La récursion ajoute une trame de pile à chaque appel ; une récursion profonde utilise donc davantage de mémoire et peut manquer d’espace dans la pile.

Différences de vitesse

Chaque appel récursif a un petit coût : la création d’une trame et le retour depuis celle-ci.

Pour les tâches simples de comptage, les boucles sont souvent un peu plus rapides, car elles évitent ce coût d’appel.

Quand la récursion est préférable

La récursion est particulièrement adaptée lorsque le problème est naturellement récursif, comme avec les arbres, les structures imbriquées ou les algorithmes diviser pour régner.

Dans ces cas, le code récursif est plus court et plus clair que la boucle équivalente utilisant une pile gérée manuellement.

Quand l’itération est préférable

Pour une répétition linéaire simple, comme additionner un tableau ou compter, une boucle est plus simple et utilise une mémoire constante.

Elle évite également tout risque de débordement de pile avec de grandes entrées.

int sum_array(int a[], int n) {
    int total = 0;
    for (int i = 0; i < n; i++)
        total += a[i];
    return total;
}

Même tâche, deux styles

Additionner les nombres de 1 à n peut se faire de l’une ou l’autre manière. Voici la version itérative, qui renvoie la même réponse que la récursion.

#include <stdio.h>

int sum_to(int n) {
    int total = 0;
    for (int i = 1; i <= n; i++)
        total += i;
    return total;
}

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

Convertir une récursion en boucle

Toute récursion peut être réécrite sous forme itérative, parfois en utilisant votre propre pile explicite.

Une récursion linéaire simple, comme une factorielle ou une somme, se convertit en une simple boucle avec une variable d’accumulation.

#include <stdio.h>

int main(void) {
    int n = 5, result = 1;
    while (n > 1) { result *= n; n--; }
    printf("%d\n", result);
    return 0;
}

Remarque sur la récursion terminale

Un appel récursif terminal est la dernière action d’une fonction. Certains compilateurs l’optimisent en boucle, en réutilisant une seule trame.

C ne garantit pas ce comportement ; ne vous y fiez donc pas pour les récursions profondes.

int sum_tail(int n, int acc) {
    if (n == 0) return acc;
    return sum_tail(n - 1, acc + n);
}

Choisir une approche

Demandez-vous : le problème est-il naturellement imbriqué ou de type diviser pour régner ? Dans ce cas, la récursion convient.

S’agit-il d’une répétition linéaire simple avec une entrée potentiellement très grande ? Alors l’itération est plus sûre et souvent plus rapide.

Vérification rapide

Comparez les deux approches.

Récapitulatif

La récursion et l’itération peuvent résoudre les mêmes problèmes. Les boucles utilisent une mémoire constante et conviennent parfaitement aux tâches linéaires ; la récursion est plus claire pour les problèmes imbriqués et de type diviser pour régner, mais coûte une trame de pile par appel.

Questions Fréquemment Posées

La leçon « Récursion ou itération » est-elle gratuite ?

Oui — le texte complet de « Récursion ou itération » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Récursion ou itération » ?

Sachez quand choisir l’une ou l’autre. Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Récursion ou itération » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C Academy