Question about mem allocation for recursive functions

[Igor Oakgrove]

Hi, my first post here.
I've been trying to wrap my mind around memory allocation for recursive functions.
As far as my understanding goes a recursive function has to go all the way down in the recursion chain until a definite value is returned and consecutive results bubble up. Every recursion step towards that definite return value requires some memory allocation which can lead to stack overflow (like in the example below).

class RecursionFactorial {
  static int F(int n) {
    if (n == 0) return 1; 
    else return n * F(n - 1);
  }  

  public static void main(String[] args) {
    int n = (int)Integer.parseInt(args[0]);
    System.out.println(F(n));
  }
}

In a book, i came across an example which supposedly solves the stack overflow problem but i cant see how. Is memory still allocated in same fashion as in example above?

class TerminalRecursionFactorial {
  static long FactorialRecTerminal (int n, int i, int result) {
    if (n == i) return result;
    else return FactorialRecTerminal (n, i + 1, result * (i + 1));
  }
  
  public static void main (String[] args) {
    int n = (int)Integer.parseInt(args[0]);
    System.out.println(FactorialRecTerminal (n, 1, 1)) ;
  }
}

Regards
Igor

[Stephan van Hulst]

Welcome to JavaRanch, Igor.

I quickly looked at the algorithm, and it appears to do exactly the same thing as the first one, the only difference being that the first one calculates a factorial starting with n, and the second one starts with 1.

As a matter of fact, the second algorithm will fail for n == 0.

They both use O(n) stack frames.

[Ernest Friedman-Hill]

The second one is worse, as its stack frames are 3 times as large!