What is recursion really and explain the output of this program? [closed]

Answer 1

In this case, calling fun() is like calling any other function. For example:

int main() {
   int a = 0;
   foo(a);
   printf("main a = %d\n", a);
}

void foo(int a) {
   a = 1;
   bar(a);
   printf("foo a = %d\n", a);
}

void bar(int a) {
   a = 2;
   printf("bar a = %d\n", a);
}

Your call sequence look like this:

main();
foo();
bar();

And your output will be this:

bar a = 2
foo a = 1
main a = 0

The arguments are passed by value, so a is copied and is actually a different variable in each function. The same happens with recursion.

main();  x = 3
fun(3);  a = 3, so a > 0, nothing happens, return to main()

If you were to change the condition so fun() calls itself when a > 0 (read top-down)

main();  x = 3
fun(3);  a = 3, a > 0 so --a = 2, fun(2)
fun(2);  a = 2, a > 0 so --a = 1, fun(1)
fun(1);  a = 1, a > 0 so --a = 0, fun(0)
fun(0);  a = 0, so return to fun(1)

fun(1);  printf("%d", a) displays 1, --a = 0, fun(0)  /* same as fun(1) above */
fun(0);  a = 0, so return to fun(1)

fun(1);  nothing left to do so return to fun(2)       /* same as fun(1) above */

fun(2);  printf("%d", a) displays 2, --a = 1, fun(1)
fun(1);  a = 1, a > 0 so --a = 0, fun(0)              /* this is a new fun(1) */
fun(0);  a = 0, so return to fun(1)

fun(1);  printf("%d", a) displays 1, --a = 0, fun(0)
fun(0);  a = 0, so return to fun(1)

fun(1);  nothing left to do so return to fun(2)

fun(2);  nothing left to do so return to fun(3)

fun(3);  printf("%d", a) displays 3, --a = 2, fun(2)  /* halfway point */
fun(2);  a = 2, a > 0 so --a = 1, fun(1)
fun(1);  a = 1, a > 0 so --a = 0, fun(0)
fun(0);  a = 0, so return to fun(1)

fun(1);  printf("%d", a) displays 1, --a = 0, fun(0)
fun(0);  a = 0, so return to fun(1)

fun(1);  nothing left to do so return to fun(2)

fun(2);  printf("%d", a) displays 2, --a = 1, fun(1)
fun(1);  a = 1, a > 0 so --a = 0, fun(0)
fun(0);  a = 0, so return to fun(1)

fun(1);  printf("%d", a) displays 1, --a = 0, fun(0)
fun(0);  a = 0, so return to fun(1)

fun(1);  nothing left to do so return to fun(2)

fun(2);  nothing left to do so return to fun(3)

fun(3);  nothing left to do so return to main()

And your output should be: 1213121 which reflects the tree structure of the calls:

        3
       / \
      /   \
     2     2
    / \   / \
   1   1 1   1

Answer 2

Function arguments are passed by value in C, which means temporary local variables are created each time the function is called. When a function is called recursively, a new set of variables is created each time. However, recursion doesn't necessarily save storage space, since somewhere a stack of the values being processed must be maintained.

Answer 3

Functions are merely code that resides somewhere in memory. Whenever you make a function call, the compiler translates that into an assembly code command for the platform that saves the address of the next command to be executed after the function call is complete as well as tell the processor where to literally "jump" in memory in order to read the next command to be executed.

Recursion works because you can easily tell the processor to "jump" back to the beginning of the function's code block in memory. The current function that you are calling from has a memory address just like any other function, and therefore there is no difference for the processor to jump to the beginning of the current function's code block in memory, or some other function's code block in memory.

The stack comes into play due to the fact that we need to save the return address for the command to execute after we complete the function call, as well as a location to store the current function's arguments and automatic variables. So as you make successive function calls, there is a call-stack that is created, with arguments as well as return addresses for any previously called functions higher-up on the stack if the stack is growing downwards. This is collectively called the "stack frame" for the function. When you return from a function, the current function's stack frame is popped off the bottom of the stack, and then the memory address for where the processor needs to jump back to after the function is complete is read and executed. In the case of recursion, this means that we simply jump back to a previous version of the same function, but in this case the automatic stack variables and arguments will be different after we return since we have returned back to a stack frame for a previous version of the function.