Answer.

Background
Recursion as a mechanism is often used for elegantly solving problems like tree traversal, factorial computation, quicksort. In C, recursive calls are implemented directly, as a function can call itself through a normal name reference.

Problem
Recursion is convenient but carries the risk of rapid stack overflow due to deep nesting (stack overflow). Moreover, it performs inefficiently for large input sizes without optimizations (e.g., due to the lack of tail recursion).

Solution
Before using recursion, check the maximum possible depth, implement base cases, consider memory (stack) usage, and in critical cases, rewrite the algorithm in an iterative format.

Example code:

// Recursive factorial calculation
unsigned long factorial(unsigned int n) {
    if (n <= 1) return 1;   // base case
    return n * factorial(n - 1);  // recursive case
}

Key features:

A new copy of local variables is created on the stack with each call.
Control of base cases is necessary to avoid infinite recursion.
Recursion is easy to implement but hard to optimize for real large data.

Tricky questions.

Can a function in C directly call itself with any name?

No. A function calls only itself using its own name, which must be defined at the moment of the call (or at least declared beforehand).

Is recursion always more efficient than a loop?

No! Iterative solutions often work faster and more reliably since they do not quickly consume the stack and do not incur additional overhead on function calls.

Does the stack return to its original state after recursion?

Yes, the stack is fully cleared as each recursive function exits. After the outermost function completes, memory returns to its previous state.

Typical mistakes and anti-patterns

Missing the base case, leading to infinite recursion.
Confused exit conditions from recursion.
Using recursion where a loop is more efficient.

Real-life example

Negative case

A developer implemented a tree traversal function recursively for 100,000 nodes without checking the depth. A stack overflow occurred.

Pros:

Simple and concise code. Cons:
The application crashes with large data due to stack overflow.

Positive case

An algorithm implemented with tracking recursion depth and protection against excessive nesting, large traversals are divided into batches (iterative version).