Java Program to Find Reverse of a Number Using Recursion

10 Jun, 2022
Recursion is a process by which a function calls itself repeatedly till it falls under the base condition and our motive is achieved.
To solve any problem using recursion, we should simply follow the below steps:
Assume the smaller problem from the problem which is similar to the bigger/original problem.Decide the answer to the smallest valid input or smallest invalid input which would act as our base condition.Approach the solution and link the answer to the smaller problem given by recursive function to find the answer to the bigger/original problem using it.
Assume the smaller problem from the problem which is similar to the bigger/original problem.
Decide the answer to the smallest valid input or smallest invalid input which would act as our base condition.
Approach the solution and link the answer to the smaller problem given by recursive function to find the answer to the bigger/original problem using it.
Example:
Input:  14689
Output: 98641

Input:  7654321
Output: 1234567
Approach 1: 
In this approach, we can simply print the unit digit of a number.
And then call the recursive function for the number after removing this unit digit( number/10)
And this process continues till the number is reduced to a single-digit number. 
Example:
    
    num = 82695
        reverse(82695)
           |
           |__print(5)
              reverse(8269)
                    |
                    |__print(9)
                       reverse(826)
                            |
                            |__print(6)
                               reverse(82)
                                   |
                                   |__print(2)
                                      reverse(8)
                                          |
                                          |__print(8)
                                             return
Java
// Java program to reverse// an integer recursivelyclass 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
 
Approach 2: 
 
In this approach, we can simply maintain a variable in which we can store the number reversed till now.
We can do this by extracting a unit digit from the number and then adding this extracted integer into the reversed number
But the key factor here is that we have to multiply the reversed number by 10 before adding this extracted number to the reversed number. 
 
Example:
 
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
// Java program to reverse an integer recursivelyclass 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
 
Note: Java does not throw an exception when an overflow occurs so a problem of overflow might occur if the reversed number is greater than Integer.MAX_VALUE (2147483647) in method 2 but there will be no such problem in method 1.
 
adnanirshad158
vinayedula
Java
Java Programs
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stream In Java
Introduction to Java
Constructors in Java
Exceptions in Java
Generics in Java
Java Programming Examples
Convert Double to Integer in Java
Implementing a Linked List in Java using Class
Factory method design pattern in Java
Java Program to Remove Duplicate Elements From the Array