Which of recursion method is better and why for reverse digits of integer?

Question

public static int recursiveReverse(int number, int reversenumber){

    if(number <= 0) {
        return reversenumber;
    }

    reversenumber = reversenumber *         


        

Answer 1

I don't see any difference between the first and second example

but using a static variable in the third example is dangerous (you need to reset it each time and it's not threadsafe)

Answer 2

Have a go with the following:

public int rev(int n){
    if(n <= 0) {
        return n;
    }
    return Integer.parseInt("" + (n % 10) + rev(n / 10));
}

This way you don't need a temporary variable to hold state and it satisfies the return type. Hope this helps!! :)

Answer 3

I think condition (n <= 0) adds extra 0 in the end. Comparing with 10 (n <= 10) returns correctly reversed integer

public int rev(int n){
    if(n <= 10) {
        return n;
    }
    return Integer.parseInt("" + (n % 10) + rev(n / 10));
}

Answer 4

This is very shortest/simplest way in two lines code:

public static int reverseNumber(int n) 
{
    System.out.println(n % 10);
    return (n/10 > 0) ? reverseNumber(n/10) : n;
}

Answer 5

Definitely not the last one. Putting a state-holding variable in a static field is just asking for trouble. Not that you're necessarily designing for concurrency, but if you had multiple threads running this code, for example, the shared reverseNumber field would totally wreck everything.

I don't see any difference between the first and second. (Literally, they appear identical to me.)

If your goal is to simplify the calling convention by having a default value for the second parameter (reverseNumber), then simply overload your method:

public static int recursiveReverse(int number) {
    return recursiveReverse(number, 0);
}

private static int recursiveReverse(int number, int reverseNumber) {
    // your code goes here
}