C++ Program To Print Fibonacci Series In C++

In this article, you will learn how to generate and print the Fibonacci series in C++ using different programming approaches. We will explore both iterative and recursive methods to solve this classic programming problem.

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 challenge is to write a C++ program that can print the first n terms of this series, where n is an integer provided by the user.

Example

If the user wants to print the first 10 terms of the Fibonacci series, the expected output would be: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Background & Knowledge Prerequisites

To understand the solutions presented in this article, readers should have a basic understanding of:

• C++ syntax: Variables, data types, input/output operations.
• Control flow statements: for loops, while loops, if-else statements.
• Functions: Defining and calling functions.
• Recursion: Understanding how functions can call themselves (for the recursive approach).

Use Cases or Case Studies

The Fibonacci sequence appears in various fields, not just in computer science. Some common applications include:

• Algorithm analysis: Used in certain sorting and searching algorithms.
• Financial modeling: Can be found in technical analysis of stock markets.
• Nature and biology: Appears in the branching of trees, arrangement of leaves on a stem, and the spiral patterns of shells and pinecones.
• Art and architecture: Utilized in design principles based on the golden ratio, which is closely related to Fibonacci numbers.
• Cryptography: Some algorithms use properties of the Fibonacci sequence.

Solution Approaches

We will explore two primary methods to generate the Fibonacci series: the iterative method and the recursive method.

Approach 1: Iterative Method (Using a Loop)

This approach uses a loop to calculate each term sequentially, building upon the previous two terms. It is generally more efficient for larger numbers of terms due to less overhead.

Summary: Calculate Fibonacci terms step-by-step using a for loop, keeping track of the last two terms.

// Fibonacci Series - Iterative
#include <iostream>
using namespace std;

int main() {
    int n;
    cout << "Enter the number of terms: ";
    cin >> n;

    int t1 = 0, t2 = 1; // Initialize the first two terms
    int nextTerm = 0;

    cout << "Fibonacci Series: ";

    // Step 1: Handle cases for n = 1 or n = 2
    if (n == 0) {
        cout << "No terms to display." << endl;
        return 0;
    } else if (n == 1) {
        cout << t1 << endl;
        return 0;
    } else {
        // Step 2: Print the first two terms
        cout << t1 << ", " << t2;
    }

    // Step 3: Calculate and print subsequent terms
    for (int i = 3; i <= n; ++i) {
        nextTerm = t1 + t2;
        cout << ", " << nextTerm;
        t1 = t2; // Update t1 to the previous t2
        t2 = nextTerm; // Update t2 to the newly calculated nextTerm
    }
    cout << endl;

    return 0;
}

Run

Sample Output:

Enter the number of terms: 10
Fibonacci Series: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Stepwise Explanation:

1. Initialize: Set t1 (first term) to 0 and t2 (second term) to 1. These are the starting points of the Fibonacci series.
2. User Input: Prompt the user to enter n, the desired number of terms.
3. Handle Edge Cases:
   • If n is 0, print a message and exit.

1. Loop for Subsequent Terms: Start a for loop from i = 3 up to n.
2. Calculate nextTerm: Inside the loop, calculate nextTerm by adding t1 and t2.
3. Print nextTerm: Print the calculated nextTerm.
4. Update Terms: Update t1 to the value of t2 and t2 to the value of nextTerm. This prepares the variables for the next iteration, moving the "window" of the last two terms forward.
5. Repeat: The loop continues until n terms have been printed.

Approach 2: Recursive Method

The recursive approach defines the Fibonacci sequence based on its own definition: F(n) = F(n-1) + F(n-2). A function calls itself to compute previous terms until it reaches the base cases.

Summary: Define a function that calls itself to compute Fibonacci numbers, with base cases for 0 and 1.

// Fibonacci Series - Recursive
#include <iostream>
using namespace std;

// Function to calculate the nth Fibonacci number
int fibonacci(int n) {
    // Step 1: Define base cases
    if (n <= 1) {
        return n; // F(0) = 0, F(1) = 1
    }
    // Step 2: Recursive step
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    int n_terms;
    cout << "Enter the number of terms: ";
    cin >> n_terms;

    cout << "Fibonacci Series: ";

    // Step 3: Iterate and call the recursive function for each term
    for (int i = 0; i < n_terms; ++i) {
        cout << fibonacci(i);
        if (i < n_terms - 1) {
            cout << ", ";
        }
    }
    cout << endl;

    return 0;
}

Run

Sample Output:

Enter the number of terms: 10
Fibonacci Series: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Stepwise Explanation:

1. fibonacci(n) function: This helper function is responsible for calculating the n-th Fibonacci number.
2. Base Cases:
   • If n is 0, it returns 0 (the 0th Fibonacci number).

1. Recursive Step: If n is greater than 1, the function returns the sum of fibonacci(n - 1) and fibonacci(n - 2). This means it recursively calls itself to find the two preceding Fibonacci numbers and adds them.
2. main function:
   • It prompts the user for n_terms.

Conclusion

We have explored two distinct methods to generate the Fibonacci series in C++. The iterative approach is generally preferred for its efficiency, especially when calculating a large number of terms, as it avoids the repeated calculations and function call overhead inherent in the recursive method. The recursive method, while elegant and closely mirroring the mathematical definition, can become computationally expensive for larger n due to its exponential time complexity without memoization.

Summary

• The Fibonacci series starts with 0 and 1, with each subsequent number being the sum of the two preceding ones.
• Iterative Method: Uses a loop to calculate terms sequentially, storing only the two previous terms. It's efficient and avoids redundant calculations.
• Recursive Method: Defines the series in terms of itself, with base cases for F(0)=0 and F(1)=1. It's concise but can be inefficient for large inputs due to repeated computations.
• For practical applications requiring many Fibonacci numbers, the iterative approach is generally recommended over naive recursion.