Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

Unfortunately, in spite of the Fibonacci definition looking like a binary recursion,
using this technique is inefficient in this case. In fact, it takes an exponential
number of calls to compute the kth Fibonacci number in this way. Specifically, let
n k denote the number of calls performed in the execution of BinaryFib(k).
Then, we have the following values for the n k 's:
n 0 = 1
n 1 = 1
n 2 = n 1 + n 0 + 1 = 1 + 1 + 1 = 3
n 3 = n 2 + n 1 + 1 = 3 + 1 + 1 = 5
n 4 = n 3 + n2 + 1 = 5 + 3 + 1 = 9
n 5 = n 4 + n 3 + 1 = 9 + 5 + 1 = 15
n 6 = n 5 + n 4 + 1 = 15 + 9 + 1 = 25
n 7 = n 6 + n 5 + 1 = 25 + 15 + 1 = 41
n 8 = n 7 + n 6 + 1 = 41 + 25 + 1 = 67.
If we follow the pattern forward, we see that the number of calls more than
doubles for each two consecutive indices. That is, n 4 is more than twice n 2 n 5 is
more than twice n 3 , n 6 is more than twice n 4 , and so on. Thus, n k > 2 k/2 , which
means that BinaryFib(k) makes a number of calls that are exponential in k. In
other words, using binary recursion to compute Fibonacci numbers is very
inefficient.
Computing Fibonacci Numbers via Linear Recursion
The main problem with the approach above, based on binary recursion, is that the
computation of Fibonacci numbers is really a linearly recursive problem. It is not
a good candidate for using binary recursion. We simply got tempted into using
binary recursion because of the way the kth Fibonacci number, F k , depends on the
two previous values, F k−1 and F k−2 . But we can compute F k much more efficiently
using linear recursion.
In order to use linear recursion, however, we need to slightly redefine the
problem. One way to accomplish this conversion is to define a recursive function
that computes a pair of consecutive Fibonacci numbers (F k ,F k −1) using the
convention F−1 = 0. Then we can use the linearly recursive algorithm shown in
Code Fragment 3.36.
201