Recursion is a programming method for function calls itself, suitable for tasks that can be decomposed into smaller similar subproblems. 1. Recursion solves the problem by constantly simplifying the problem until it reaches a "base example" that no longer needs to be recursive; 2. Each recursive call will be pushed into the call stack, and if it does not approach the base case, it may cause stack overflow; 3. Common applications include tree traversal, division and conquer algorithm, backtracking problems and mathematical sequence generation; 4. When writing recursive functions, you need to clarify the base case, ensure that each call is close to the base case, avoid repeated calculations, and pay attention to stack limitations; 5. Compared with iteration, recursive code is simpler but may be less efficient, and should be selected according to structure, performance and memory requirements.

Recursion is a programming concept where a function calls itself in order to solve a problem. It's especially useful for tasks that can be broken down into smaller, similar sub-problems — like traversing file systems, calculating factorials, or solving puzzles like the Tower of Hanoi.

Why recursion matters

At its core, recursion simplifies complex problems by reducing them to smaller instances of the same problem. Instead of using loops, recursive functions repeat actions by calling themselves with modified inputs until they reach a base case — a stopping point where no further recursion is needed.

How recursion works step by step

When a function calls itself, each call gets added to the call stack , which keeps track of all active function calls. Each recursive call should bring you closer to the base case. If not, you risk ending up in an infinite loop , which usually results in a stack overflow error .

Here's how it generally breaks down:

• The function checks if the current input matches the base case.
• If yes, return a simple result (no more recursion).
• If not, perform some operation and call the function again with a reduced or simpler version of the input.

Let's take a basic example: calculating the factorial of a number n .
The factorial of 5 is 5 * 4 * 3 * 2 * 1 , which can also be written as 5 * factorial(4) .

 def factorial(n):
    if n == 1: # base case
        return 1
    else:
        return n * factorial(n - 1) # recursive call

In this case:

• factorial(5) becomes 5 * factorial(4)
• Then 4 * factorial(3) , and so on…
• Until it hits factorial(1) , which returns 1 directly.

Common use cases for recursion

Some problems are naturally suited for recursive solutions because they involve nested or branching structures.

• Tree traversal : Visiting all nodes in a tree structure, such as a file system or HTML DOM.
• Divide-and-conquer algorithms : Like merge sort or quicksort.
• Backtracking problems : Such as maze-solving or Sudoku solvers.
• Mathematical sequences : Fibonacci numbers, powers, etc.

One thing to note is that while recursion can make code cleaner and easier to understand, it may not always be the most efficient option due to the overhead of multiple function calls.

Tips for writing good recursive functions

If you're just getting started with recursion, here are a few things to keep in mind:

• Always define a clear base case — otherwise, your function will keep calling itself forever.
• Make sure each recursive call moves toward the base case — typically by reducing the input size or complexity.
• Avoid unnecessary repetition — sometimes recursion leads to repeated calculations (like in the naive Fibonacci implementation).
• Consider stack limits — too many recursive calls can cause a stack overflow.

A common mistake is forgetting to return the result of the recursive call, or setting up the base case incorrectly. For example:

 def bad_factorial(n):
    if n == 1:
        print(1) # This doesn't return anything usable
    return n * bad_factorial(n - 1)

This would crash or give incorrect output because the base case doesn't return a value properly.

Recursion vs iteration

You can often rewrite a recursive function using a loop (iteration), and vice versa. Sometimes recursion is more elegant, but iteration might be faster and safer in terms of memory usage.

Use recursion when:

• The problem naturally fits a recursive structure.
• Readability and simplicity matter more than micro-optimizations.

Use iteration when:

• You need better performance or control over memory.
• There's a risk of hitting the recursion limit.

So, recursion boils down to breaking a problem into smaller versions of itself, solving those, and combining the results. It's powerful, but needs careful handling.

Basically that's it.

The above is the detailed content of What is recursion, and how does it work?. For more information, please follow other related articles on the PHP Chinese website!