Are recursive methods always better than iterative methods in Java? [closed]

Answer 1

Are recursive methods always better than iterative methods in java?

No

Also can they always be used in place of iteration and vice-versa?

You can always make a recursive function an iterative one. (if memory can handle it, see interesting link here)

For some cases, it's better to use recursion (like when dealing with trees.. traveling on a binary tree.. etc..). For me, if using loops isn't more complicated and much more difficult than a recursion, I prefer to use loops.

Recursion uses more memory, but is sometimes clearer and more readable. Using loops increases the performance, but recursion can sometimes be better for the programmer (and his performance).

So, for conclusion, deciding what to use - recursion or iteration, depends on what you want to implement, and what's more important for you (readability, performance...) and asking recursion or iteration is like asking for elegance or performance.

---

Example

Consider these two implementation for the factorial:

Iterative:

private int Factorial(int num)
{
    int result = 1;
    if (num <= 1) 
       return result;
    while (num > 1)
    {
        result * = num;
        num--;
    }
    return result;
}

Recursion:

private int Factorial(int num)
{
    if (num <= 1) 
        return 1;
    return num * Factorial(num - 1);
}

Which method is more readable?

Obviously the recursive one, it is straight forward and can be written and successfully run from the first try - It is simply translating math definition into Java!

Which method is more efficient?

Take for example num = 40, here is a time comparison:

long start = System.nanoTime();
int res = Factorial(40);
long end = System.nanoTime();
long elapsed = end - start;

System.out.println("Time: " + elapsed); 

2993 for the recursive

2138 for the iterative

of course the difference will be larger when num is larger..

Answer 2

Usually recursive methods demands a few lines of code but a deeply thought about your algorithm. If you make a logical mistake, you'll probably obtain a StackOverflowError.

Here follows 2 programming examples for factorial:

Iteractive:

public int calculateIteractiveFactorial(int n) {
    // Base case
    if (n == 1) {
        return 1;
    }
    int factorial = 1;
    for (int i = 1; i <= n; i++) {
        factorial = factorial * i;
    }
    return factorial;
}

Recursive:

public int calculateRecursiveFactorial(int n) {
    // Base case
    if (n == 1) {
        return 1;
    }
    return n * calculateRecursiveFactorial(n - 1);
}

It's always good to reflect about different ideas for each proposal, always considering lines of code, complexity, clarity, cohesion, etc.