Program to Print Fibonacci Series in Java

The Fibonacci series is a series of elements where the previous two elements are added to generate the next term. It starts with 0 and 1, for example, 0, 1, 1, 2, 3, and so on. We can mathematically represent it in the form of a function to generate the n'th Fibonacci number because it follows a constant addition. The function F(n) = F(n-1) + F(n-2). Here, the F(0) is 0 and F(1) is 1, and using this function, we can find the n'th term that will come in the series.

Example of the Fibonacci Series in Java:

Input: N = 10 
Output: 0 1 1 2 3 5 8 13 21 34 
Explanation: Here, first term of Fibonacci is 0 and second is 1, so that 3rd term = first(o) + second(1) etc and so on.

There are 4 ways to write the Fibonacci Series program in Java which are listed below:

1. Fibonacci Series Using the Iterative Approach

Initialize the first and second numbers to 0 and 1. Following this, we print the first and second numbers. Then we send the flow to the iterative while loop where we get the next number by adding the previous two numbers and simultaneously, we swap the first number with the second and the second with the third. 

Example:

import java.io.*;

class Geeks
{
    // Function to print N Fibonacci Number
    static void Fibonacci(int N)
    {
        int n1 = 0, n2 = 1;

        for (int i = 0; i < N; i++) {
            // Print the number
            System.out.print(n1 + " ");

            // Swap
            int n3 = n2 + n1;
            n1 = n2;
            n2 = n3;
        }
    }

    // Driver Code
    public static void main(String args[])
    {
        // Given Number N
        int N = 10;

        // Function Call
        Fibonacci(N);
    }
}

0 1 1 2 3 5 8 13 21 34 

2. Fibonacci Series Using Recursive Approach

Since the Fibonacci Number is the summation of the two previous numbers. We can use recursion as per the following conditions:

Get the number whose Fibonacci series needs to be calculated.

Recursively iterate from value N to 1:

• Base case: If the value called recursively is less than 1, the function returns 1 the function.
• Recursive call: If the base case is not met, then recursively call for the previous two values as:

recursive_function(N - 1) + recursive_function(N - 2);

Return statement: At each recursive call(except the base case), return the recursive function for the previous two values as:

recursive_function(N - 1) + recursive_function(N - 2);

Example:

//Driver Code Starts

import java.io.*;

class Geeks
{
    // Function to print the fibonacci series
//Driver Code Ends

    static int fib(int n)
    {
        // Base Case
        if (n <= 1)
            return n;

        // Recursive call
        return fib(n - 1) + fib(n - 2);
    }

    // Driver Code
    public static void main(String args[])
    {
        // Given Number N
        int N = 3;

        // Print the first N numbers
        for (int i = 0; i < N; i++) {

            System.out.print(fib(i) + " ");
        }
    }
}

0 1 1 

3. Fibonacci Series Using Memoization 

In the above example, its time complexity is O(2ⁿ), which can be reduced to O(n) using the memoization technique, which will help to optimize the recursion method. This is because the function computes each Fibonacci number only once and stores it in the array.

Example:

import java.io.*;

class Geeks
{
    public static void main(String[] args)
    {
        // Number of terms to print
        int n = 10;
        int[] memo = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            System.out.print(fibonacci(i, memo) + " ");
        }
    }

    public static int fibonacci(int n, int[] memo)
    {
        if (memo[n] != 0)
            return memo[n];
        if (n == 1 || n == 2)
            return 1;
        else {
            memo[n] = fibonacci(n - 1, memo)
                      + fibonacci(n - 2, memo);
            return memo[n];
        }
    }
}

1 1 2 3 5 8 13 21 34 55 

Note:

Starts from fibonacci(1) instead of fibonacci(0), so 0 is not included. If you want to include 0, adjust the range to 0 to n-1 and add handling for fibonacci(0) = 0.

4. Fibonacci Series Using Dynamic Programming

We can avoid the repeated work done in method 2 by storing the Fibonacci numbers calculated so far.

The steps to writing the Program are mentioned below:

• Create an array arr[] of size N.
• Initialize arr[0] = 0, arr[1] = 1.
• Iterate over [2, N] and update the array arr[] as:   
  • arr[i] = arr[i - 2] + arr[i - 1]
• Print the value of arr[N].

Example:

import java.io.*;

class Geeks
{

    static int fib(int n)
    {
        // Declare an array to store
        // Fibonacci numbers.
        // 1 extra to handle case, n = 0
        int f[] = new int[n + 2];

        int i;

        // 0th and 1st number of
        // the series are 0 and 1
        f[0] = 0;
        f[1] = 1;

        for (i = 2; i <= n; i++) {

            // Add the previous 2 numbers
            // in the series and store it
            f[i] = f[i - 1] + f[i - 2];
        }

        // Nth Fibonacci Number
        return f[n];
    }

    public static void main(String args[])
    {
        // Given Number N
        int N = 10;

        // Print first 10 term
        for (int i = 0; i < N; i++)
            System.out.print(fib(i) + " ");
    }
}

0 1 1 2 3 5 8 13 21 34 

To know more about the Fibonacci Series, refer to the article - Program to print first n Fibonacci Numbers.