The ultimate guide to recursion interviews in JavaScript. Developed by FAANG engineers. Practice with real-world interview questions and get interview-ready in just a few hours.

If you’ve ever struggled with solving problems using recursion, or if you have to brush up your skills for an interview, this course is for you.

We'll start with the basics of what recursion is and why it’s important before diving into practicing solving actual questions. You’ll have access to detailed explanations and visualizations for each problem to help you along the way. 

By the time you have completed this course, you’ll be able to use all the concepts to solve complex real-world problems. We hope that through practicing recursion, you will be able to ace all recursion related questions in interviews at top tech companies.

Recursion for Coding Interviews in JavaScript

function balanced(testVariable, startIndex = 0, currentIndex = 0) {
  // Base case1 and 2
  if (startIndex == testVariable.length) {
    return currentIndex == 0
  }

  // Base case3
  if (currentIndex < 0) { // A closing parenthesis did not find its corresponding opening parenthesis
    return false
  }

  // Recursive case1
  if (testVariable[startIndex] == "(") { 
    return balanced(testVariable, startIndex + 1, currentIndex + 1)
  }

  // Recursive case2
  else if (testVariable[startIndex] == ")") { 
    return  balanced(testVariable, startIndex + 1, currentIndex - 1)
  }

  else {
    return false // the string contained an unrecognized character
  }
}

// Driver Code
testVariable = ["(", "(", ")", ")", "(", ")"]
console.log("The array [\"(\", \"(\", \")\", \")\", \"(\", \")\"] is balanced: " + balanced(testVariable))

testVariable = ["(", "(", ")"]
console.log("The array [\"(\", \"(\", \")\"] is balanced: " + balanced(testVariable))

## Explanation
Our task is to read an array of parentheses from left to right and decide whether the symbols are balanced. 

To solve this problem, notice that the most recent opening parenthesis must match the following closing parenthesis. The first opening parenthesis processed will be saved until the very last parenthesis is processed to find its corresponding closing parenthesis. 

> Closing parentheses match opening parentheses in the *reverse order* of their appearance, meaning that they match from the *inside out*. This is a clue that recursion can be used to solve this problem.

Let's investigate the code snippet above. 

The two variables `startIndex` and `currentIndex` are important to note. `startIndex` traverses the whole array. In each **recursive call**, it moves to the next element in the array. It is also used to check whether or not we have reached the _end_ of the array.

The `currentIndex` examines if each *opening parenthesis* has a corresponding *closing parenthesis*. If we encounter a closing parenthesis `currentIndex` is decreased by $1$ and if we encounter an opening parenthesis it is increased by $1$. If the `currentIndex` does not reach $0$ at the end of the traversal, we return `false`.

### Conditions of the array
Our array may satisfy $5$ conditions: 

1. **(Line number 3 to 5)** `startIndex` == `testVariable.length` and `currentIndex == 0`
   * In this situation, the `startingIndex` has successfully traversed the whole array and the `currentIndex` has matched every starting parenthesis to a closing parenthesis. We return `true` for this situation.

2. **(Line number 3 to 5)** `startIndex` == `testVariable.length` and `currentIndex != 0`
   * In this situation, the `startIndex` has traversed the whole array, but the `currentIndex` has *not* found a matching *closing parenthesis* for a *starting parenthesis*. We return `false` for this situation.

3. **(Line number 8 to 10)** `currentIndex < 0`
   * In this situation, we encountered no *opening parenthesis* for a *closing parenthesis* while traversing the array. Since all the closing parentheses must match opening parentheses in the *reverse order* of their appearance, this situation returns `false`.

 > These $3$ conditions are our **base cases**.

4. **(Line number 13 to 15)** `testVariable[startIndex] == "("`
   * An opening parenthesis is found, so we increase both the `startIndex` and `currentIndex` and call the function `balanced(testVariable, startIndex + 1, currentIndex + 1)`

5. **(Line number 18 to 20)** `testVariable[startIndex] == ")"`
   * A closing parenthesis is found, so we increase `startIndex` but decrease `currentIndex` and call the function `balanced(testVariable, startIndex + 1, currentIndex - 1)`

 > Conditions $4$ and $5$ are our **recursive cases**.


Let's take a look at an example:

This review provides a detailed analysis of the solution to determine whether or not an array contains balanced parenthesis.

Recursion Fundamentals

Iteration Vs Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Conclusion

Solution Review: Balance Parenthesis

Solution: Using Recursion

Explanation