Recursive Functions Using Fibonacci Series [closed] - c++

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking for code must demonstrate a minimal understanding of the problem being solved. Include attempted solutions, why they didn't work, and the expected results. See also: Stack Overflow question checklist
Closed 9 years ago.
Improve this question
I am self-learning C++ from Sams Teach Yourself C++ In One Hour A Day and on page 150 the author discusses recursive functions using the Fibonacci Series.
He uses the following code:
#include <iostream>
using namespace std;
int GetFibNumber(int FibIndex)
{
if(FibIndex < 2 )
return FibIndex;
else
return GetFibNumber(FibIndex - 1) + GetFibNumber(FibIndex - 2);
}
int main()
{
cout << " Enter 0 based index of desired Fibonacci Number: ";
int Index = 0;
cin >> Index;
cout << " Fibonacci number is: " << GetFibNumber(Index) << endl;
return 0;
}
What is the difference between having
return GetFibNumber(FibIndex - 1) + GetFibNumber(FibIndex - 2);
and
return FibIndex - 1 + FibIndex - 2;
Why do you have to call the function inside itself?
Thank you in advance!

Answer 1

You ask: "Why do you have to call the function inside itself?" Well, strictly, you don't.
The Fibonacci sequence is the sequence of numbers defined by this mathematical recursion:
a0 = 0
a1 = 1
an = an-1 + an-2
The original function does compute this sequence, albeit inefficiently. If Index is 0 it returns 0; if it is 1, it returns 1. Otherwise it returns GetFibNumber(Index - 1) + GetFibNumber(Index - 2), which is precisely what the mathematical definition is. For each element of the sequence, you must add the two previous terms in the sequence.
Your code just returns Index - 1 + Index - 2, which will give a different numerical sequence. Compare:
Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 36...
Yours: 0, 1, 1, 3, 5, 7, 9, 11, 13, 17...
But that aside, you do not strictly need a recursive function to compute this mathematical recursion. All you need is a simple for loop:
int GetFibNumber(int FibIndex)
{
if(FibIndex < 2 )
return FibIndex;
int a_n_2 = 0, a_n_1 = 1, a_n;
for (i = 2; i < FibIndex; i++)
{
a_n = a_n_1 + a_n_2;
a_n_2 = a_n_1;
a_n_1 = a_n;
}
return a_n;
}
This approach will be much faster, also.
The code-recursive technique is mathematically correct. It is, however, slower, because it doesn't reuse any computations. It computes an-1 by reworking the recursion all the way back to a1. It then computes an-2, without reusing any of the work that generated an-1. And if you consider this lack-of-reuse happens at every step of the recursion, you'll see that the running time grows exponentially for the recursive function. It grows linearly for the for loop, though.
Advanced topic: There is a way to make the recursive version run faster, and that can be important to know if you run into a programming problem that is most readily defined recursively. Once you're much more comfortable with C++, look up memoization. A memoized recursive Fibonacci gives linear worst-case run-time, and constant run time for repeated lookups (assuming the memo lookup is itself O(1)).

Answer 2

Using the version that does not use recursion is not correct. It will only compute correctly first few Fiboonacci numbers. Try to compute first 10 Fibonacci numbers using the two versions and you will see yourself the two versions compute two different sequences.

Answer 3

The function GetFibNumber calculates the Nth number in the Fibonacci series. If you just take a look the explanation on http://en.wikipedia.org/wiki/Fibonacci_number it is calculated by adding the Nth-1 and Nth-2 numbers in the Fibinacci series. And this is exactly what the function does. You provide the function with an index in the Fibonacci series that you want to calculate (lets say 6; this should have 8 as result).
To calculate the 6th element in the Fibonacci series you need to add the 5th and 4th elements together. So you first need to calculate those. This is where recursion steps in. You can let the function call itself; but instead of calling it again with the value 6 as parameter you now use 5 and 4. This will again lead to the same problem (you need to calc 5th element by adding elements 4 and 3), etc. etc.
With the recursive function you can simply re-use the code to perform the same calculation over and over again until you reach a certain point where you have an answer for the calculation (in this case if N = 1 or N = 0; these cases will result in 1).

Answer 4

I would suggest, since you are still learning, to program this both recursively (like the author did) and using a loop (while, for). It will most likely show you the answer on how this algorithm is built up.
Hint 1: You must know that Fibonnaci sequences are built up upon two initial values...
Hint 2: For when it comes to recursion, you should know how the function results are stored. That will explain your question as well.

Answer 5

They are not equvialent, and it certainly won't calculate the fibonanic sequence. Recursion can be thought of like a tree, so to compute Fib(8) say, by definition we take Fib(7) + Fib(6)
Fib(8)
/ \
Fib(7) Fib(6)
Which in turn require computing Fib(6), Fib(5), Fib(4) as follows:
Fib(8)
/ \
Fib(7) Fib(6)
/ \ / \
Fib(5) Fib(6) Fib(5) Fib(4)
And so on. What you are doing, would produce a different, depth 1 tree:
Fib(8)
/ \
7 6
Because, if you never call the function within the function, it can never go more deep. It should be clear from this and the other answers why it is not correct.