To Understand Recursion, You Must First Understand Recursion

float _pow_recursion(float x, float y)
if (y == 0)
return (1);
if (y < 0)
return (_pow_recursion(x, y + 1) / x);
printf("Current x, y: %f, %f\n", x, y); return (_pow_recursion(x, y - 1) * x);

Recursion can be a tricky concept to wrap your head around, but think of it as a stack of blocks that pop down to return it’s result. The program above will be our recursive example for learning recursion. Take note of the , which is if (y == 0) return 1; . This means that when y becomes 0, the program will exit and give you back the result of it’s recursion. The next piece of code to look at it is return (_pow_recursion(x, y - 1) * x); , this is how our program will recursively call itself until it hits it’s exit condition to pop down to give our result. A better visual will be drawn below:

int main(void)
int res = 0;
res = _pow_recursion(2, 5);
printf("Result = %d\n", res);
return (0);

We will use this input in our power recursive program, setting x = 2 and y = 5 , the picture below the code is how the stack looks like when it is computing the recursive program. Starting from the bottom, we see that it wants to return 2 * 2 , but it can’t do that until it knows what 5 - 1 is. So it adds to the stack after computing what 5 - 1 is, and it becomes 4 - 1 . This goes on until it hits it’s at the very top, which is if (y == 0) return (1); . At this point of the stack, it can finally compute it’s pending multiplies by going down the stack:

Now from the top of the stack, it exits and goes down to 2 * 2 which is 4. Now its holding 4 , but cannot return until it goes down because of a pending multiply. So it does 4 * 2 , and now it holds 8 , and so on until it hits the last of the stack where it returns what it is holding; which is 32 . Below is the the entire program that has been listed in this article:

In conclusion, if you think of recursion while being on a stack like how the images above are; it might be easier to understand the concept of how it works. Recursion builds a stack until it hits it’s , and then it pops the stack from top to the end (bottom) while holding onto it’s return value. Once it’s back down to the start of the stack, it returns it’s value and the program finishes.


Software Engineer living in Tokyo | Linux | Cats | | |

Software Engineer living in Tokyo | Linux | Cats | | |