# Recursion in Java

Recursion in java is a process in which a method calls itself and the method that calls itself is known as a recursive method. Recursion provides a way to break complicated problems into simple smaller problems which are easier to solve.Using recursion, certain problems can be solved easily like Tower of Hanoi, fibonacci number, tree traversals etc.

For beginner, recursion can be difficult to understand in the first place but once you understand it, a whole new world of programming will open for you.

## Understanding Recursion

• Principles of Recursion : Recursion is based on the idea of breaking down a problem into smaller instances of the same problem until a base case is reached. The base case is a condition that stops the recursive calls and provides a direct result. Without a base case, the recursion would continue indefinitely, leading to a stack overflow.

• Characteristics of Recursive Functions : A recursive function typically exhibits the following characteristics:
• Self-Call : The function calls itself.

• Base Case : A condition that stops the recursion.

• Progress Towards Base Case : Each recursive call should bring the problem closer to the base case.

### Syntax of recursive function

```return_type method_name(){
//statements
methodname();
}
```

Let's see how we can use recursion to find the value of factorial N.

```N! = 1 x 2 x 3 x 4....x (N-2) x (N-1) x N
N! = (N-1)! x N
```
Let factorial(N) is a function to calculate and return value of N!. As per the above recurrence equation, To find factorial(N) we can first calculate factorial(N-1) then multiply it with N.
```factorial(N) = factorial(N-1) x N
```
Function factorial(N) reduces the problem of finding factorial of a number N into sub-problem of finding factorial on N-1. Here is a recursive function implementing above mentioned recurrence relationship.
```public int factorial(int n) {
if (n <= 1) {
return 1;
}
return factorial(n - 1) * n;
}
```
In the above method, we have called factorial() method from the body the factorial() method. In order to stop the recursive call, we need to provide some termination condition inside the method. Otherwise, the method will be called infinitely and it will never terminate. Hence, we have added a if statement(n <= 1) to terminate the recursive call.

Recursion termination condition

Recursive functions can run into the problem of infinite recursion. When the recursive function never stops calling itself, it is called infinite recursion.

Every recursive function should have a termination condition, which is the condition where the function stops calling itself. In above method, the termination condition is when n <= 0, then we return 1 instead of calling fatorial method again.

• Solving Complex Problems : Recursion is particularly useful for solving problems with a recursive structure, such as tree traversal, sorting, and searching algorithms.

• Memory Efficiency : In some cases, recursion can be more memory-efficient than iterative solutions. However, it's essential to be cautious, as excessive recursion can lead to stack overflow errors.

• Readability and Simplicity : Recursion often leads to more concise and readable code, especially for problems that can be naturally divided into smaller subproblems.

## Java programs to find factorial of a number using recursion

```public class FactorialRecursion {
static int factorial(int n) {
System.out.println("N = " + n);
// recursion termination condition
if (n &lt;= 1) {
return 1;
}
// Recursive call
return factorial(n - 1) * n;
}

public static void main(String[] args) {
int factorial5 = factorial(5);
System.out.println("Factorial 5 = " + factorial5);
}
}
```
Output
```N = 5
N = 4
N = 3
N = 2
N = 1
Factorial 5 = 120
```

## Java programs to print Nth fibonacci number using recursion

Fibonacci sequence is the series numbers in the following integer sequence
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 ....
the first two numbers in the Fibonacci sequence are 0 and 1, and each subsequent term is the sum of the previous two terms. Nth term of Fibonacci series is defined by the recurrence relation:

fibonacci(N) = Nth term in fibonacci series
fibonacci(N) = fibonacci(N - 1) + fibonacci(N - 2);
whereas, fibonacci(0) = 0 and fibonacci(1) = 1

For Example :
fibonacci(4) = fibonacci(3) + fibonacci(2);

```public class FibonacciRecursion {

static int fibonacci(int n) {
// Recursion termination condition
if(n < 2) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}

public static void main(String[] args) {
int sixthTerm = fibonacci(6);
System.out.println("Sixth term = " + sixthTerm);
}
}
```
Output
```Sixth term = 8
```

## Tail Recursion

Tail recursion is a specific form of recursion where the recursive call is the last operation in the function. Some programming languages, like Scala, optimize tail-recursive functions to use a constant amount of stack space. However, as of my knowledge cutoff in January 2022, Java does not automatically optimize tail-recursive functions.

Here's an example of a tail-recursive factorial function:

```public class TailRecursionExample {
public static void main(String[] args) {
int number = 5;
long factorial = getTailRecursiveFactorial(number, 1);
System.out.println("Factorial of " + number + " is: " + factorial);
}

public static long getTailRecursiveFactorial(int n, long result) {
// Base case
if (n == 0 || n == 1) {
return result;
} else {
// Tail-recursive call
return getTailRecursiveFactorial(n - 1, n * result);
}
}
}
```
In this example, the recursive call is the last operation, making it a tail-recursive function. However, it's important to note that, as of the last update, Java doesn't perform automatic tail-call optimization.

## Best Practices for Recursion in Java

• Establish Base Cases Carefully : Ensure that base cases are well-defined and cover all possible scenarios. They should be reached through the recursive calls and prevent infinite recursion.

• Choose the Right Problems : Recursion is suitable for problems that can be naturally divided into smaller, similar subproblems. Not all problems are well-suited for recursion, and some may have more efficient iterative solutions.

• Be Mindful of Stack Space : Recursion involves creating a new stack frame for each function call. Be cautious about potential stack overflow errors, especially for problems with a large depth of recursion.

• Use Memoization for Efficiency : For recursive functions that compute the same values multiple times, consider using memoization to cache and reuse results.

## Common Pitfalls in Recursion

• Forgetting the Base Case : Forgetting to define a base case or defining a base case that is never reached can result in infinite recursion and lead to a stack overflow error.

• Lack of Memoization : Memoization involves storing the results of expensive function calls and returning the cached result when the same inputs occur again. Without memoization, recursive functions might redundantly recompute the same values.

• Inefficient Recursion : In some cases, recursion might not be the most efficient solution. Excessive function calls can lead to a large number of stack frames, potentially causing a stack overflow.

### Conclusion

Recursion is a powerful technique in Java that allows developers to solve complex problems in an elegant and readable way. Understanding the principles of recursion, its benefits, and potential pitfalls is essential for using it effectively. As you explore recursion in Java, practice with different examples, and be mindful of base cases, you'll gain a deeper appreciation for this versatile programming concept.