Recursion Algorithms

Last Updated : 03 Apr, 2024

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

Practice Sets on Recursion

Quiz based on Recursion:

Previous
Next