# Java Program to Find Reverse of a Number Using Recursion

• Difficulty Level : Easy
• Last Updated : 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:

1. Assume the smaller problem from the problem which is similar to the bigger/original problem.
2. Decide the answer to the smallest valid input or smallest invalid input which would act as our base condition.
3. 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 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);``    ``}``}`

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 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 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);``    ``}``}`

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.

My Personal Notes arrow_drop_up