## Introduction

In the previous chapters, we explored various aspects of functions in C, including their definition, usage, and parameter passing mechanisms. In this chapter, we will focus on recursion, a powerful programming technique where a function calls itself to solve smaller instances of the same problem. Recursion is particularly useful for problems that can be broken down into smaller, repetitive tasks.

## What is Recursion?

Recursion is a process where a function calls itself directly or indirectly to solve a problem. A recursive function typically has two main components:

**Base Case**: A condition under which the function stops calling itself, preventing an infinite loop.**Recursive Case**: The part of the function that reduces the problem into smaller instances and calls the function itself.

## Syntax

The basic syntax for a recursive function in C is as follows:

```
return_type function_name(parameters) {
if (base_case_condition) {
return base_case_value;
} else {
// Recursive case
return function_name(modified_parameters);
}
}
```

## Example: Factorial of a Number

One of the classic examples of recursion is calculating the factorial of a number. The factorial of a number `n`

(denoted as `n!`

) is the product of all positive integers less than or equal to `n`

.

### Example: Recursive Function to Calculate Factorial

```
#include <stdio.h>
// Function prototype
int factorial(int n);
int main() {
int num = 5;
int result;
// Calling the recursive function
result = factorial(num);
// Printing the result
printf("Factorial of %d is %d\n", num, result);
return 0; // Returning 0 to indicate successful execution
}
// Function definition
int factorial(int n) {
if (n == 0) {
return 1; // Base case: factorial of 0 is 1
} else {
return n * factorial(n - 1); // Recursive case
}
}
```

**Output:**

```
Factorial of 5 is 120
```

In this example, the `factorial`

function calls itself with the argument `n - 1`

until the base case (`n == 0`

) is reached.

## Example: Fibonacci Series

Another classic example of recursion is generating the Fibonacci series. The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones, starting from 0 and 1.

### Example: Recursive Function to Generate Fibonacci Series

```
#include <stdio.h>
// Function prototype
int fibonacci(int n);
int main() {
int n = 10;
// Printing the first n Fibonacci numbers
for (int i = 0; i < n; i++) {
printf("%d ", fibonacci(i));
}
return 0; // Returning 0 to indicate successful execution
}
// Function definition
int fibonacci(int n) {
if (n == 0) {
return 0; // Base case: Fibonacci of 0 is 0
} else if (n == 1) {
return 1; // Base case: Fibonacci of 1 is 1
} else {
return fibonacci(n - 1) + fibonacci(n - 2); // Recursive case
}
}
```

**Output:**

```
0 1 1 2 3 5 8 13 21 34
```

In this example, the `fibonacci`

function calls itself twice with the arguments `n - 1`

and `n - 2`

until the base cases (`n == 0`

or `n == 1`

) are reached.

## Understanding Recursive Functions

### Base Case

The base case is the condition that stops the recursion. Without a base case, the function would call itself indefinitely, leading to a stack overflow.

### Recursive Case

The recursive case is the part of the function that reduces the problem into smaller instances and makes the recursive call. Each recursive call should bring the problem closer to the base case.

## Advantages and Disadvantages of Recursion

### Advantages

**Simplifies Code**: Recursion can simplify the code for problems that have a natural recursive structure, making it easier to write and understand.**Elegance**: Recursive solutions are often more elegant and concise than their iterative counterparts.

### Disadvantages

**Performance**: Recursive functions can be less efficient and slower than iterative solutions due to the overhead of multiple function calls.**Stack Overflow**: Excessive recursion can lead to stack overflow if the recursion depth exceeds the stack size.

## When to Use Recursion

Recursion is particularly useful for problems that can be broken down into smaller, repetitive tasks. Common examples include:

- Calculating factorials
- Generating Fibonacci series
- Traversing trees and graphs
- Solving puzzles (e.g., Towers of Hanoi)
- Implementing algorithms (e.g., quicksort, mergesort)

## Conclusion

Recursion is a powerful programming technique in C that allows you to solve complex problems by breaking them down into smaller, more manageable tasks. By understanding the components of a recursive function (base case and recursive case) and the advantages and disadvantages of recursion, you can write more efficient and elegant code. While recursion can simplify code for certain problems, it is essential to use it judiciously and be aware of its potential performance implications.