Open In App

Recursion Algorithms

Last Updated : 03 Apr, 2024
Like Article

Recursion is technique used in computer science to solve big problems by breaking them into smaller, similar problems. The process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function. Using a recursive algorithm, certain problems can be solved quite easily.


What is Recursion?

Recursion is a programming technique where a function calls itself within its own definition. This allows a function to break down a problem into smaller subproblems, which are then solved recursively.

How Does Recursion Work?

Recursion works by creating a stack of function calls. When a function calls itself, a new instance of the function is created and pushed onto the stack. This process continues until a base case is reached, which is a condition that stops the recursion. Once the base case is reached, the function calls start popping off the stack and returning their results.

What is a Recursive Algorithm?

A recursive algorithm is an algorithm that uses recursion to solve a problem. Recursive algorithms typically have two parts:

  1. Base case: Which is a condition that stops the recursion.
  2. Recursive case: Which is a call to the function itself with a smaller version of the problem.

Types of Recursion

There are several different recursion types and terms. These include:

  • Direct recursion: This is typified by the factorial implementation where the methods call itself.
  • In-Direct recursion: This happens where one method, say method A, calls another method B, which then calls method A. This involves two or more methods that eventually create a circular call sequence.
  • Head recursion: The recursive call is made at the beginning of the method.
  • Tail recursion: The recursive call is the last statement.

When to Use Recursion?

Recursion is a powerful technique that can be used to solve a wide variety of problems. However, it is important to use recursion carefully, as it can lead to stack overflows if not used properly.

Recursion should be used when:

  • The problem can be broken down into smaller subproblems that can be solved recursively.
  • The base case is easy to identify.
  • The recursive calls are tail recursive.

Examples of Recursion

Here are some common examples of recursion:

Example 1: Factorial: The factorial of a number n is the product of all the integers from 1 to n. The factorial of n can be defined recursively as:

factorial(n) = n * factorial(n-1)

Example 2: Fibonacci sequence: The Fibonacci sequence is a sequence of numbers where each number is the sum of the two preceding numbers. The Fibonacci sequence can be defined recursively as:

fib(n) = fib(n-1) + fib(n-2)

Applications of Recursion Algorithms:

Here are some common applications of recursion:

  • Tree and Graph Traversal: Depth-first search (DFS) and breadth-first search (BFS)
  • Dynamic Programming: Solving optimization problems by breaking them into smaller subproblems
  • Divide-and-Conquer: Solving problems by dividing them into smaller parts, solving each part recursively, and combining the results
  • Backtracking: Exploring all possible solutions to a problem by recursively trying different options
  • Combinatorics: Counting or generating all possible combinations or permutations of a set

Learn Basics of Recursion Algorithms:

Recursion in Different Languages:

Easy Problems on Recursion

Medium Problems on Recursion

Hard Problems on Recursion

Practice Sets on Recursion

Quiz based on Recursion:

Like Article
Suggest improvement
Share your thoughts in the comments

Similar Reads