How to calculate fibonacci Series Using Recursion?

How to calculate fibonacci Series Using Recursion?

The intrigue surrounding the Fibonacci series lies not just in its numerical beauty but also in its widespread appearance in nature, art, and mathematics. This sequence, seemingly simple, unfolds complexities and patterns that have fascinated mathematicians and scientists for centuries. Today, we embark on a journey to uncover one of the elegant techniques to calculate the Fibonacci series: recursion, a method that simplifies coding and adds depth to our programming arsenal.


The Fibonacci series is a sequence where each number is the sum of the two preceding ones, usually starting with 0 and 1. Its historical origin traces back to the early 13th century, attributed to Leonardo of Pisa, also known as Fibonacci. He introduced this sequence to the Western world through his work “Liber Abaci.” However, its mathematical beauty and the intrigue it holds go beyond its simple definition. Coupled with the concept of recursion, the calculation of the Fibonacci series becomes not just a programming task but a dive into the elegance of mathematical algorithms.

Understanding Recursion

Recursion, in both computing and mathematics, is a method of solving problems where the solution to a problem depends on solutions to smaller instances of the same problem. It involves functions calling themselves with progressively simpler inputs, converging towards a base case that can be solved directly.

Definition of Recursion

In computing, recursion is a method where a function calls itself directly or indirectly, allowing the function to repeat its behavior until a certain condition is met. This approach is pivotal in solving problems that can be broken down into smaller, similar problems.

How Recursion Works

Imagine a scenario where you need to count down from a specific number to zero. Instead of using a loop, you could write a function that calls itself with the current number minus one, until it reaches zero. This simple example illustrates how recursion works by breaking down a task into smaller tasks of the same nature.

Advantages and Disadvantages of Using Recursion

Recursion simplifies code and makes it easier to read, especially for tasks that are naturally recursive, like tree traversals. However, it can be less efficient and more memory-intensive than iterative solutions due to the overhead of multiple function calls and stack usage. Understanding when and where to use recursion is key to harnessing its benefits without falling into its pitfalls.

The Fibonacci Series Explained

At its core, the Fibonacci series is represented by the mathematical formula F(n) = F(n-1) + F(n-2), with base cases F(0) = 0 and F(1) = 1. This formula succinctly captures the essence of the series, providing a foundation for both iterative and recursive approaches to its calculation.

Mathematical Formula

The derivation of the Fibonacci series from the formula F(n) = F(n-1) + F(n-2) is straightforward yet profound, illustrating the recursive nature inherent in the sequence itself.

Iterative vs. Recursive Approaches

While an iterative approach calculates the series by looping through each value, the recursive approach leverages the mathematical formula directly, applying the principle of recursion. Each approach has its merits, but the recursive method offers a more direct mapping to the mathematical definition, often making the code more intuitive and elegant.

Implementing Fibonacci Series Using Recursion

To implement the Fibonacci series using recursion, we start by defining a function that accepts an integer n as its parameter. The function then checks if n is either 0 or 1, the base cases, returning n itself. For all other cases, the function calls itself twice with the arguments n-1 and n-2, adding the results together to compute the nth Fibonacci number.

Base Case Explanation

Base cases in recursion are essential as they provide the conditions under which the recursion stops. For the Fibonacci sequence, the base cases are when n = 0 or n = 1. Without these base cases, the recursive function would call itself indefinitely, leading to a stack overflow error. In the context of the Fibonacci series, these base cases are simple yet crucial for the recursive solution to function correctly.

Recursive Case Explanation

The Fibonacci series is a sequence where each number is the sum of the two preceding ones, usually starting with 0 and 1. In the recursive approach, the base case is defined first: if the term to find is the first or second term, it returns 0 or 1, respectively. For all other terms, the function calls itself with the sum of the two preceding terms. This process continues until it reaches the base case.

Code Examples

Here are examples of calculating the Fibonacci series using recursion in Python, Java, and C++:


def fibonacci(n):
if n <= 1:
return n
return(fibonacci(n-1) + fibonacci(n-2))


1public class Fibonacci {
3 public static int fibonacci(int n) {
4 if (n <= 1) {
5 return n;
6 } else {
7 return fibonacci(n-1) + fibonacci(n-2);
8 }
9 }
11 public static void main(String args[]) {
12 int n = 10; // Example
13 System.out.println(fibonacci(n));
14 }


1#include <iostream>
2using namespace std;
4int fibonacci(int n) {
5 if (n <= 1)
6 return n;
7 else
8 return fibonacci(n-1) + fibonacci(n-2);
11int main() {
12 int n = 10; // Example
13 cout << fibonacci(n);
14 return 0;

Optimizing Recursive Fibonacci Solutions

The naive recursive approach, while straightforward, is highly inefficient for large values of n due to repetitive calculations of the same subproblems.

Overlapping Subproblems

Overlapping subproblems occur when the same calculations are performed multiple times, as seen in the recursive calculation of Fibonacci numbers. This redundancy leads to exponential time complexity.

Introduction to Memoization/Dynamic Programming

Memoization is a technique used to optimize recursive algorithms by storing the results of expensive function calls and reusing them when the same inputs occur again, eliminating the need for redundant calculations. This approach is a cornerstone of dynamic programming.

Optimized Solution Code Examples

Here are the optimized solutions using memoization in Python, Java, and C++:


def fibonacci(n, memo={}):
if n in memo:
return memo[n]
if n <= 1:
return n
memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo)
return memo[n]


1import java.util.HashMap;
3public class Fibonacci {
5 private static HashMap<Integer, Integer> memo = new HashMap<>();
7 public static int fibonacci(int n) {
8 if (memo.containsKey(n)) {
9 return memo.get(n);
10 }
11 if (n <= 1) {
12 return n;
13 } else {
14 int result = fibonacci(n-1) + fibonacci(n-2);
15 memo.put(n, result);
16 return result;
17 }
18 }
20 public static void main(String args[]) {
21 int n = 10; // Example
22 System.out.println(fibonacci(n));
23 }


1#include <iostream>
2#include <unordered_map>
3using namespace std;
5unordered_map<int, int> memo;
7int fibonacci(int n) {
8 if (memo.find(n) != memo.end())
9 return memo[n];
10 if (n <= 1)
11 return n;
12 else {
13 memo[n] = fibonacci(n-1) + fibonacci(n-2);
14 return memo[n];
15 }
18int main() {
19 int n = 10; // Example
20 cout << fibonacci(n);
21 return 0;

Sharing is caring

Did you like what Rishabh Rao wrote? Thank them for their work by sharing it on social media.


No comments so far