Recursive Method Java

Version imprimable

Bonjour,

J'ai le code suivant, j'arrive pas a comprendre le résultat obtenu :

Code:

1
2
3
4
5
6
7
8
9
10
 
public class JavaApplication {
 
    public static void main(String[] args) {
 
       A x=new A();
       x.rec(2);
 
    }   
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
public class A {
 
    public void rec(int v){
 
        if(v > 0)
            rec(v-1);
 
        System.out.println(v);
    }
 
}

Resultat :
0
1
2

27/01/2018, 18h31
thelvin

Hello,

cette méthode rec() qui a un seul paramètre,

on voit qu'à la fin, elle fait un System.out.println() pour afficher son paramètre v. C'est aussi la seule instruction d'affichage du programme, donc rien d'autre n'est affiché.
Conclusions :
- Chaque fois que rec() est appelée, elle affiche une ligne et une seule.
- Toute ligne en sortie correspond à un appel à rec().
- Ce qui est affiché est la valeur de v qui a été donné en paramètre à rec().
- L'affichage se fait à la fin de l'exécution de rec().

Avant cet affichage, il y a un if(). Ce if peut être vrai ou faux.
S'il est faux, il ne se passe rien, et rec() ne fait rien d'autre qu'afficher sa ligne.
S'il est vrai, alors rec() effectue une seule chose avant d'afficher sa ligne.

Cette autre chose que rec() peut faire, est un appel à rec(), avec paramètre v-1.

En supposant qu'on n'appelle pas rec() avec un paramètre négatif (cette supposition est vraie : le paramètre vaut 2, qui n'est pas négatif), alors on constate que la récursion va fatalement s'arrêter :
- pour chaque appel à rec(),
-- ou bien v vaut zéro, auquel cas rec() ne fait plus d'appel à rec() et la récursion s'arrête
-- ou bien v vaut plus que zéro, auquel cas il y a un appel récursif à rec(), avec un v de valeur v - 1.
Donc à chaque fois que v vaut plus que zéro, au prochain appel il se rapproche de zéro. Fatalement il vaudra zéro à un moment ou à un autre.

Donc :
- On fait un appel récursif à rec() qui va forcément s'arrêter au moment où son v vaut zéro
- Chaque appel à rec() affiche une ligne
- Cette ligne est affichée juste avant que l'appel à rec() se termine.

Résultat :
- La récursion fait son œuvre et appelle rec() jusqu'à ce que son v vaille zéro.
- A ce moment-là on a terminé la récursion et c'était le dernier appel à rec().
- Cet appel affiche son v, qui vaut zéro. Puis il se termine
- On remonte à l'appel précédent, qui a terminé son travail. Il affiche donc son v, qui vaut 1.
- Et ainsi de suite jusqu'à remonter au premier appel de v, qui va afficher le paramètre avec lequel rec() a été appelée au début.
27/01/2018, 19h29
hichem0550

Citation:

Envoyé par thelvin

- Cet appel affiche son v, qui vaut zéro. Puis il se termine

ok. c'est claire.

Citation:

Envoyé par thelvin

- On remonte à l'appel précédent, qui a terminé son travail. Il affiche donc son v, qui vaut 1.
- Et ainsi de suite jusqu'à remonter au premier appel de v, qui va afficher le paramètre avec lequel rec() a été appelée au début.

Pourquoi le programme va exécuter encore fois et affiche les deux valeurs 1 et 2.
J'ai pense que l'affichage est seulement 0.

Merci beaucoup.
27/01/2018, 19h45
thelvin

Il y a un System.out.println() dans la méthode rec().
Il n'est pas dans un if, et il n'y a rien pour sortir de rec() avant ce System.out.println().
Par conséquent pour chaque appel à rec(), il y a exécution d'un System.out.println(), donc un affichage.

Combien y a-t-il d'appels à rec() ?
S'il y a plus d'un appel à rec(), et que tous les appels à rec() font un affichage, alors comment serait-il possible qu'il y ait un seul affichage et pas d'autres ensuite ?
27/01/2018, 20h56
hichem0550

Citation:

Envoyé par thelvin

Par conséquent pour chaque appel à rec(), il y a exécution d'un System.out.println(), donc un affichage.

Combien y a-t-il d'appels à rec() ?
S'il y a plus d'un appel à rec(), et que tous les appels à rec() font un affichage, alors comment serait-il possible qu'il y ait un seul affichage et pas d'autres ensuite ?

Merci beaucoup