The ultimate recursion guide! Master basics, solve real-world problems, and get interview-ready in hours with FAANG engineers’ proven strategies.

If you’ve ever struggled with solving coding problems using recursion, or if you need to brush up your recursion skills for an interview, this course is for you! We will start with the basics of recursion before we practice solving actual coding problems. 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 of recursion to solve complex, real-world problems. We hope that this course will help you ace all the recursion related questions during interviews at top tech companies!

Recursion for Coding Interviews in Python

# HELPER FUNCTION FOR CREATING AND MANIPULATING A STACK

def createStack() : # Function to create an empty stack
  stack = []
  return stack 

def isEmpty(stack) :
  return len(stack) == 0

def push(stack, item) : # push item to stack
  stack.append( item ) 

def pop(stack) : # pop item from stack

  if(isEmpty(stack)) : # display error if stack empty  
    print("Stack Underflow ")
    exit(1)

  return stack.pop() 

def printStack(stack):
  for i in range(len(stack)-1, -1, -1) :
    print(stack[i], end = ' ')

import stack as s
 
def insertAtBottom(stack, item) : # Recursive function that inserts an element at the bottom of a stack.
  # Base case
  if s.isEmpty(stack) :
    s.push(stack, item)

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

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

# Driver Code 
myStack = s.createStack() 
s.push(myStack, str(8)) 
s.push(myStack, str(5)) 
s.push(myStack, str(3)) 
s.push(myStack, str(2)) 

print("Original Stack") 
s.printStack(myStack) 

reverse(myStack) 

print("\n\nReversed Stack") 
s.printStack(myStack) 

## 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. Otherwise, the space complexity of our solution will increase.

This is where recursion becomes helpful. We pop the top element from the given stack and then recursively call another instance of the same function. When this child function returns to the parent function, append the popped element to the bottom of the stack.

In the code snippet above, 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 the **base case** for this function be? 

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