Recursion en Java

Recursion in Java est l'appel d'une méthode, par la méthode, à partir de la méthode. Cette action se répète jusqu'à ce qu'une condition soit remplie. La méthode doit être une méthode dans une classe, à part une dans la classe principale. La classe principale est la classe qui a la méthode principale (). Le nom du fichier java est celui de la classe principale. Une méthode statique dans la classe principale peut encore être rendue récursive, mais cela ne sera pas abordé dans cet article. Cet article explique la récursivité en Java, avec trois bons exemples.

Compter les entiers de zéro

Considérez un fichier Java avec deux classes: une classe privée comme suit:

classe ACLASS
void MTHD (int no)
Système.dehors.imprimer (non); Système.dehors.imprimer(");
Non = non + 1;
sinon < 5)
MTHD (NO);

La méthode à s'appeler est, MTHD (). Il a le paramètre «int no». La méthode est dans la classe, Aclass. Cette méthode compte de 0 à 4. La première ligne de la méthode a deux déclarations. Le premier imprime le paramètre, non. Le second imprime un espace à droite de ce paramètre imprimé. La ligne suivante ajoute 1 à non. La ligne qui suit est une déclaration IF-compound. Il a la condition qui doit être remplie. La condition à remplir est quand aucune atteint 5. Si 5 n'a pas été atteint, «MTHD (NO)»; s'appelle avec non qui y a ajouté.

La classe principale de cette méthode peut être,

classe publique TheClass
public static void main (String [] args)
int num = 0;
Aclass obj = new aclass ();
obj.MTHD (NUM);
Système.dehors.println ();

La première instruction de la méthode principale () déclare l'entier, num qui lui attribue zéro. Pour qu'une méthode soit appelée, un objet doit être instancié de sa classe. L'énoncé suivant dans la méthode principale () instancie un objet, obj d'Aclass. L'instruction après utilise cet objet pour appeler la méthode, MTHD (), passant à lui l'argument, num, qui est 0. C'est le début du décompte. La dernière instruction de la méthode Main () imprime une nouvelle ligne, une fois que tout le résultat a été imprimé. La sortie est:

0 1 2 3 4

La méthode récursive, MTHD (), est appelée la première fois à partir de la méthode principale (). Après cela, il continue de s'appeler, jusqu'à ce qu'une condition soit remplie.

Ce type de comptage peut être fait pour n'importe quelle gamme. Pour y parvenir pour n'importe quelle gamme, le numéro de début de la plage doit être affecté à Num. Au lieu de 5 pour la condition IF dans la méthode, le nombre juste après la plage doit être tapé.

Ajout d'une gamme de nombres donnés non continues

Considérez les chiffres:

10, 20, 30, 40, 50, 60

La somme des 4 premiers nombres est de 100. C'est-à-dire: 10 + 20 = 30; 30 + 30 = 60; et 60 + 40 = 100. Une méthode récursive peut ajouter ces nombres à une somme croissante jusqu'à ce que la somme soit inférieure ou égale à 100. Afin d'ajouter les cinq premiers nombres, la méthode récursive peut ajouter les nombres à une somme croissante jusqu'à ce que la somme soit inférieure ou égale à 150.

La stratégie consiste à avoir tous ces chiffres dans un tableau dans la méthode principale (). Ensuite, passez le tableau comme argument à la méthode récursive. Si l'ajout des quatre premiers numéros est requis, alors lorsque la somme atteint 100, la méthode récursive doit arrêter de s'appeler. Si l'ajout des cinq premiers numéros est requis, alors lorsque la somme atteint 150, la méthode récursive doit arrêter de s'appeler. Si l'ajout des six premiers numéros est requis, alors lorsque la somme atteint 210, la méthode récursive doit arrêter de s'appeler.

La classe de cette méthode récursive peut être:

classe ACLASS
int sum = 0, i = 0;
void MTHD (int [] arry)
sum = sum + arry [i];
i = i + 1;
Si (résumer < 100)
MTHD (Arry);

C'est pour ajouter les quatre premiers nombres. La classe a deux champs, qui sont somme et je. I est pour itératiser le tableau, à partir de l'index 0. La première instruction de la méthode récursive, MTHD (), ajoute le numéro suivant, à la somme, qui est initialement nul. L'énoncé suivant augmente I par 1, pour l'indice de tableau suivant de l'appel suivant. L'énoncé après est le composé if-statement. La condition ici est que la somme ne doit pas être supérieure à 100. Donc, pour chaque appel que la somme n'est pas jusqu'à 100 (ou plus), la méthode est appelée à nouveau, passant le même tableau. Dans cette situation, la condition est à la fin de la mise en œuvre de la méthode.

La classe principale () pour cela peut être:

classe publique TheClass
public static void main (String [] args)
int [] arr = new int [] 10, 20, 30, 40, 50, 60;
Aclass obj = new aclass ();
obj.MTHD (ARR);
Système.dehors.println (obj.somme);

La première déclaration de la méthode principale () instancie le tableau, avec ses éléments. La deuxième instruction instancie l'objet pour AClass. La déclaration après, appelle la méthode récursive, passant le tableau comme argument. Ceci est le premier appel de la méthode récursive. Après cela, la méthode s'appellera jusqu'à ce que la somme requise soit atteinte. La dernière déclaration imprime la somme finale. La sortie de ce cas est de 100.

Factoriel

Le factoriel de 0, écrit comme 0!, est 1. Les factoriels de 5, 4, 3, 2, 1 sont les suivants:

Factoriel de 5 = 5 x 4 x 3 x 2 x 1 x 0! = 120
Factoriel de 4 = 4 x 3 x 2 x 1 x 0! = 24
Factoriel de 3 = 3 x 2 x 1 x 0! = 6
Factoriel de 2 = 2 x 1 x 0! = 2
Factoriel de 1 = 1 x 0! = 1

Un programme peut être écrit de sorte que lorsqu'un nombre est envoyé à une méthode récursive, la méthode récursive renvoie enfin la factorielle résultante. Notez que la factorielle peut être calculée à 1, au lieu de 0, et le résultat sera toujours le même.

La classe de la méthode récursive peut être:

classe ACLASS
int mthd (int no)
si (non == 1)
retour 1;
autre
return (no * MTHD (NO-1));

L'ensemble du corps de la méthode est un composé if-statement. Si le nombre dont le factoriel est nécessaire est 1, ce qui sera retourné sera 1, car le factoriel de 1 est 1. Si le nombre est supérieur à 1, alors toute la multiplication devra être effectuée, à partir du nombre lui-même, en descendant de 1 unité.

Le résultat est obtenu lorsque toute la multiplication a été effectuée. L'expression de retour ici est un appel de méthode. Son argument est le produit du nombre et de la méthode récursive.

Supposons que le nombre dont le factoriel est nécessaire est de 5, alors l'argument du premier appel de retour sera:

5 x MSTHD (4)

Cette expression sera réservée en mémoire, et le prochain appel sera

5 x 4 x MSTHD (3)

Cette expression sera réservée en mémoire, et le prochain appel sera

5 x 4 x 3 x MSTHD (2)

Cette expression sera réservée en mémoire, et le prochain appel sera

5 x 4 x 3 x 2 x mTHD (1)

Maintenant, le MTHD (1) renvoie 1, en raison de la déclaration if-part, «if (no == 1) return 1;», résultant en,

5 x 4 x 3 x 2 x 1 = 120

Pour la valeur de retour finale.

La classe principale pour cela peut être:

classe publique TheClass
public static void main (String [] args)
Aclass obj = new aclass ();
int ret = obj.MTHD (5);
Système.dehors.println (ret);

Avec un argument de 5 pour le premier appel, dans la méthode principale (), la valeur finale renvoyée est 120.

Conclusion

Recursion in Java est l'appel d'une méthode, par la méthode, à partir de la méthode. Cette action se répète jusqu'à ce qu'une condition soit remplie.