Understanding Java behaviour in recursive factorial

Question

I created two recursive methods to calculate factorial as follows:

private int fact1(int n) {
    if (n == 0 || n == 1)
        return 1;
    return n * fact1(--n);

}

private int fact2(int n) {
    if (n == 0 || n == 1)
        return 1;
    return fact2(--n) * n;
}

When I call fact1(4) it returns 24. When I call fact2(4) it returns 6 (EDIT: is not returning 18 but 6). I know the second method is making 3 * 2 * 1, but I don't understand why not 4 * 3 * 2 * 1.

The same happens if I change the return to

//fact3(4) returns 60.
return (n + 1) * fact3(--n); // wrong
//fact4(4) returns 24
return fact4(--n) * (n + 1); // works

Why is the method exhibiting this behavior??

The question is about the different behaviour. I know n * fact(n-1) is the better way to solve it.

Can someone help me to understand the evaluation of this expression? Thanks!

It's strange how nobody pointed out yet that `fact2(4)` is actually `6`. — Tamas Hegedus, Nov 03 '16 at 23:39

janos · Accepted Answer · 2016-11-03T23:51:57.503

8

It all comes down to the difference between these expressions:

return n * f(--n);

return f(--n) * n;

When n = 4, these expressions are evaluated like this:

return 4 * f(3);

return f(3) * 3;

Because the moment --n is evaluated, the value of n is decreased by 1. This is how the prefix -- operator works.

It might help to recursively evaluate the entire expressions by hand. The first one:

// first
return 4 * f(3);
return 4 * 3 * f(2);
return 4 * 3 * 2 * f(1);
return 4 * 3 * 2 * 1;

// second
return f(3) * 3;
return f(2) * 2 * 3;
return f(1) * 1 * 2 * 3;
return 1 * 1 * 2 * 3;

On a related note, guess how this will be evaluated:

return f(n--) * n;

It will be:

return f(4) * 3;

Because here the postfix -- operator is used: the -1 decrement will be applied after the evaluation of n in f(...).

edited Nov 03 '16 at 23:51

answered Nov 03 '16 at 23:30

janos

120,954
29
226
236

In your 2nd line, when `f(3)` is evaluated what is the behaviour? Why the 2nd call returns `f(2) * 3`? – El Mestre Nov 03 '16 at 23:38
1

If you mean `fact2(3)`, the same logic applies as in my 2nd line but with `n = 3`, so that becomes `f(2) * 2` – janos Nov 03 '16 at 23:43
Are you saying the expression is (f(2) * 2) * 3? It returns 6. But running the code here is returning 18. – El Mestre Nov 03 '16 at 23:51
Actually, yes, your must be running something else to get 18, because your posted methods return 24 and 6, respectively – janos Nov 03 '16 at 23:54
Ok, I will check. Thanks for the answer – El Mestre Nov 04 '16 at 00:24

Understanding Java behaviour in recursive factorial

1 Answers1