What is Recursion?

Recursion is defined as a process which calls itself directly or indirectly and the corresponding function is called a recursive function.

Example 1 : Sum of Natural Numbers

Let us consider a problem to find the sum of natural numbers, there are several ways of doing that but the simplest approach is simply to add the numbers starting from 0 to n. So the function simply looks like this,

approach(1) - Simply adding one by one (Iterative Approach)

f(n) = 1 + 2 + 3 +...…..+ n

but there is another mathematical approach of representing this,

approach(2) - Recursive adding (Recursive Approach)

f(n) = 1                 n=1

f(n) = n + f(n-1)    n>=1

#include <iostream>
using namespace std;

// Recursive function to find the sum of 
// numbers from 0 to n
int findSum(int n)
{
    // Base case 
    if (n == 1) 
        return 1; 
  
    // Recursive case 
    return n + findSum(n - 1);
}

int main()
{
    int n = 5;
    cout << findSum(n);
    return 0;
}

// Recursive function to find the sum of 
// numbers from 0 to n
class Main {
    static int findSum(int n) {
        // Base case 
        if (n == 1) 
            return 1; 
        
        // Recursive case 
        return n + findSum(n - 1);
    }
    
    public static void main(String[] args) {
        int n = 5;
        System.out.println(findSum(n));
    }
}

# Recursive function to find the sum of 
# numbers from 0 to n
def find_sum(n):
    # Base case 
    if n == 1:
        return 1
    
    # Recursive case 
    return n + find_sum(n - 1)

n = 5
print(find_sum(n))

// Recursive function to find the sum of 
// numbers from 0 to n
using System;

class Program {
    static int FindSum(int n) {
        // Base case 
        if (n == 1) 
            return 1; 
        
        // Recursive case 
        return n + FindSum(n - 1);
    }
    
    static void Main() {
        int n = 5;
        Console.WriteLine(FindSum(n));
    }
}

// Recursive function to find the sum of 
// numbers from 0 to n
function findSum(n) {
    // Base case 
    if (n === 1) 
        return 1; 

    // Recursive case 
    return n + findSum(n - 1);
}

const n = 5;
console.log(findSum(n));

15

Example 2 : Factorial of a Number

The factorial of a number n (where n >= 0) is the product of all positive integers from 1 to n. To compute the factorial recursively, we calculate the factorial of n by using the factorial of (n-1). The base case for the recursive function is when n = 0, in which case we return 1.

#include <iostream>
using namespace std;

int fact(int n)
{
    // BASE CONDITION
    if (n == 0)
        return 1;
  
    return n * fact(n - 1);
}

int main()
{
    cout << "Factorial of 5 : " << fact(5);
    return 0;
}

public class Factorial {
    static int fact(int n) {
        // BASE CONDITION
        if (n == 0)
            return 1;
        return n * fact(n - 1);
    }

    public static void main(String[] args) {
        System.out.println("Factorial of 5 : " + fact(5));
    }
}

def fact(n):
    # BASE CONDITION
    if n == 0:
        return 1
    return n * fact(n - 1)

print("Factorial of 5 : ", fact(5))

using System;

class Program {
    static int Fact(int n) {
        // BASE CONDITION
        if (n == 0)
            return 1;
        return n * Fact(n - 1);
    }

    static void Main() {
        Console.WriteLine("Factorial of 5 : " + Fact(5));
    }
}

// Function to calculate factorial
function fact(n) {
    // BASE CONDITION
    if (n === 0)
        return 1;

    return n * fact(n - 1);
}

console.log("Factorial of 5 : " + fact(5));

Factorial of 5 : 120

Example 3 : Fibonacci with Recursion

Write a program and recurrence relation to find the Fibonacci series of n where n >= 0. 

Mathematical Equation:  

n if n == 0, n == 1;
fib(n) = fib(n-1) + fib(n-2) otherwise;

Recurrence Relation: 

T(n) = T(n-1) + T(n-2) + O(1)

// C++ code to implement Fibonacci series
#include <bits/stdc++.h>
using namespace std;

// Function for fibonacci

int fib(int n)
{
    // Stop condition
    if (n == 0)
        return 0;

    // Stop condition
    if (n == 1 || n == 2)
        return 1;

    // Recursion function
    else
        return (fib(n - 1) + fib(n - 2));
}

// Driver Code
int main()
{
    // Initialize variable n.
    int n = 5;
    cout<<"Fibonacci series of 5 numbers is: ";

    // for loop to print the fibonacci series.
    for (int i = 0; i < n; i++) 
    {
        cout<<fib(i)<<" ";
    }
    return 0;
}

// Function for fibonacci
public class Fibonacci {
    public static int fib(int n) {
        // Stop condition
        if (n == 0)
            return 0;

        // Stop condition
        if (n == 1 || n == 2)
            return 1;

        // Recursion function
        else
            return (fib(n - 1) + fib(n - 2));
    }

    public static void main(String[] args) {
        // Initialize variable n.
        int n = 5;
        System.out.print("Fibonacci series of 5 numbers is: ");

        // for loop to print the fibonacci series.
        for (int i = 0; i < n; i++) {
            System.out.print(fib(i) + " ");
        }
    }
}

# Function for fibonacci
def fib(n):
    # Stop condition
    if n == 0:
        return 0

    # Stop condition
    if n == 1 or n == 2:
        return 1

    # Recursion function
    else:
        return fib(n - 1) + fib(n - 2)

# Driver Code
if __name__ == '__main__':
    # Initialize variable n.
    n = 5
    print("Fibonacci series of 5 numbers is:", end=' ')

    # for loop to print the fibonacci series.
    for i in range(n):
        print(fib(i), end=' ')

// Function for fibonacci
using System;

class Fibonacci {
    public static int Fib(int n) {
        // Stop condition
        if (n == 0)
            return 0;

        // Stop condition
        if (n == 1 || n == 2)
            return 1;

        // Recursion function
        else
            return Fib(n - 1) + Fib(n - 2);
    }

    static void Main() {
        // Initialize variable n.
        int n = 5;
        Console.Write("Fibonacci series of 5 numbers is: ");

        // for loop to print the fibonacci series.
        for (int i = 0; i < n; i++) {
            Console.Write(Fib(i) + " ");
        }
    }
}

// Function for fibonacci
function fib(n) {
    // Stop condition
    if (n === 0)
        return 0;

    // Stop condition
    if (n === 1 || n === 2)
        return 1;

    // Recursion function
    else
        return fib(n - 1) + fib(n - 2);
}

// Driver Code
let n = 5;
console.log("Fibonacci series of 5 numbers is:");

// for loop to print the fibonacci series.
for (let i = 0; i < n; i++) {
    process.stdout.write(fib(i) + " ");
}

Fibonacci series of 5 numbers is: 0 1 1 2 3 

Properties of Recursion

Recursion has some important properties. Some of which are mentioned below:

• The primary property of recursion is the ability to solve a problem by breaking it down into smaller sub-problems, each of which can be solved in the same way.
• A recursive function must have a base case or stopping criteria to avoid infinite recursion.
• Recursion involves calling the same function within itself, which leads to a call stack.
• Recursive functions may be less efficient than iterative solutions in terms of memory and performance.

Types of Recursion

1. Direct recursion: When a function is called within itself directly it is called direct recursion. This can be further categorised into four types: 
   • Tail recursion,  
   • Head recursion,  
   • Tree recursion and 
   • Nested recursion.
2. Indirect recursion: Indirect recursion occurs when a function calls another function that eventually calls the original function and it forms a cycle.

To learn more about types of recursion, refer to this article.

Applications of Recursion

Recursion is used in many fields of computer science and mathematics, which includes:

• Searching and sorting algorithms: Recursive algorithms are used to search and sort data structures like trees and graphs.
• Mathematical calculations: Recursive algorithms are used to solve problems such as factorial, Fibonacci sequence, etc.
• Compiler design: Recursion is used in the design of compilers to parse and analyze programming languages.
• Graphics: many computer graphics algorithms, such as fractals and the Mandelbrot set, use recursion to generate complex patterns.
• Artificial intelligence: recursive neural networks are used in natural language processing, computer vision, and other AI applications.

Advantages of Recursion:

• Recursion can simplify complex problems by breaking them down into smaller, more manageable pieces.
• Recursive code can be more readable and easier to understand than iterative code.
• Recursion is essential for some algorithms and data structures.
• Also with recursion, we can reduce the length of code and become more readable and understandable to the user/ programmer.

Disadvantages of Recursion:

• Recursion can be less efficient than iterative solutions in terms of memory and performance.
• Recursive functions can be more challenging to debug and understand than iterative solutions.
• Recursion can lead to stack overflow errors if the recursion depth is too high.

What else can you read?

• Introduction to Recursion - Data Structure and Algorithm Tutorials
• Types of Recursion
• Recursive Functions

Introduction of Recursion

Visit Course

Introduction of Recursion

Application's of Recursion

Writing base case in Recursion