Programa Java para encontrar factorial de un número recursivamente

El factorial de un número n se define como el producto de todos los números enteros descendentes positivos. El factorial de n se denota por n!. El factorial se puede calcular utilizando la siguiente fórmula recursiva donde la llamada recursiva se realiza a una multiplicidad de todos los números menores que el número para el que se calcula el factorial, ya que la fórmula para calcular el factorial es la siguiente:

n! = n * [(n-1)!] 
i.e factorial of n (n!) = n * (n-1) * ......* 3 * 2* 1

Nota: Factorial de 0 es 1 

Ilustración:

Input      : 5!
Processing : 5*4*3*2*1
Output     : 120  

Input      : 6!
Processing : 6*5*4*3*2*1
Output     : 720 

Ejemplo 1:

// Java Program to Find Factorial of a Number
// where N>=0 is currently N>1
 
// Importing input output classes
import java.io.*;
// importing utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Method 1
    // To calculate factorial
    static int factorial(int n)
    {
 
        // Handling base case
        // iIf value of n=1 or n=0, it returns 1
        if (n == 0 || n == 1)
            return 1;
 
        // Generic case
        // Otherwise we do n*(n-1)!
        return n * factorial(n - 1);
    }
 
    // Method 2
    // main driver method
    public static void main(String[] args)
    {
 
        // Calling method 1 to compute factorial and
        // storing the result into a variable
        int ans = factorial(5);
 
        // Print and display the factorial of number
        // customly passed as an argument
        System.out.println("Factorial of 5 is :" + ans);
    }
}

Factorial of 5 is :120

Explicación de salida:

Inicialmente, factorial() se llama desde el método principal con 5 pasado como argumento. Dado que 5 es mayor o igual que 1, 5 se multiplica por el resultado de factorial() donde se pasa 4 (n -1). Dado que se llama desde el mismo método, es una llamada recursiva. En cada llamada recursiva, el valor del argumento n se reduce en 1 hasta que n llega a menos de 1. Cuando el valor de n es menor o igual a 1, entonces no hay llamada recursiva y, por último, devuelve 1.

Ejemplo 2: 

// Java Program to Find Factorial of a Number
// where N>=0 is currently N=1
 
// Importing input output classes
import java.io.*;
// Importing utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Method 1
    // To calculate factorial
    static int factorial(int n)
    {
 
        // Handling base case
        // If value of n=1 or n=0 we return 1
        if (n == 0 || n == 1)
            return 1;
 
        // Generic case computation math
        // Otherwise we do n*(n-1)!
        return n * factorial(n - 1);
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Calling Method 1 and
        // storing the result into variable
        int ans1 = factorial(0);
        int ans2 = factorial(1);
 
        // Print and display the factorial of 0
        System.out.println("Factorial of 0 is : " + ans1);
 
        // Similarly, Print and display the factorial of 1
        System.out.println("Factorial of 1 is : " + ans2);
    }
}

Factorial of 0 is : 1
Factorial of 1 is : 1

Explicación de salida:

Inicialmente, el factorial() se llama desde el método principal con 6 pasado como argumento. En cada llamada recursiva, el valor del argumento n se reduce en 1 hasta que n llega a menos de 1. ¡Para 1! ¡El argumento reducido que se ha pasado es 0! como una pequeña llamada recursiva para ser computada. Como se discutió anteriormente, el factorial de cero es 1. Por lo tanto, la pequeña respuesta devuelta es 1, que luego se multiplica por 1, por lo que el resultado es 1 como salida. Por lo tanto, se establece que cuando el valor de n es menor o igual a 0, entonces no se calcula ninguna llamada de recurrencia, ya que encontraremos números enteros negativos sobre los cuales no se permite calcular el factorial.