Programa Java para encontrar el reverso de un número usando recursividad

La recursividad es un proceso por el cual una función se llama a sí misma repetidamente hasta que cae bajo la condición base y se logra nuestro motivo.

Para resolver cualquier problema usando la recursividad, simplemente debemos seguir los siguientes pasos:

1. Asuma el problema más pequeño del problema que es similar al problema más grande/original.
2. Decida la respuesta a la entrada válida más pequeña o la entrada no válida más pequeña que actuaría como nuestra condición base.
3. Acérquese a la solución y vincule la respuesta al problema más pequeño dado por la función recursiva para encontrar la respuesta al problema más grande/original usándolo.

Ejemplo:

Input:  14689
Output: 98641

Input:  7654321
Output: 1234567

Enfoque 1: 

• En este enfoque, podemos simplemente imprimir el dígito de la unidad de un número.
• Y luego llame a la función recursiva para el número después de eliminar este dígito de unidad (número/10)
• Y este proceso continúa hasta que el número se reduce a un número de un solo dígito.
   

Ejemplo:

    
    num = 82695
        reverse(82695)
           |
           |__print(5)
              reverse(8269)
                    |
                    |__print(9)
                       reverse(826)
                            |
                            |__print(6)
                               reverse(82)
                                   |
                                   |__print(2)
                                      reverse(8)
                                          |
                                          |__print(8)
                                             return

// Java program to reverse
// an integer recursively
class GFG {
   
    // Recursive function to print
    // the number in reversed form
    public static void Reverse(int num)
    {
 
        // base condition to end recursive calls
        if (num < 10) {
            System.out.println(num);
            return;
        }
 
        else {
 
            // print the unit digit of the given number
            System.out.print(num % 10);
 
            // calling function for remaining number other
            // than unit digit
            Reverse(num / 10);
        }
    }
 
    // driver code
    public static void main(String args[])
    {
        // number to be reversed
        int num = 98765;
 
        System.out.print("Reversed Number: ");
 
        // calling recursive function
        // to print the number in
        // reversed form
        Reverse(num);
    }
}

Reversed Number: 56789

Enfoque 2: 

• En este enfoque, podemos simplemente mantener una variable en la que podemos almacenar el número invertido hasta ahora.
• Podemos hacer esto extrayendo un dígito unitario del número y luego agregando este entero extraído al número invertido
• Pero el factor clave aquí es que tenemos que multiplicar el número invertido por 10 antes de sumar este número extraído al número invertido.
   

Ejemplo:

num = 48291
ans = 0       -> variable to store reversed number
        
How this works:    
    reverse(num)
          |
          |__ temp = num % 10    -> extracting unit digit from number
                ans = ans*10 + temp   -> adding temp at unit position in reversed number 
          reverse(num/10)    -> calling function for remaining number
Implementation:
          reverse(48291)
                |
                |__ temp=1
                      ans= 0*10 + 1  --> ans=1
                      reverse(4829)
                        |
                       |__ temp=9
                              ans= 1*10 + 9  --> ans=19
                                reverse(482)
                                     |
                                     |__ temp= 2
                                         ans= 19*10 +2  --> ans=192
                                         reverse(48)
                                              |
                                              |__ temp=8
                                                  ans=192*10 + 8  --> ans=1928
                                                  reverse(4)
                                                      |
                                                      |__ temp=4
                                                          ans=1928*10 +4 --> ans=19284
                                                          reverse(0)
                                                              |
                                                              |__ return ans
                          

// Java program to reverse an integer recursively
class GFG {
   
    // Variable to store reversed
    // number after every
    // recursive call
    static int ans = 0;
 
    static int Reverse(int var)
    {
 
        // base condition to end the
        // recursive calling of function
        if (var == 0) {
 
            // We have reversed the
            // complete number and
            // stored in ans variable
            return ans;
        }
 
        if (var > 0) {
 
            // temp variable to store the digit at unit
            // place in the number
            int temp = var % 10;
 
            // Add this temp variable in the ans variable
            // which stores the number reversed till now
            ans = ans * 10 + temp;
 
            // recursive calling of function to reverse the
            // remaining number
            Reverse(var / 10);
        }
 
        // returning final answer when the number is
        // reversed completely
        return ans;
    }
 
    public static void main(String[] args)
    {
 
        // Number to be reversed
        int var = 98765;
       
        // Variable to store reversed number returned by
        // reverse function
        int rev;
 
        // Calling reverse function and storing the return
        // value in rev variable
        rev = Reverse(var);
 
        // Printing the Reversed Number
        System.out.println("Reversed number: " + rev);
    }
}

Reversed number: 56789

Nota: Java no genera una excepción cuando se produce un desbordamiento, por lo que podría producirse un problema de desbordamiento si el número invertido es mayor que Integer.MAX_VALUE (2147483647) en el método 2, pero no habrá tal problema en el método 1.