Understand functions that call themselves by visualizing the call stack.
What is recursion?
Recursion is a programming technique where a function calls itself. Anything you can do with a loop can also be expressed with recursion, but recursion shines when the problem has a naturally self-similar structure.
Every recursion needs a base case (stop condition). Without it, calls continue forever and you get a stack overflow.
Factorial
n! = n Γ (n-1) Γ ... Γ 1 can be written recursively as follows.
intfactorial(int n) {
if (n <= 1) return1; // base casereturn n * factorial(n - 1); // recursive call
}
Warning: This naive implementation gets exponentially slower as n grows. Even fib(40) can take several seconds. In practice, use a loop or memoization.
n =
Things to watch out for
Stack overflow
Without a base case, recursion never ends. The stack is exhausted and the program crashes.
Performance
Recursion that repeats the same computation is inefficient. Consider memoization (caching results) or rewriting as a loop.
Where recursion shines
Tree traversal, divide-and-conquer (like merge sort), and problems that match mathematical induction.
Quick quiz
intmystery(int n) {
if (n == 0) return0;
return n + mystery(n - 1);
}
printf("%d\n", mystery(5));
What is the output?
5
15
120
0
Explanation:mystery(5) = 5 + mystery(4) = 5 + 4 + 3 + 2 + 1 + 0 = 15. This function computes the sum from 1 to n. Don't confuse it with factorial (n!).