A Little Introduction to Recursion

Recursion lets us solve a problem by assuming we can already solve smaller versions of it. This guide builds the idea from its mathematical root in induction through the call stack, the recursion tree, tail recursion, mutual recursion, divide-and-conquer, and the memoization that rescues recursion from its own redundant work. Interactive labs let you watch every one of these mechanisms run.

Recursion is a way of thinking before it is a programming technique. It rests on a single, almost impudent, act of faith: to solve a problem, assume you can already solve a smaller version of the same problem, and figure out only how to bridge the gap between the two. The attentive reader will notice the circularity and be right to be suspicious. This article is, in large part, an argument that the circularity is not vicious. It is disciplined by a base case, licensed by mathematical induction, and made concrete by what happens when a function calls itself.

We start where the idea itself started, in mathematical logic, and show that recursion is induction read backwards. We then descend from the abstract to the concrete: the call stack that actually executes a recursive function, the recursion tree that explains why the naive Fibonacci is catastrophically slow, and the memoization that fixes it. Along the way we meet tail recursion, which turns a recursive call into a loop, mutual recursion, in which two functions call each other, and divide-and-conquer, the strategy behind the fastest sorting algorithms. We close with the pitfalls that turn an elegant recursive idea into a program that crashes. Every mechanism is paired with an interactive lab, because recursion is far easier to see than to describe.

Exclusive Content

Want to keep reading?

The full article contains practical strategies and exclusive data reserved for our registered members.

Continue with Google Instant free access for registered readers