Visualising recursion in C - c

Question

I am trying to understand how recursion works in the factorial function. What should I print, so that I can see what actually happens during each recursion call?
Here's the code:
#include <stdio.h>
#include <stdlib.h>
long factorial(long number) {
if(number <= 1) {
return 1;
} else {
return number * factorial(number - 1);
}
}
int main() {
int i;
for(i = 0; i <= 10; i++) {
printf("%2d ! = %ld\n", i, factorial(i));
}
return 0;
}

Answer 1

The following code
#include <stdio.h>
#include <stdlib.h>
long factorial (int level, long number){
int result;
printf("[%03d] Calculating: %d\n", level, number);
if(number <= 1)
{
result = 1;
}
else
{
result = number * factorial(level+1, number - 1);
}
printf("[%03d] Returning: %d\n", level, result);
return result;
}
int main(){
int i;
for(i = 0; i <= 10; i++)
{
printf("%2d ! = %ld\n", i, factorial(0, i));
}
return 0;
}
gives this output
[000] Calculating: 10
[001] Calculating: 9
[002] Calculating: 8
[003] Calculating: 7
[004] Calculating: 6
[005] Calculating: 5
[006] Calculating: 4
[007] Calculating: 3
[008] Calculating: 2
[009] Calculating: 1
[009] Returning: 1
[008] Returning: 2
[007] Returning: 6
[006] Returning: 24
[005] Returning: 120
[004] Returning: 720
[003] Returning: 5040
[002] Returning: 40320
[001] Returning: 362880
[000] Returning: 3628800
10 ! = 3628800
Where [XXX] is the current level of recursion.

Answer 2

Try this
long factorial (long number){
if(number <= 1){
return 1;
}else{
return number * factorial(number - 1);
}
}
Assume we pass 4 as first parameter, then function evaluates to:
long factorial (long number /*==4*/){
if(4 <= 1){//false
return 1;
}else{
return 4 * factorial(4 - 1);
}
}
Note return in else can't finish, because it calls another function - factorial (4-1).
So 4 must be multiplied by the result of factorial (3). So it goes and executes factorial(3).
Now we get
long factorial (long number /*==3*/){
if(3 <= 1){//false
return 1;
}else{
return 3 * factorial(3 - 1);
}
}
But again the return here can't finish, since it calls factorial for 3-1=2.
Now one needs to evaluate factorial (2), result of which will be multiplied by 3 and passed to previous return. Again:
long factorial (long number /*==2*/){
if(2 <= 1){//false
return 1;
}else{
return 2 * factorial(2 - 1);
}
}
We have similar problem. But now when executing factorial (2-1) the function will immediately return 1, hence above line will return 2.
This result will be plugged to the result of previous return, giving 2*3; this result - 6 - will be plugged in previous return and yield 6*4, which is the final result 24.

Answer 3

For something ridiculous, factor out the body of factorial:
long factorial_body(long number) {
if(number <= 1) {
return 1;
} else {
return number * factorial(number - 1);
}
}
Then, rewrite factorial to call factorial_body, printing some stuff around the call.
long factorial (long number) {
static char output[4096];
static int level;
static int index;
int saved_index;
long result;
switch (level++) {
case 1: index += snprintf(output + index, sizeof(output) - index, "= ");
default: index += snprintf(output + index, sizeof(output) - index,
"%ld x ", number + 1);
case 0: snprintf(output + index, sizeof(output) - index,
"factorial(%ld)\n", number);
}
saved_index = index;
printf("%s", output);
result = factorial_body(number);
index = saved_index;
snprintf(output + index, sizeof(output) - index,
--level ? "%ld\n" : "= %ld\n", result);
printf("%s", output);
return result;
}
factorial(10) will generate the following output:
factorial(10)
= 10 x factorial(9)
= 10 x 9 x factorial(8)
= 10 x 9 x 8 x factorial(7)
= 10 x 9 x 8 x 7 x factorial(6)
= 10 x 9 x 8 x 7 x 6 x factorial(5)
= 10 x 9 x 8 x 7 x 6 x 5 x factorial(4)
= 10 x 9 x 8 x 7 x 6 x 5 x 4 x factorial(3)
= 10 x 9 x 8 x 7 x 6 x 5 x 4 x 3 x factorial(2)
= 10 x 9 x 8 x 7 x 6 x 5 x 4 x 3 x 2 x factorial(1)
= 10 x 9 x 8 x 7 x 6 x 5 x 4 x 3 x 2 x 1
= 10 x 9 x 8 x 7 x 6 x 5 x 4 x 3 x 2
= 10 x 9 x 8 x 7 x 6 x 5 x 4 x 6
= 10 x 9 x 8 x 7 x 6 x 5 x 24
= 10 x 9 x 8 x 7 x 6 x 120
= 10 x 9 x 8 x 7 x 720
= 10 x 9 x 8 x 5040
= 10 x 9 x 40320
= 10 x 362880
= 3628800
I am dubious if the above output will help enhance your understanding of recursion. But, working to understand how the printing code works probably would lead to a better understanding of recursion.

Answer 4

Instead of print statements add whatever you would print to an array or something and then print them out in the order that they were inserted (fifo) after the recursive function is finished.

Answer 5

This should give you a trace of the execution of factorial, with indentation:
long factorial(long number, int depth){
printf("%*s enter, number = %d\n", 4*depth, "", number);
long result = 1;
if (number > 1) result = number * factorial(number-1, depth+1);
printf("%*s exit, result = %d\n", 4*depth, "", result);
return result;
}