Write a Program to Find the Factorial of a Number Using Recursion in C

Factorial is a mathematical operation that multiplies a number by all the positive integers less than it. It is denoted by the symbol \( n! \), where \( n \) is a non-negative integer. The factorial of \( n \) can be defined recursively as follows:

• Base case: \( 0! = 1 \)
• Recursive case: \( n! = n \times (n-1)! \) for \( n > 0 \)

In this blog post, we will walk through how to write a C program to calculate the factorial of a number using recursion. We will also explain how the program works in detail.

1. Understanding Recursion

Recursion is a programming technique where a function calls itself to solve a problem. The recursive function must have:

• Base Case: This stops the recursion when a certain condition is met.
• Recursive Case: This defines the problem in terms of a smaller instance of itself.

For calculating the factorial:

• If \( n = 0 \), the factorial is 1.
• If \( n > 0 \), the factorial is \( n \) multiplied by the factorial of \( n-1 \).

2. Writing the Program

Below is the C program to find the factorial of a number using recursion:

Program to Find the Factorial of a Number

#include <stdio.h>

// Function to calculate the factorial of a number recursively
long long factorial(int n) {
    // Base case: if n is 0, return 1
    if (n == 0) {
        return 1;
    }
    // Recursive case: n * factorial of (n - 1)
    return n * factorial(n - 1);
}

int main() {
    int n;

    // Input: Prompt user to enter a non-negative integer
    printf("Enter a non-negative integer: ");
    scanf("%d", &n);

    // Check if the input is non-negative
    if (n < 0) {
        printf("Please enter a non-negative integer.\n");
        return 1; // Exit the program
    }

    // Calculate the factorial using the recursive function
    long long result = factorial(n);

    // Output the result
    printf("The factorial of %d is: %lld\n", n, result);

    return 0;
}

Explanation of the Code

Let’s break down the program step-by-step:

• We start by including the standard input-output header file stdio.h.
• The factorial function takes an integer \( n \) as input and returns its factorial using recursion.
• The base case checks if \( n \) is equal to 0, in which case it returns 1. This prevents infinite recursion.
• The recursive case returns \( n \) multiplied by the factorial of \( n - 1 \).
• In the main function, we prompt the user to enter a non-negative integer and check if the input is valid. We then call the recursive function and print the result.

3. Example Output

Here’s an example of how the program works:

Enter a non-negative integer: 5
The factorial of 5 is: 120

4. Common Mistakes to Avoid

• Incorrect Base Case: Always ensure your base case is correct; otherwise, your function may recurse indefinitely.
• Negative Input: Handle cases where the user might input a negative number, as factorials are defined for non-negative integers only.

5. Advantages and Disadvantages of Recursion

Advantages

• Recursion can simplify code and make it easier to read, especially for problems that naturally fit a recursive approach.
• It allows for elegant solutions to complex problems without the need for iterative constructs.

Disadvantages

• Recursive functions can lead to stack overflow errors if the recursion depth is too high, especially for large \( n \).
• They may be less efficient than iterative solutions due to the overhead of function calls.

6. Conclusion

In this post, we created a C program to find the factorial of a number using recursion. This approach demonstrates how recursion works and provides a straightforward solution to a common mathematical problem. Mastering recursion is essential for tackling more complex algorithms and problems in programming. Keep practicing, and you'll become proficient in using recursion effectively!