Scribd
Upload
59 views4 pages

Memoization

The document discusses implementations of the recursive Fibonacci sequence algorithm in Java. It first provides a basic recursive implementation, then shows that this has poor performance for larger inputs due to the exponential number of recursive calls. It then introduces an optimized implementation using memoization that caches previously calculated values, dramatically improving performance. For n=25, the basic recursive version takes 10 milliseconds while the memoized version takes 0 milliseconds.

Uploaded by

AD Writes
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
59 views4 pages

Memoization

The document discusses implementations of the recursive Fibonacci sequence algorithm in Java. It first provides a basic recursive implementation, then shows that this has poor performance for larger inputs due to the exponential number of recursive calls. It then introduces an optimized implementation using memoization that caches previously calculated values, dramatically improving performance. For n=25, the basic recursive version takes 10 milliseconds while the memoized version takes 0 milliseconds.

Uploaded by

AD Writes
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 4

Introduction:This article first explains how to implement recursive

fibonacci algorithm in java, and follows it up with an enhanced


algorithm implementation of recursive fibonacci in java with
memoization.

What is Fibonacci Sequence: Fibonacci is the sequence of numbers


which are governed by the recurrence relation – “F(n)=F(n-1)+F(n-
2)”.
The first 2 numbers numbers in the sequence are 0,1 . The Fibonacci
sequence, based on the recurrence relation given above, goes like this
– 0,1,1,2,3,5,8,13,21 and so on…

Recursive Fibonacci Implementation: Given below is


a recursive java program which generates numbers in the
Fibonacci sequence –

Recursive Fibonacci Implementation


public class Fibonacci {
public static long fibonacci(long n) {
if(n==0 ){
return 0;
}else if(n==1){
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
public static void main(String args[]) {
long preTime=System.currentTimeMillis();
System.out.println("Value of 25th number in fibonacci series->"+fibonacci(25));
long postTime=System.currentTimeMillis();
System.out.println("Time taken to compute in milliseconds->"+(postTim
preTime));
}
}
Output for the above program
Value of 25th number in Fibonacci series->121393
Time taken to compute in milliseconds->10
In the above program the Fibonacci calculation is done in the method
fibonacci() which takes as input a single parameter of type long (long
n), and returns the number at the nth position in the Fibonacci series.
As you must have noticed, the method is recursive in nature and calls
itself twice for computing Fibonacci numbers at the position ‘n’ and ‘n-
1’. It then adds up these 2 values which is in line with the recurrence
relation describing Fibonacci numbers.

The program also computes and prints out the time taken in
determining this number. In this case (n=25), time taken was 10
milliseconds. Lets run this program for n > 25 and see how much time
it takes. For n=30 (17 ms), n=35 (105 ms), n=40 (1023 ms),
n=45(12083 ms), n=46 (17872 ms), n=48 (30889 ms). As you can
see, the time taken is increasing at an alarming rate because the
number of recursive calls are increasing at a very high rate with every
increase in the value of n.

This deterioration in performance can be improved by an optimization


technique called Memoization. In Memoization the results of expensive
function calls, i.e. functions which take a lot of time, are cached on
their first run. These cached values are then re-used when the function
is called again with the same inputs.

Recursive Fibonacci Implementation using Memoization: Given


below is a recursive java program for Fibonacci generation which
utilizes the concept of memoization to improve its performance –
Recursive Fibonacci Implementation using Memoization
public class FibonacciWithMemoization {

public static long fibArray[]=new long[26];

public static long fibonacci(long n){


long fibValue=0;
if(n==0 ){
return 0;
}else if(n==1){
return 1;
}else if(fibArray[(int)n]!=0){
return fibArray[(int)n];
}else{
fibValue=fibonacci(n-1)+fibonacci(n-2);
fibArray[(int) n]=fibValue;
return fibValue;
}
}

public static void main(String args[]){


fibArray[0]=0;
fibArray[1]=1;
long preTime=System.currentTimeMillis();
System.out.println("Value of 25th number in Fibonacci series->"+fibonacci(25));
long postTime=System.currentTimeMillis();
System.out.println("Time taken to compute in milliseconds->"+(postTime-preTime));
}
}
Output for the above program
Value of 25th number in Fibonacci series->121393
Time taken to compute in milliseconds->0
As you can see in the above program, the value of every fibonacci
number at position ‘n’ is being stored in an array called ‘fibArray’ at
position ‘n’. At the first instance of calling fibonacci(n), the result is
also stored in fibArray[n]. Next time when this value is needed again
then instead of calculating this value again recursively, the program
simply picks it up from the array. It comes to know whether a value is
cached or not simply by checking if the value is not zero.
Using memoization, the performance improves drastically. I checked
for n=30, n=50, n=80, n=120 and so on. The time taken kept coming
as 0 ms. It was around n=150 that the time taken increased to 1 ms.
Compared to time taken without Memoization, this is a very good.

You might also like