# Explain Recursion with Example in C

Recursion is a powerful programming method in which a function calls itself to solve an issue by breaking it down into smaller, simpler examples of the same problem, either directly or indirectly. Recursion in C is accomplished through the use of functions. Let's look at recursion using an example written in C.

Consider the problem of calculating the factorial of a number. The factorial of a non-negative integer n, denoted as n!, is the product of all positive integers from 1 to n. Mathematically, n! = n * (n-1) * (n-2) * ... * 1.

### Here's a recursive function in C to calculate the factorial:

C Program:

Let's run the code with an example input of 5 to see the output and understand the execution flow:

Output:

```Enter a non-negative integer: 4
Factorial of 4 is 24
```

### Let's walk through the code:

1. The factorial function takes an integer n as its parameter and returns an integer. Inside the function, we have two cases:
• Base case: If n is 0 or 1, the factorial is 1. So, we return 1.
• Recursive case: For any other value of n, we recursively call the factorial function with n - 1 and multiply the result with n. This ensures that we calculate the factorial of n by multiplying it with the factorial of n-1.
2. In the main function, we ask the user to enter a non-negative integer. We store the input in the variable num.
3. We call the factorial function with num as the argument and store the result in the variable result.
4. Finally, we print the calculated factorial.

### Explanation of the expected outcome of the above code:

1. The program prompts the user to enter a non-negative integer.
2. The user enters 5.
3. The factorial function is called with the argument 5.
4. Inside the factorial function:
• Since n is not 0 or 1, the function enters the recursive case.
• It calls itself with the argument 4 (5 - 1).
• A new instance of the factorial function is called with n equal to 4.
5. Inside the new instance of the factorial function:
• Again, n is not 0 or 1, so it enters the recursive case.
• It calls itself with the argument 3 (4 - 1).
• A new instance of the factorial function is called with n equal to 3.
6. This process continues until the base case is reached:
• The recursive calls are made with n decreasing by 1 each time: 2, 1, and finally 0.
• When n becomes 0, the base case is triggered.
• In this case, the function returns 1.
7. The function calls start returning the values back up the call stack:
• The instance of the factorial function with n equal to 1 returns 1.
• The instance with n equal to 2 returns 2 * 1, which is 2.
• The instance with n equal to 3 returns 3 * 2, which is 6.
• The instance with n equal to 4 returns 4 * 6, which is 24.
• Finally, the initial instance with n equal to 5 returns 5 * 24, which is 120.
8. The calculated factorial, which is 120, is printed in the main function.

The recursion process breaks down the problem of calculating the factorial of a number into smaller subproblems, each one being the factorial of a smaller number. The base case ensures that the recursion terminates, and the values are gradually computed and propagated back up the call stack to obtain the final result.

Recursion is a powerful programming technique, but it has certain characteristics, advantages, and disadvantages. Let's explore them:

### Characteristics of Recursion:

• Self-Calling: Recursion involves a function calling itself, either directly or indirectly.
• Base Case: Recursive functions have a base case that specifies when the recursion should stop. It provides a terminating condition.
• Recursive Case: Recursive functions have a recursive case that defines how the problem is broken down into smaller subproblems.
• Stack Usage: Recursive function calls are stored on the call stack, allowing the program to keep track of the recursive calls and their respective states.

• Simplicity and Readability: Recursion can lead to clean and concise code, especially when solving problems that exhibit repetitive patterns.
• Problem Solving: Recursion is useful for solving problems that can be naturally divided into smaller instances of the same problem.
• Elegant Solution: In some cases, a recursive solution may be more elegant and intuitive compared to an iterative approach.
• Recursive Data Structures: Recursion is particularly well-suited for working with recursive data structures like linked lists, trees, and graphs.

• Stack Space: Recursive function calls consume stack space, and excessive recursion or deep recursion levels can lead to stack overflow errors.
• Performance Overhead: Recursive function calls involve overhead due to the creation of new stack frames and parameter passing. In some cases, iterative solutions can be more efficient.
• Time Complexity: Recursive solutions may have higher time complexity compared to their iterative counterparts, leading to slower execution.
• Difficult Debugging: Recursive programs can be challenging to debug and trace due to the multiple levels of function calls and complex control flow.
• It's essential to use recursion judiciously, considering the characteristics and potential trade-offs. Recursion can provide elegant solutions for certain problems, but it's important to ensure that the base case is reached and the recursive calls make progress towards it. Additionally, considering the space and time complexity implications is crucial when deciding whether to use recursion or opt for an alternative approach.

## Conclusion:

When the program starts, the factorial function is invoked with the value supplied by the user. If the value is 0 or 1, the function executes the base case and returns 1. Otherwise, it enters the recursive case, where it calls itself with a lower number until it reaches the base case. The function then begins returning values up the call stack, multiplying each value by the current value of n. The final result is eventually retrieved and printed in the main function.

Recursion is a highlyeffective method, but it should be used with prudence. To avoid infinite recursion, recursive functions must have a base case and should proceed toward it with each recursive call.