Recursion: Everything you need to know about it

[@nasimnajand9697]

I hope you explain the tower of Hanoi problem in further videos. Thanks in advance❤😊

[@thob]

The other comment might be under review, so I'll post this in a new one. I wrote the iterative factorial function counting backwards because I missed that she said "the loop in _this case_ counts upwards", but the distinction in the execution might make new programmers think this is an inherent property of the control flow, which is why I wanted to exemplify the same behavior can occur in both recursive and iterative processes.

[@zandrah496]

You are correct, loops can of course go both ways. I chose to do the iterative solution by incrementing the counting, since many new coders (me included) find that easier.

[@samuelvishesh]

How to enforce tail recursion optimisation?

[@42berlin]

Here is a quick summary for you ✌️ In C, tail recursion optimization (TRO) is not something you enforce directly in the language itself, but rather something that is handled by the compiler if possible. Tail recursion occurs when the recursive call is the last operation in the function before it returns. In this case, the current function's stack frame is no longer needed, and the compiler can optimize by reusing the stack frame instead of creating a new one. Modern C compilers (e.g., GCC, Clang) can optimize tail-recursive functions to eliminate stack frame buildup. However, this optimization is not guaranteed by the C standard and depends on the compiler and optimization settings. How to Write Tail-Recursive Functions - Ensure that the recursive call is the last action in the function. - Avoid computations or operations after the recursive call. - Pass along any intermediate results via function arguments. Example of tail-recursive function: ```c int factorial_tail(int n, int acc) { if (n == 0) return acc; return factorial_tail(n - 1, acc * n); // Tail call } ``` Example of non-tail-recursive function: ```c int factorial_non_tail(int n) { if (n == 0) return 1; return n * factorial_non_tail(n - 1); // Not a tail call because of multiplication }