La récursion en programmation<span class="wtr-time-wrap after-title"><span class="wtr-time-number">6</span> min read</span>
la récursion en programmation

La récursion en programmation6 min read

Aujourd’hui, nous allons découvrir une technique de programmation qui va vous permettre de faire des merveilles.

Si je vous disais qu’il était possible d’additionner deux nombres a et b 100 fois en seulement quelques lignes de code, sans aucune boucle et dans une seule fonction.

Vous allez me dire qu’il suffit d’écrire a = a + b une centaine de fois. Et bien j’ai beaucoup mieux, découvrons ensemble la récursion.

C’est quoi la récursion ?

Prenons l’exemple précédent. Vous avez trois solutions. Vous pouvez utiliser une boucle while classique avec une rupture à 100, vous pouvez aussi taper sur votre clavier l’addition 100 fois. Ou enfin, vous pouvez utiliser la fameuse récursion.

Concrètement, la récursion c’est le fait de rappeler une faction dans elle-même. La fonction A va rappeler la fonction A à la fin de l’exécution en lui passant potentiellement des arguments.

L’idée, c’est de simplement appeler la fonction à la fin, ou de la retourner, ça dépends des langages de programmation. Voyons concrètement un exemple de récursion en Pseudo Code C

int addition(int a, int b, int c) { // nombre 1, nombre 2 , decompte
    a = a + b 
    if c > 0 {
        addition(a, b , (c - 1)
    }
    else {
        return a 
    }

}

Cette fonction va additionner a et b c fois. Ici on utilise la récursion. Concrètement, on appelle la fonction , et elle va réassigner la variable a en valant l’addition de a + b. Ensuite, on teste si c est supérieur à 0. C agis comme notre décompte.

Puisque C est supérieur à 0, on rappelle la fonction addition en lui passant la nouvelle valeur de A, ce qui implique que l’on conserve le résultat de l’addition.

Prenons un exemple, si en premier lieu on additionne 3 + 2, a vaux maintenant 5, on additionne ensuite a + b donc 5 + 2 = 7 etc…

Enfin, on change la valeure de c en soustrayant 1 afin de réduire le décompte et donc se rapprocher de 0.

Voilà en gros le fonctionnement de la récursion. Je comprends que ça soit un peu complexe. Mais les possibilités sont infinies. Selon les données, on peux lancer des récursion avec des modifications et des arguments différents.

Vous pouvez faire des boucles extrêmement complexes grâce à la récursion.

A quoi sers la récursion ?

Voyez la récursion comme une technique complexe qui va vous permettre d’écrire des itérations beaucoup plus poussées que des simples boucles.

La récursion permets de créer des complexes mathématiques poussés. Par exemple les factorielles.

Une factorielle est une multiplication d’un nombre par le nombre précédent, et ce jusqu’à 0. Par exemple : factorielle(5) = 1*2*3*4*5

La récursion permets de créer très facilement une fonction factorielle, voici un exemple de code python car c’est plus facile à lire :


def calc_factorial(x):

    if x == 1:
        return 1
    else:
        return (x * calc_factorial(x-1))

Ici, on calcule la factorielle en multipliant le nombre passé par son nombre inférieur, et ce jusqu’à 1.

Cette méthode permets de créer un concept mathématique complexe en quelques lignes de code.

Pourquoi utiliser la récursion ?

Bon alors, vous venez d’apprendre un nouveau concept mais vous vous dites :

Tout ce que tu nous apprends la, on peux le faire avec une simple boucle while ou for

Et c’est parfaitement vrai. Dans la majorité des cas, il est plus simple d’utiliser une boucle plutôt que la récursion.

Néanmoins, il est possible d’utiliser la récursion pour parcourir des données complexes. Par exemple, il est possible d’analyser des récurrences dans les arbres de données via la récursion.

La récursion permets aussi de simplement naviguer dans les fichiers d’un ordinateur. Les itérations de recherche sont en fait des récursions.

Enfin, il est possible d’utiliser des concept physiques, mathématiques et scientifiques complexes grâce à la récursion. Prenez par exemple les fractales, c’est un exemple parfait de récursion, par exemple :

private void BuildVertices(double x, double y, double len)
{
    if (len > 0.002)
    {
        mesh.Positions.Add(new Point3D(x, y + len, -len));
        mesh.Positions.Add(new Point3D(x - len, y - len, -len));
        mesh.Positions.Add(new Point3D(x + len, y - len, -len));
        len *= 0.5;
        BuildVertices(x, y + len, len);
        BuildVertices(x - len, y - len, len);
        BuildVertices(x + len, y - len, len);
    }
}
enter image description here

Ce code utilise la récursion et permets de créer une fractale complexe en seulement quelques lignes de code.

En conclusion

On peux voir la récursion comme une méthode qui permets de diviser des processus et de créer des itérations complexes.

Il est souvent inutile d’utiliser la récursion, une boucle suffit, mais dans certains cas, elle est essentielle

Je sais que ce concept est complexe mais je vous invite à vous entraîner afin de bien comprendre le concept de la récursion, ça pourrait vous servir.

J’espère que cet article vous as plu, si c’est le cas, n’hésitez pas à écrire un commentaire pour me le dire ou me poser une question.

Vous pouvez aussi télécharger mon guide Ultime pour bien débuter la programmation en inscrivant votre email en dessous !

Vous abonner à notre newsletter

* champ requis

Laisser un commentaire

Fermer le menu
×
×

Panier