La fonction récursive est une fonction qui appelle par elle-même
Il permet aux programmeurs d'écrire des programmes efficaces en utilisant une quantité minimale de code .
L'inconvénient est qu'ils peuvent provoquer des boucles infinies et d'autres résultats inattendus s'ils ne sont pas écrits correctement .
Je vais expliquer à la fois la fonction récursive simple et la fonction récursive de queue
Pour écrire une fonction récursive simple
- Le premier point à considérer est quand devriez-vous décider de sortir de la boucle qui est la boucle if
- Le second est quel processus faire si nous sommes notre propre fonction
À partir de l'exemple donné:
public static int fact(int n){
if(n <=1)
return 1;
else
return n * fact(n-1);
}
À partir de l'exemple ci-dessus
if(n <=1)
return 1;
Est le facteur décisif pour sortir de la boucle
else
return n * fact(n-1);
Le traitement réel doit-il être effectué
Permettez-moi de rompre la tâche une par une pour une meilleure compréhension.
Voyons ce qui se passe en interne si je cours fact(4)
- Remplacer n = 4
public static int fact(4){
if(4 <=1)
return 1;
else
return 4 * fact(4-1);
}
If
la boucle échoue donc elle va en else
boucle donc elle retourne4 * fact(3)
Dans la mémoire de pile, nous avons 4 * fact(3)
Remplacer n = 3
public static int fact(3){
if(3 <=1)
return 1;
else
return 3 * fact(3-1);
}
If
la boucle échoue donc il va à else
boucle
donc ça revient 3 * fact(2)
Rappelez-vous que nous avons appelé `` 4 * fact (3) ''
La sortie pour fact(3) = 3 * fact(2)
Jusqu'à présent, la pile a 4 * fact(3) = 4 * 3 * fact(2)
Dans la mémoire de pile, nous avons 4 * 3 * fact(2)
Remplacer n = 2
public static int fact(2){
if(2 <=1)
return 1;
else
return 2 * fact(2-1);
}
If
la boucle échoue donc elle passe en else
boucle
donc ça revient 2 * fact(1)
Rappelez-vous que nous avons appelé 4 * 3 * fact(2)
La sortie pour fact(2) = 2 * fact(1)
Jusqu'à présent, la pile a 4 * 3 * fact(2) = 4 * 3 * 2 * fact(1)
Dans la mémoire de pile, nous avons 4 * 3 * 2 * fact(1)
Remplacer n = 1
public static int fact(1){
if(1 <=1)
return 1;
else
return 1 * fact(1-1);
}
If
la boucle est vraie
donc ça revient 1
Rappelez-vous que nous avons appelé 4 * 3 * 2 * fact(1)
La sortie pour fact(1) = 1
Jusqu'à présent, la pile a 4 * 3 * 2 * fact(1) = 4 * 3 * 2 * 1
Enfin, le résultat du fait (4) = 4 * 3 * 2 * 1 = 24
La récursion de la queue serait
public static int fact(x, running_total=1) {
if (x==1) {
return running_total;
} else {
return fact(x-1, running_total*x);
}
}
- Remplacer n = 4
public static int fact(4, running_total=1) {
if (x==1) {
return running_total;
} else {
return fact(4-1, running_total*4);
}
}
If
la boucle échoue donc elle va en else
boucle donc elle retournefact(3, 4)
Dans la mémoire de pile, nous avons fact(3, 4)
Remplacer n = 3
public static int fact(3, running_total=4) {
if (x==1) {
return running_total;
} else {
return fact(3-1, 4*3);
}
}
If
la boucle échoue donc elle passe en else
boucle
donc ça revient fact(2, 12)
Dans la mémoire de pile, nous avons fact(2, 12)
Remplacer n = 2
public static int fact(2, running_total=12) {
if (x==1) {
return running_total;
} else {
return fact(2-1, 12*2);
}
}
If
la boucle échoue donc elle passe en else
boucle
donc ça revient fact(1, 24)
Dans la mémoire de pile, nous avons fact(1, 24)
Remplacer n = 1
public static int fact(1, running_total=24) {
if (x==1) {
return running_total;
} else {
return fact(1-1, 24*1);
}
}
If
la boucle est vraie
donc ça revient running_total
La sortie pour running_total = 24
Enfin, le résultat de fait (4,1) = 24