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

class Stack {
	
	// constrictor
	constructor() {
		this.myStack = [];
	}
	
  // push an element in stack
	push(newData) {
    this.myStack.unshift(newData)
	}

  // check whether stack is empty or not
  isEmpty() {
    if(this.myStack.length == 0) {
      return true;
    }
    else {
      return false;
    }
  }

  // pop element from the top of the stack
  pop() {
    if (this.isEmpty() == false)
    {
      var temp = this.myStack[0];
      this.myStack = this.myStack.slice(1);
      return temp;
    }
    else 
    {
      throw new Error("End of Stack reached");
    }
  }
	
  // function for returning the stack
	getStack() {
		return this.myStack;
	}
}

module.exports =  Stack;

import Stack from './stack.js'

function insertAtBottom(stack, item) { // Creating a helper function
  // Base case
  if (stack.isEmpty() == true) {
    stack.push(item);
  }

  // Recursive case
  else {
    var temp = stack.pop();
    insertAtBottom(stack, item);
    stack.push(temp);
  } 
}
 
function reverse(testVariable) {
  // Recursive case
  if (testVariable.isEmpty() == false) {
    var temp = testVariable.pop();
    reverse(testVariable);
    insertAtBottom(testVariable, temp);
  }
}

myStack = new Stack(); 
myStack.push(2); 
myStack.push(3); 
myStack.push(5); 
myStack.push(8); // <---- 8 will be at the top of the stack because it was pushed last

console.log("Original Stack: ");
console.log(myStack.getStack());

reverse(myStack);

console.log("Reversed Stack: ");
console.log(myStack.getStack());

import stack as s
 
def insertAtBottom(stack, item) : # Creating a helper function
  if s.isEmpty(stack) :
    s.push(stack, item)

  else:
    temp = s.pop(stack)
    insertAtBottom(stack, item)
    s.push(stack, temp) 

def reverse(testVariable) :
  if not s.isEmpty(testVariable) :
    temp = s.pop(testVariable)
    reverse(testVariable)
    insertAtBottom(testVariable, temp)

## Explanation

A simple solution to reversing a stack is to create another stack. Pop elements from the old stack into the new stack and we will have the reversed contents in the new stack.

However, the problem statement asked us specifically to *not* use any other data structure or stack.

Let's have a look at the `reverse()` function in `index.js` file. A particular call to this function: 
* removes the top element from the stack, 
* relies on a recursive call to reverse the rest of the stack and 
* places the previously top item at the bottom of the stack. 


### Functions `reverse()` and `insertAtBottom()`:
In `index.js` file, we have created two functions: `reverse()` and `insertAtBottom()`.

1. The `reverse()` function checks whether or not the stack is empty. If the stack is not empty, we *pop* the top element and store it in `temp` variable. We then call `reverse()` function again on the updated stack. When this child function returns, we call the helper function `insertAtBottom()`.
    > What will be the **base case** for the `reverse()` function? 

This review provides a detailed analysis of the solution to reverse a stack using recursion.

Recursion Fundamentals

Iteration Vs Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Conclusion

Solution Review: Reverse a Stack

Solution: Using Recursion

Explanation