Java Program to Find Reverse of a Number Using Recursion
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.
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)
returnJava
// 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); }} |
Output
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 nnumber
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); }} |
Output
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.
Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.
