Recursion Examples That Actually Click

TL;DR: Recursion is a function calling itself on a smaller piece of the same problem until it hits a base case. The best recursion examples are Russian nesting dolls, folder trees, and countdowns. Use recursion for nested or branching data; use a loop for simple, flat repetition.

You’ve already used recursion. You just didn’t call it that. Open a folder inside a folder inside a folder — that’s recursion in your file manager. The trick is knowing when that self-similar pattern helps and when it turns into a stack overflow.

Recursion examples you already know

Russian dolls are the classic: each doll contains a smaller doll, until the tiny wooden baby ends the chain. That tiny baby is the base case. Without it, you keep opening forever.

Folder trees work the same way. A recursive function example: list every file in a directory. For each folder, call the same function again. For each file, print the name. Nested comments on Reddit or Hacker News? Same shape. That’s recursion explained without a whiteboard.

Recursion vs iteration: pick the boring tool

The popular options are a loop, plain recursion, and memoized recursion. Here’s the honest comparison. Recursion wins on clarity when the data is nested. Iteration wins on memory and simplicity when you’re counting from 1 to 100.

Use a loop for flat lists, pagination, and simple math. Reach for recursion on trees, graphs with visited tracking, JSON, DOM nodes, and divide-and-conquer. If you can write the loop in three lines and it reads fine, do that. Boring code ships.

def countdown(n):
    if n == 0:
        return
    print(n)
    countdown(n - 1)

Call countdown(3) and you get 3, 2, 1. Remove the base case and Python eventually raises RecursionError — around 1,000 calls by default. That’s not a theory problem; it’s your app falling over.

The base case is the whole deal

Every recursion needs two parts: a base case that stops, and a recursive call that moves toward it. Miss either one and you get infinite calls, stack overflow, or a very confused coworker.

Base case recursion is easy to get wrong when input can be empty or negative. Test n = 0, an empty folder, and a tree with one node. Those edge cases are where recursive code earns or loses trust.

Memoization is the popular upgrade for repeated work. Naive Fibonacci recursion is a fine teaching example and a poor production choice; cache results or use a loop. For tree traversal, plain recursion is usually plenty.

When to use recursion (and when not to)

Use recursion when the problem is naturally self-similar: parse nested JSON, render a comment thread, walk a file system, implement quicksort or merge sort. Use iteration when the shape is a straight line.

Watch the stack. Deep recursion on a linked list with 100,000 nodes will fail in Python and may fail in JavaScript. If depth is unpredictable, use an explicit stack or a loop.

Opinion: learn recursion by writing the dumb factorial and Fibonacci versions once. Then move on. In day-to-day code, the best recursive function is the one that’s obviously correct — not the cleverest one.

Key Takeaways

• Recursion solves a problem by calling the same function on a smaller input.
• A base case stops the chain; without it, you get a stack overflow.
• Recursion vs iteration is a readability and memory trade-off, not a religion.
• Reach for recursion on trees, nested data, and divide-and-conquer; use loops for flat repetition.

Frequently Asked Questions