Tail Recursion Java | Fresher Interview

Tail recursion is when the recursive call is the very last thing a function does. There's no computation left after the call returns. For example, regular factorial does return n times factorial of n minus one. After the recursive call returns, you still have to multiply by n, so it's not tail-recursive. A tail-recursive version passes an accumulator parameter, like return helper of n minus one and n times accumulator, where that call is the final operation. The key thing about tail recursion is that in languages with tail call optimization, the compiler can reuse the current stack frame for the next call instead of creating a new one. This effectively turns the recursion into a loop, using constant stack space. But here's the catch for Java: the JVM does not perform tail call optimization. Even if you write a perfectly tail-recursive function, Java still creates a new stack frame for every call. So you still get O of n stack space and you still risk StackOverflowError for large inputs. Languages like Scala and Kotlin support this optimization with the tailrec annotation, but Java doesn't. The practical takeaway is that in Java, tail recursion offers no performance or safety benefit over regular recursion. If you're worried about stack overflow with large inputs, don't try to make it tail-recursive. Just convert the whole thing to an iterative loop with a while statement. Use a local variable to track the accumulator and update it each iteration. Java provides no general tail-call optimization guarantee, so recursion depth remains a real limit even when the call is in tail position. Use an iterative loop when the input can be large.