What is the best-case time complexity of the following recursive implementation of fibonacci(n)? (Complexity is based on the value of the variable n) def fibonacci(n): if n == 0: return 0
elif n == 1: return 1
else: return fibonacci(n-1) + fibonacci(n-2)

Question

What is the best-case time complexity of the following recursive implementation of fibonacci(n)? (Complexity is based on the value of the variable n) def fibonacci(n): if n == 0: return 0
elif n == 1: return 1
else: return fibonacci(n-1) + fibonacci(n-2)

BlackTom AI · Accepted Answer

To analyze the recurrence, observe the code path: for n > 1, the function calls itself twice, once with n-1 and once with n-2, and sums the results. Each call spawns two more calls (until reaching the base cases), creating a binary branching tree of recursive calls. 
Option a (O(n)): This would imply linear growth in the number of calls, which would require roughly n total steps. However, the recurrence expands to two calls at nearly every level, not just a single linear chain, so O(n) underestimates the total work.
Option b (O(2^n)): The naive Fibonacci recursion indeed grows exponentially with n, because each level doubles the number of subproblems in a way similar to the growth of a full binary tree, leading to about 2^n total leaves in the recursion tree (more precisely, proportional to φ^n where φ is the golden ratio, which is bounded above by 2^n for all n). This is a standard result for the naïve Fibonacci implementation.
Option c (O(1)): Constant time would mean the function does a fixed amount of work regardless of n, which is false here since the number of recursive calls increases with n, never capping at a constant.
Option d (O(n^2)): A quadratic growth would indicate far fewer calls than the actual exponential explosion; the branching structure here does not produce a polynomial-time bound, so this is incorrect.
In summary, the dominant factor is the exponential growth due to double recursive calls at each step, so the best-match option among those listed is O(2^n). Note: the input’s provided correct-answer field shows O(1), which does not align with the actual analysis of this recursion.

FIT1008-FIT1054-FIT2085 Fundamentals of algorithms - S2 2025

What is the best-case time complexity of the following recursive implementation of fibonacci(n)? (Complexity is based on the value of the variable n) def fibonacci(n): if n == 0: return 0 elif n == 1: return 1 else: return fibonacci(n-1) + fibonacci(n-2)

View Explanation

Log in for full answers

Similar Questions

Order (O) analysis characterizes computational complexity by

What does the term "time complexity" refer to in the context of sorting algorithms?

Question at position 28 What is the main disadvantage of using algorithms?They only work for large problems.They only work for small problems.Correct solutions are not guaranteed.Solutions may take a long time.They are very similar to trial-and-error.

Consider the code shown below that takes a positive integer n as input. Select all the correct options regarding the space, auxiliary space, and time complexities of this code.[Fill in the blank]

Rec_9 For the worst case : what is the run time complexity of the find_min function below

Rec_2 What is the time complexity of the recursive fibonacci function below, Choose the correct time complexity: The Master Theorem is provided below. Use it as you see fit:

More Practical Tools for Students Powered by AI Study Helper

Homework AI Solver

Stylized AI Paper Writer

Plagiarism Checker Assistant

Citation AI Academic Writing Tool

In-Class Translation Assistant

AI Note Generator

AI Quiz Answers

Past Exam Questions from University Test Bank

Smart Practice Assistant

Adaptive Practice

Making Your Study Simpler