# Program to Print Fibonacci Series in Java

The Fibonacci series is a series of elements where, the previous two elements are added to get the next element, starting with 0 and 1. In this article, we will learn how to print Fibonacci Series in Java up to the N term, where N is the given number.

### Examples of 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:

• Fibonacci Series Using Iterative Approach
• Fibonacci Series Using Recursive Approach
• Fibonacci Series Using Memoization
• Fibonacci Series Using Dynamic Programming

## Fibonacci Series Using 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.

Below is the implementation of the Iterative Approach to Print Fibonacci Series in Java:

## Java

 `// Fibonacci series program in java` `class` `GFG {``    ``// Function to print N Fibonacci Number``    ``static` `void` `Fibonacci(``int` `N)``    ``{``        ``int` `num1 = ``0``, num2 = ``1``;``      ` `        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``// Print the number``            ``System.out.print(num1 + ``" "``);` `            ``// Swap``            ``int` `num3 = num2 + num1;``            ``num1 = num2;``            ``num2 = num3;``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``// Given Number N``        ``int` `N = ``10``;` `        ``// Function Call``        ``Fibonacci(N);``    ``}``}`

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

```

#### The complexity of the above method

Time Complexity: O(N)
Auxiliary Space: O(1)

## Fibonacci Series Using Recursive Approach

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

1. Get the number whose Fibonacci series needs to be calculated.
2. Recursively iterate from value N to 1:
• Base case: If the value called recursively is less than 1, the return 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);

Below is the implementation of the Fibonacci Series Using Recursion in Java:

## Java

 `// Recursive implementation of Fibonacci series program in java` `class` `GFG {` `    ``// Function to print the fibonacci series``    ``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 = ``10``;` `        ``// Print the first N numbers``        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``System.out.print(fib(i) + ``" "``);``        ``}``    ``}``}`

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

```

#### The complexity of the above method

Time Complexity: O(2N)
Auxiliary Space: O(1)

## Fibonacci Series Using Memoization

In the above example, Its time complexity is O(2n)  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.

Below is the implementation of the Fibonacci series using memoization:

## Java

 `// Fibonacci series program in java using memoization` `import` `java.io.*;` `class` `GFG {``    ``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];``        ``}``    ``}``}`

Output
```1 1 2 3 5 8 13 21 34 55

```

#### The Complexity of the above method

Time Complexity: O(n)
Auxiliary Space: O(n)

## 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].

Below is the implementation of the above approach:

## Java

 `// Dynamic Programming approach for``// Fibonacci series program in java` `class` `fibonacci {` `    ``// Function to find the fibonacci Series``    ``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) + ``" "``);``    ``}``}`

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

```

#### The complexity of the above method

Time Complexity: O(N)
Auxiliary Space: O(N)

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

Previous
Next