What Is Recursion in Data Structure and Its Types?


Heather Bennett

Recursion is a fundamental concept in data structures that plays a crucial role in solving complex problems. In simple terms, recursion is the process of solving a problem by breaking it down into smaller, more manageable subproblems. These subproblems are then solved independently and their solutions are combined to obtain the final solution.

Types of Recursion:
There are two main types of recursion: direct recursion and indirect recursion.

Direct Recursion:
Direct recursion occurs when a function calls itself within its body. This type of recursion is the most common and widely used. Let’s take a look at an example to understand it better:



Let’s write a recursive function to calculate the factorial of a number.

// Function to calculate factorial
function factorial(n) {
    // Base case: if n is 0 or 1, return 1
    if (n === 0 || n === 1) {
        return 1;
    // Recursive case: call the function with n-1 and multiply by n
    return n * factorial(n - 1);

// Call the factorial function
console.log(factorial(5)); // Output: 120


In this example, we define a function called `factorial` that calculates the factorial of a given number `n`. It first checks for the base case where `n` is either 0 or 1, in which case it returns 1.

If not, it recursively calls itself with `n-1` and multiplies the result with `n`. The function keeps calling itself until it reaches the base case, and then the results are combined to get the final factorial.

Indirect Recursion:
Indirect recursion occurs when a function calls another function, which in turn calls the original function. This creates a cycle of function calls. Let’s see an example to understand this type of recursion:



Let’s write two functions that call each other indirectly.

// Function 1
function foo() {

// Function 2
function bar() {

// Call the foo function to start the cycle
foo(); // Output: "foo" "bar" "foo" "bar" .. (infinite loop)


In this example, we have two functions, `foo` and `bar`, that call each other indirectly. When we call the `foo` function, it prints “foo” to the console and then calls `bar`.

Similarly, when we call the `bar` function, it prints “bar” to the console and then calls `foo`. This process continues indefinitely, creating an infinite loop of function calls.

Recursion is a powerful technique that allows us to solve complex problems by breaking them down into smaller subproblems. It is widely used in various data structures and algorithms.

Understanding the different types of recursion and how they work is essential for any programmer. So, make sure to grasp this concept thoroughly and leverage its power in your coding endeavors!