Last Updated : 15 Jul, 2025
Try it on GfG Practice
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:
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:
Java
// Fibonacci series program in Java
// using iterative approach
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 34The complexity of the above method:
2. Fibonacci Series Using Recursive ApproachTime Complexity: O(N)
Auxiliary Space: O(1)
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:
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:
Java
//Driver Code Starts
// Recursive implementation of Fibonacci series
// program in Java
import java.io.*;
class Geeks
{
//Driver Code Ends
// 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 = 3;
// Print the first N numbers
for (int i = 0; i < N; i++) {
System.out.print(fib(i) + " ");
}
}
//Driver Code Starts
}
//Driver Code Ends
The complexity of the above method:
3. Fibonacci Series Using MemoizationTime Complexity: O(2N)
Auxiliary Space: O(n)
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.
Example:
Java
// Fibonacci series program using memoization
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.
The Complexity of the above method:
4. Fibonacci Series Using Dynamic ProgrammingTime Complexity: O(n)
Auxiliary Space: O(n)
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:
Java
// Dynamic Programming approach for
// Fibonacci series program
import java.io.*;
class Geeks
{
// 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) + " ");
}
}
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.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4