Factorielle en utilisant la Récursivité en Java

D'abord, vous devez comprendre comment les travaux factoriels.

Permet de prendre 4! à titre d'exemple.

4! = 4 * 3 * 2 * 1 = 24

Permettez-nous de simuler le code à l'aide de l'exemple ci-dessus:

int fact(int n)
    {
        int result;
       if(n==0 || n==1)
         return 1;

       result = fact(n-1) * n;
       return result;
    }

Dans la plupart des langages de programmation, nous avons ce que nous appelons function stack. Il est juste comme un jeu de cartes, où chaque carte est placée au-dessus de l'autre, et chaque carte peut être considéré comme une fonction, Donc, en passant sur la méthode fact:

Niveau de la pile 1: fact(4) //n = 4 and is not equal to 1. So we call fact(n-1)*n

Niveau de la pile 2: fact(3)

Niveau de la pile 3: fact(2)

Niveau de la pile 4: fact(1) //maintenant, n = 1. si nous revenons 1 à partir de cette fonction.

renvoi de valeurs...

Niveau de la pile 3: 2 * fact(1) = 2 * 1 = 2

Niveau de la pile 2: 3 * fact(2) = 3 * 2 = 6

Niveau de la pile 1: 4 * fact(3) = 4 * 6 = 24

donc nous avons 24.

Prendre note de ces lignes:

result = fact(n-1) * n;
           return result;

ou tout simplement:

return fact(n-1) * n;

Ce appels de la fonction elle-même. À l'aide de 4 par exemple,

En séquence selon la fonction de piles..

return fact(3) * 4;
return fact(2) * 3 * 4
return fact(1) * 2 * 3 * 4

La substitution des résultats...

return 1 * 2 * 3 * 4 = return 24

J'espère que vous obtenez le point.

Votre confusion, je crois, vient du fait que vous pensez qu'il n'est qu'un result variable, alors qu'en fait il y a un result variable pour chaque appel de fonction. À cet effet, les anciens résultats ne sont pas remplacés, mais est retournée.

D'ÉLABORER:

int fact(int n)
{
    int result;

   if(n==1)
     return 1;

   result = fact(n-1) * n;
   return result;
}

Assumer un appel à fact(2):

int result;
if ( n == 1 ) //false, go to next statement
result = fact(1) * 2; //calls fact(1):
|    
|fact(1)
|    int result;  //different variable
|    if ( n == 1 )  //true
|        return 1;  //this will return 1, i.e. call to fact(1) is 1
result = 1 * 2; //because fact(1) = 1
return 2;

Espère que c'est plus clair maintenant.

Ce qui se passe, c'est que l'appel récursif lui-même les résultats dans récursive comportement. Si vous avez été à l'écrire, vous bénéficiez de:

 fact(4)
 fact(3) * 4;
 (fact(2) * 3) * 4;
 ((fact(1) * 2) * 3) * 4;
 ((1 * 2) * 3) * 4;

Même si c'est vieux, il tient encore à venir assez bien dans google. Alors j'ai pensé que je voudrais mentionner. Personne n'a indiqué à vérifier quand vous x = 0.

0! et 1! les deux = 1.

Ce n'est pas vérifiée avec les réponses précédentes, et serait la cause d'un débordement de la pile, si fact(0) a été exécuté. De toute façon simple correctif:

public static int fact(int x){
    if (x==1 | x==0)
        return 1;
    return fact(x-1) * x;
}//fact

À mon avis, et que l'avis de quelqu'un avec un niveau débutant connaissance de java, je voudrais suggérer que le n == 1 être modifié en n <= 1 ou n == 0)||(n==1) parce que la factorielle de 0 est 1.

De comprendre ce que vous avez à déclarer la méthode de la façon la plus simple possible et martynas cloué sur 6 Mai post:

int fact(int n) {
    if(n==0) return 1;
    else return n * fact(n-1);
}

lu la mise en œuvre et vous comprendrez.

À l'aide de Java 8 et ci-dessus, en utilisant la récursivité lui-même

  UnaryOperator<Long> fact = num -> num<1 ? 1 : num * this.fact.apply(num-1);

Et de l'utiliser comme

  fact.apply(5); //prints 120

import java.util.Scanner;

public class Factorial {
    public static void main(String[] args) {
        Scanner keyboard = new Scanner(System.in);
        int n; 
        System.out.println("Enter number: ");
        n = keyboard.nextInt();
        int number = calculatefactorial(n);
        System.out.println("Factorial: " +number);
    }
    public static int calculatefactorial(int n){
        int factorialnumbers=1;
        while(n>0){
         factorialnumbers=(int)(factorialnumbers*n--);   
        }
        return factorialnumbers;
    }
}

public class Factorial {
public static void main(String[] args) {
   int n = 7;
   int result = 1;
   for (int i = 1; i <= n; i++) {
       result = result * i;
   }
   System.out.println("The factorial of 7 is " + result);
}
}