Recursion is a concept rather than a language feature, so while most modern programming languages support recursion, it is not universally applicable. A language must support function calls and stack memory management to implement recursion. Some low-level languages or those designed for very specific applications might not support recursion if they do not implement a call stack or if the language's performance constraints make recursion impractical. However, for the vast majority of high-level programming languages used in both academia and the industry, recursion is a fundamental concept that is widely supported and used.

A common mistake is neglecting to define a proper base case, which can lead to infinite recursion. Another is writing a base case that is never reached due to incorrect logic, leading to similar problems. Students also often misunderstand the flow of recursive calls, especially in functions with multiple recursive calls, resulting in unexpected behaviours. Furthermore, another mistake is the incorrect use of global variables or side effects that can complicate the function's behaviour across recursive calls. Lastly, students may overlook the efficiency of their recursive solution, not realising that an iterative approach might be more suitable for their particular problem.

To avoid stack overflow in recursive algorithms, one must ensure that the depth of recursion does not exceed the stack size. This can be achieved by careful design of the base case to ensure that it is reached before the stack limit is exceeded. Additionally, using tail recursion, where the recursive call is the last operation in the function, can help since compilers can optimise tail-recursive functions to reuse stack frames, effectively converting recursion into iteration. Moreover, implementing checks that prevent excessive recursion and using memoization to cache results of recursive calls can significantly reduce the number of calls, thus preventing stack overflow.

Without a base case, a recursive function would continue to call itself indefinitely, leading to infinite recursion and eventually a stack overflow error, where the program runs out of memory and crashes. The base case acts as a stopping condition, ensuring that each recursive call brings the function closer to a point where no further recursive calls are needed. It's the scenario where the problem can be solved directly without recursion. Without this base case, not only would the recursion be endless, but it would also fail to produce a meaningful result. The base case provides the simplest version of the problem, which is often solvable without further recursion, and from which the solution to the original problem can be built.

Direct recursion occurs when a function calls itself directly within its body. In contrast, indirect recursion involves a function calling another function that in turn calls the original function, creating a cycle of calls. For example, function A calls function B, which then calls function A, and so on. This cycle continues until a base case is reached in one of the functions to break the cycle. Both forms of recursion must have a well-defined base case to prevent infinite loops, but indirect recursion can be more challenging to trace and understand due to the multiple functions involved.