Tail Recursion

Concept

As we learned, standard Recursion creates a massive Call Stack because Parent frames are forced to pause and wait for the Child frames to bubble their answers back up.

return n * factorial(n - 1)
The CPU says: “I have to keep this current Stack Frame alive in RAM, because when factorial finishes, I still need to do the n * multiplication part before I can return!”

Tail Recursion is a special way of writing recursive functions where the recursive call is the absolute, definitive last action in the function. There is zero math left to do when the child returns.

return tailFactorial(n - 1, currentTotal * n)
Because there is absolutely no logic left to execute after the call, the CPU realizes: “I don’t need to keep this Parent frame alive anymore! The Child is handling everything!”

Tail Call Optimization (TCO)

If the compiler detects Tail Recursion, it triggers Tail Call Optimization (TCO).
Instead of allocating a brand new Stack Frame for the Child and pushing it on top, it physically overwrites the Parent’s Stack Frame with the Child’s data.
This means the Call Stack never grows deeper than exactly 1 frame! A Tail-Recursive function can run 10 million times with a pure $O(1)$ Space Complexity, completely immune to Stack Overflows.

Implementation Comparison

Standard Recursion (O(N) Space):
The multiplication happens after the child returns.

function factorial(n: number): number {
    if (n <= 1) return 1;
    // PAUSE! Waiting for the child so I can multiply by N!
    return n * factorial(n - 1); 
}

Tail Recursion (O(1) Space with TCO):
We pass the running total forward into the child as an accumulator parameter. When we hit the Base Case, the accumulator is the final answer! We just instantly return it.

function factorialTail(n: number, accumulator: number = 1): number {
    if (n <= 1) return accumulator;
    // DO NOT PAUSE! Pass the math forward.
    // My frame can be destroyed now!
    return factorialTail(n - 1, n * accumulator); 
}

The JavaScript Trap

Why is this rated as “LOW” importance for interviews?

Because JavaScript engines (V8/Node.js) explicitly do NOT support Tail Call Optimization!
Even if you write mathematically perfect Tail Recursive code in JavaScript, Node.js will still allocate 10,000 Stack Frames and crash with a Stack Overflow anyway. (TCO was briefly added in ES6, but was rolled back by browser vendors because it broke Error Stack Traces, making debugging a nightmare).

Other languages like C++, Go, and Elixir fully support TCO, and functional programmers rely on it heavily.

Interview Questions

Q: If JavaScript doesn’t support Tail Call Optimization, should I bother writing Tail-Recursive functions in an interview?
A: No. In a standard JS/TS algorithmic interview, if a recursive solution risks a Stack Overflow, writing it tail-recursively will not save you. The interviewer expects you to explicitly rewrite the algorithm using an Iterative while loop, which is the only guaranteed way to achieve $O(1)$ space in JavaScript. However, knowing the theory of Tail Recursion and explaining why it doesn’t work in V8 is a massive senior-level flex.

Q: A developer writes return 1 + tailRecursiveFunc(n - 1). Is this Tail Recursive?
A: No! Even though the function call is at the end of the line, the 1 + operation must execute after the function returns. The compiler is forced to keep the Parent frame alive in RAM to remember to add the 1. A function is only Tail Recursive if the function call itself is the absolute only expression on the return line.