C Program To Print Fibonacci Series Using Function

In this article, you will learn how to implement a C program to generate and print the Fibonacci series using functions, exploring both iterative and recursive approaches.

Problem Statement

The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones, usually starting with 0 and 1. The sequence typically begins: 0, 1, 1, 2, 3, 5, 8, 13, 21, and so on. The challenge is to write a C program that can generate this series up to a specified number of terms, encapsulating the logic within a function for better modularity and reusability.

Example

For a desired series length of 10 terms, the output should be: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Background & Knowledge Prerequisites

To understand this article, readers should have a basic grasp of:

• C Programming Fundamentals: Variables, data types, input/output operations.
• Loops: for or while loops for iteration.
• Functions: How to declare, define, and call functions, including passing parameters.
• Basic Recursion (for the recursive approach): Understanding of base cases and recursive calls.

Use Cases or Case Studies

The Fibonacci sequence appears in various fields and algorithms:

• Mathematics and Computer Science: Fundamental in algorithms like Fibonacci search and for understanding computational complexity.
• Nature: Patterns like the branching of trees, arrangement of leaves on a stem, and the spirals of a pineapple or sunflower often follow Fibonacci numbers.
• Financial Markets: Used in technical analysis to identify potential support and resistance levels.
• Art and Architecture: The Golden Ratio, which is approximated by the ratio of consecutive Fibonacci numbers, has been used in design for its aesthetic appeal.
• Algorithm Optimization: Used in certain dynamic programming problems to achieve optimal solutions.

Solution Approaches

We will explore two primary ways to generate the Fibonacci series using functions in C: an iterative approach and a recursive approach.

Approach 1: Iterative Approach using a Function

This approach uses a loop to generate the Fibonacci series. It is generally more efficient for larger numbers of terms as it avoids the overhead of multiple function calls associated with recursion.

• Summary: A function takes the number of terms as input and uses a for loop to calculate and print the series step by step.

// Fibonacci Series - Iterative Function
#include <stdio.h>

// Function to print the Fibonacci series up to 'n' terms iteratively
void printFibonacciIterative(int n) {
    // Step 1: Initialize the first two Fibonacci numbers
    int first = 0;
    int second = 1;
    int next;

    printf("Fibonacci Series (Iterative) up to %d terms: ", n);

    // Step 2: Handle edge cases for n=0 or n=1
    if (n <= 0) {
        printf("No terms to display.\\n");
        return;
    } else if (n == 1) {
        printf("%d\\n", first);
        return;
    }

    // Step 3: Print the first two terms
    printf("%d, %d", first, second);

    // Step 4: Loop from the 3rd term up to n terms
    for (int i = 3; i <= n; i++) {
        next = first + second;
        printf(", %d", next);
        first = second; // Move 'second' to 'first'
        second = next;  // Move 'next' to 'second'
    }
    printf("\\n");
}

int main() {
    int numTerms;

    // Step 1: Prompt user for the number of terms
    printf("Enter the number of terms for Fibonacci Series: ");
    scanf("%d", &numTerms);

    // Step 2: Call the function to print the series
    printFibonacciIterative(numTerms);

    return 0;
}

Run

• Sample Output:

Enter the number of terms for Fibonacci Series: 10
Fibonacci Series (Iterative) up to 10 terms: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

• Stepwise Explanation:

1. The printFibonacciIterative function takes an integer n (number of terms) as input.
2. It initializes first to 0 and second to 1, which are the starting points of the Fibonacci series.
3. Edge cases for n <= 0 and n == 1 are handled.
4. The first two terms (0 and 1) are printed directly.
5. A for loop iterates from the 3rd term up to n terms.
6. In each iteration, the next term is calculated as the sum of first and second.
7. next is then printed.
8. first is updated to the value of second, and second is updated to the value of next, effectively shifting the window to the next pair of numbers for the subsequent calculation.

Approach 2: Recursive Approach using a Function

This approach defines the Fibonacci sequence recursively. While elegant for its direct translation of the mathematical definition, it can be less efficient for large inputs due to repeated calculations.

• Summary: A helper function recursively calculates the Nth Fibonacci number, and the main function iterates to print each term using this helper.

// Fibonacci Series - Recursive Function
#include <stdio.h>

// Function to calculate the Nth Fibonacci number recursively
int fibonacciRecursive(int n) {
    // Step 1: Define the base cases
    if (n <= 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    }
    // Step 2: Define the recursive step
    else {
        return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
    }
}

int main() {
    int numTerms;

    // Step 1: Prompt user for the number of terms
    printf("Enter the number of terms for Fibonacci Series: ");
    scanf("%d", &numTerms);

    printf("Fibonacci Series (Recursive) up to %d terms: ", numTerms);

    // Step 2: Loop to print each term using the recursive function
    for (int i = 0; i < numTerms; i++) {
        printf("%d", fibonacciRecursive(i));
        if (i < numTerms - 1) {
            printf(", ");
        }
    }
    printf("\\n");

    return 0;
}

Run

• Sample Output:

Enter the number of terms for Fibonacci Series: 8
Fibonacci Series (Recursive) up to 8 terms: 0, 1, 1, 2, 3, 5, 8, 13

• Stepwise Explanation:

1. The fibonacciRecursive function calculates the Fibonacci number at a specific position n.
2. Base Cases: It defines two base cases:

• If n is 0, it returns 0.
• If n is 1, it returns 1.

1. Recursive Step: For n > 1, it recursively calls itself twice: fibonacciRecursive(n - 1) and fibonacciRecursive(n - 2), and returns their sum.
2. In main, a for loop iterates from 0 to numTerms - 1.
3. In each iteration, fibonacciRecursive(i) is called to get the i-th Fibonacci number, which is then printed.

Conclusion

Generating the Fibonacci series using functions in C can be accomplished through both iterative and recursive methods. The iterative approach is generally preferred for its efficiency, especially for generating a large number of terms, as it avoids redundant calculations and function call overhead. The recursive approach, while concise and directly reflecting the mathematical definition, can lead to performance issues due to its exponential time complexity for larger inputs. Understanding both allows for choosing the appropriate method based on specific requirements for performance and code clarity.

Summary

• The Fibonacci series is a sequence where each number is the sum of the two preceding ones, typically starting 0, 1.
• Functions encapsulate the logic for generating the series, promoting modularity.
• Iterative Approach: Uses a loop (e.g., for) to calculate terms sequentially.
• Pros: Efficient, avoids recursion overhead, suitable for large n.
• Cons: Can be slightly less concise than recursion for some.
• Recursive Approach: Defines Fibonacci numbers in terms of previous numbers, with base cases.
• Pros: Elegant, directly maps to mathematical definition.
• Cons: Less efficient for large n due to repeated calculations (exponential time complexity), can lead to stack overflow for very large n.
• Choose the iterative method for performance-critical applications and the recursive method for pedagogical clarity or when n is small.