🔁 Recursion: The divide-and-conquer of programming languages

Recursion is a fundamental technique in programming, in which a function calls itself to solve a problem. It is an elegant method for tackling complex problems, but it must be used with caution: if not designed correctly, it can cause errors or inefficiencies.

🔗 Do you like Techelopment? Take a look at website for all the details!

How does recursion work?

A recursive function is made up of two essential elements:

The base case (base case): the condition that stops the recursion.
The recursive call (recursive case): the function calls on a simplified version of the problem.

Example: Factorial calculation

function factorial(n) { 
  if (n === 0) { 
    return 1; // base case 
  } 
  return n * factorial(n - 1); // recursive call
}

In the code:

If n is 0, the function returns 1 → base case.
Otherwise, multiply n by factorial(n - 1) → recursive call.

Step-by-step execution

factorial(3)
= 3 * factorial(2)
= 3 * (2 * factorial(1))
= 3 * (2 * (1 * factorial(0)))
= 3 * 2 * 1 * 1
= 6

The heart of recursion: base case + simplification

A recursive function must always:

Have a base case, which stops recursive calls.
Simplify the problem at each step, to get closer to the base case.

Without a base case, the function continues to call itself infinitely, causing a stack overflow.

Another example: Countdown

function countdown(n) {
  if (n <= 0) { 
    console.log("Done!"); 
    return; // base case 
  } 
  console.log(n); 
  countdown(n - 1); // recursive call
}

In this example:

The base case is n <= 0
Each recursive call reduces n by 1
Sooner or later, n reaches 0 → the recursion ends

When to use recursion?

Recursion is suitable when the problem:

Can be broken down into similar subproblems
Has a natural recursive structure (e.g., trees, nested structures)
Requires divide-and-conquer algorithms (e.g. mergesort, quicksort)

Example: visit a tree

const tree = { 
  value: 1, 
  children: [ 
    { value: 2, children: [] }, 
    { 
      value: 3, 
      children: [ 
        { value: 4, children: [] }, 
        { value: 5, children: [] } 
      ] 
    } 
  ]
};

function printTree(node) { 
  console.log(node.value); 
  for (let child of node.children) { 
    printTree(child); // recursive call
  }
}

Here, recursion allows you to traverse every node in the tree, visiting each subtree with the same logic.

Warning: Do not abuse it

Using recursion incorrectly can cause:

Stack overflow (too many nested calls)
Poorer performance than a ciIterative loop
Code that's less readable or harder to maintain

Example of inefficient recursion: Fibonacci

function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

This approach has exponential complexity because it calculates the same values multiple times. An iterative or memoized solution is more suitable.

Guidelines for using recursion well

✅ Use recursion when:

The problem is naturally recursive
There is a clear base case
Each step reduces the complexity of the problem

🚫 Avoid recursion when:

An iterative version is simpler or more efficient
You don't fully understand the recursive execution flow
The problem requires too many deep calls (beyond the stack boundary)

Conclusion

The Recursion is a powerful tool, but it is not a shortcut. It's elegant, compact, and sometimes necessary—but it must be used with awareness.

Like any advanced technique, recursion is at its best only in the hands of those who master it.

For beginners, it may be safer to start with iterative approaches and move on to recursion once you fully understand the base case, the call stack, and the performance implications.

Follow me #techelopment

Official site: www.techelopment.it
facebook: Techelopment
instagram: @techelopment
X: techelopment
Bluesky: @techelopment
telegram: @techelopment_channel
whatsapp: Techelopment
youtube: @techelopment

Techelopment

Cerca nel blog