What is the relationship between recursion functions and memory stack? - recursion

Question

is there's a direct relationship between recursive functions and the memory stack, for more explanation consider that code:
public static int triangle(int n) {
System.out.println(“Entering: n = ” + n);
if (n == 1) {
System.out.println(“Returning 1”);
return 1;
} else {
int temp = n + triangle(n - 1);
System.out.println(“Returning“ + temp);
return temp;
}
}​
in this example where will the values 2,3,4,5 be stored until the function returns ? note that they will be returned in LIFO(LastInFirstOut) is these a special case of recursion that deals with the memory stack or they always goes together?

Answer 1

Yes, there is direct relationship between recursion functions and memory stack as some function with a high limit will crash your program just because stack size limit is reached and function will override parts of your program code (that is what we call stack-overflow).
R: Recursive
I: Iterative
first call:
R | I
|_| |_|
second call:
R | I
|_| |_|
|_|
third call:
R | I
|_| |_|
|_|
|_|
.
.
.
n call :
R | I
|_| |_|
|_|
|_|
.
.
.
|_|
I hope this makes sense, for iterative call function will be pushed to the stack once done it goes off from the stack and the next call will load a similar function, in the other hand the recursive function loads into the stack and calls itself and reloads the stack with each call, and then they start to go off (LIFO last one called first one out) when the stopping condition is reached.
So now to be specific to your matter, the n value as you said will be hold in the memory when stopping condition is met then the last function will display n, and then exits to give the hand to the function that just called it which will also display its own value of n and the same thing will be repeated until the very first function called, however the iterative function will display a value of a counter n (only one variable used and we are changing its value).
The below is a good article about stackoverflow,
Very deep or infinite recursion Main article: Infinite recursion The
most common cause of stack overflow is excessively deep or infinite
recursion. Languages like Scheme, which implement tail-call
optimization, allow infinite recursion of a specific sort—tail
recursion—to occur without stack overflow. This works because
tail-recursion calls do not take up additional stack space.
http://en.wikipedia.org/wiki/Stack_overflow

Answer 2

Assuming this is a C++ class method, calls to triangle(n) will push data to the stack that looks like:
function code
int *returnAddress
int n
Where the return value doesn't get assigned until the function returns. R.S. Shaw provided a nice image example to the Call Stack wikipedia page here.
This data gets pushed onto the top of the call stack once per recursion, so the code for the last call to triangle(n) will be on top. The value stored in *returnAddress is the place in memory where the result needs to go in order to unwind the recursion.
In other words, the results themselves (for example: 1 for triangle(1), 3 for triangle(2)) end up somewhere in the function code part of the stack, not in a particular named place in memory. If you run a debugger, you should be able to track down the location of your returnAddress by placing a breakpoint inside the triangle function code.
By the way, this is not a special case of recursion. This is the classic textbook case.

Answer 3

The temporary variable n will be on the stack, as will be the parameter to the call n-1 as will be the return address. These are all on the same stack.

Answer 4

As QuentinQK explained, the local variable n will consume stack space as well as the function's return address and -for a short moment- the return value and all paramters handed over to the recursive function consume space on the stack. And this happens on each recursion level. So it depends on how deep your recursion will go (how often this function calls itself) how much of the stack will be eventually requried and wether it bursts or not.
For that very reason it is essential having sim final condition. In your excaple it is this if (n==1)' condition where the recursion is stopped when that value is reached. It only works along with then-1in the parameter list of the recursive call oftriangle`.
But what do you really want to konw?