The ultimate guide to recursion interviews with strategies developed by FAANG engineers. Practice with real-world interview questions, detailed explanations, and visualizations to prep faster.

If you’ve got an interview coming up and want to brush up on your knowledge, or if you’ve ever struggled with solving coding problems using recursion, you'll find this course helpful.
 
You’ll start with the basics of what recursion is and why it’s important before diving into what it looks like in practice. You’ll see how recursion can help you solve a variety of different math, string, and data structure problems by using interactive code playgrounds that you can execute directly in your browser. You’ll have access to detailed explanations and visualizations for each problem to help you along the way.  
 
By the time you’re done, you’ll be able to use what you’ve learned to solve complex real-world problems and even advance more easily through your interviews at top tech companies.

Recursion for Coding Interviews in Java

## Invert the Position of Elements

Given an array, you must reverse the position of the elements in the array.

## Implementing the Code
The following code explains the concept of reversing the elements of an array using recursion.

Experiment with the code by changing the `array` elements and `size` to see how the answer changes.

import java.io.*;

class ExampleClass { 

  private static void invert(int[] array, int currentIndex) {
    if (currentIndex < array.length/2) {
      // swap array[currentIndex] and array[array.length-1-currentIndex]
      int temp = array[currentIndex];
      array[currentIndex] = array[array.length-1-currentIndex];
      array[array.length-1-currentIndex] = temp;
      
      invert(array, currentIndex+1);
    }
  }
  
  public static void main(String[] args) {
    System.out.println("Before: ");
    
    int[] array = {1,2,3,4,5,6,7};
    System.out.print("{ ");
    for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println("} ");
    
    System.out.println("After: ");
    
    invert(array, 0);
    
    System.out.print("{ ");
    for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.print("} ");
  }
}

Recursive

import java.io.*;

class sample {
  
  private static void invert(int[] arr) {
    int s = arr.length/2;
    int tmp = arr.length-1;
    int tmp2 = 0;
    for (int i=0; i<s; i++) {
      tmp2 = arr[i];
      arr[i] = arr[tmp];
      arr[tmp] = tmp2;
      tmp = tmp - 1;
    }
  }
  
  public static void main(String[] args) {
    System.out.println("Hello world");
    
    int[] a = {5,4,3,2,1,0};
    System.out.print("{ ");
    for (int i = 0; i < a.length; i++) {
      System.out.print(a[i] + ", ");
    }
    System.out.print("} ");
    
    System.out.println(" ");
    
    invert(a);
    
    System.out.print("{ ");
    for (int i = 0; i < a.length; i++) {
      System.out.print(a[i] + ", ");
    }
    System.out.print("} ");
    
  }
}

Iterative

## Understanding the Code

The code snippet above can be broken down into **two parts**: the **recursive method** and the **main** where the method is called. 

### Driver Method

The driver code is between **lines 17** and **line 34**.

* In the driver code, we have an `array` that equals to 7.

 * The method takes in 2 arguments: `array` and `0`(i.e.,the starting index value). 

* The array gets completely reversed until the completion of the method’s execution.

* The array is printed using a `for` loop.

### Recursive Method

In the method, we define the base case and the recursive case.
  

#### Base Case

The method terminates when the following condition is met:

* If the value of the `currentIndex` exceeds or is equal to half the size of the array, the method terminates. Otherwise, it continues executing the code that follows and eventually calls the recursive method.

#### Recursive Case
The recursive case is called on **line 12**.

* The method takes in two arguments. The first is the `array`. The second is the `currentIndex` which is the starting index of the array. The `currentIndex` is updated and incremented by 1 in each successive recursive call.

* Before the recursive call is made, we **swap** the values of the last index with the first index and continue modifying the value of the `currentIndex` in order to traverse through the array entirely. 

* Initially, the value of `currentIndex` is 0, and the value at `array[0]` is swapped with the value at `array[7-1-0]`, meaning the size of the array is subtracted by 1 and the value of the `currentIndex`. The recursive method `invert` is then called.

* In each recursive call,
  * From **line 8 to line 10**, the values of the array are swapped using the process explained above.

  * The value of the  `currentIndex` **is increased by 1** in order to update the value of the index and swap the values of the array at these indices in the next recursive call. 

* The method is continually called through recursion until the base condition is met.


# Invert the Position of Elements

Given an array, you must reverse the position of the elements in the array.

# Implementing the Code
The following code explains the concept of reversing the elements of an array using recursion.

Experiment with the code by changing the `array` elements and `size` to see how the answer changes.

# Understanding the Code

The code snippet above can be broken down into **two parts**: the **recursive method** and the **main** where the method is called. 

## Driver Method

The driver code is between **lines 17** and **line 34**.

* In the driver code, we have an `array` that equals to 7.

 * The method takes in 2 arguments: `array` and `0`(i.e.,the starting index value). 

* The array gets completely reversed until the completion of the method’s execution.

* The array is printed using a `for` loop.

## Recursive Method

In the method, we define the base case and the recursive case.
  

### Base Case

The method terminates when the following condition is met:

* If the value of the `currentIndex` exceeds or is equal to half the size of the array, the method terminates. Otherwise, it continues executing the code that follows and eventually calls the recursive method.

### Recursive Case
The recursive case is called on **line 12**.

* The method takes in two arguments. The first is the `array`. The second is the `currentIndex` which is the starting index of the array. The `currentIndex` is updated and incremented by 1 in each successive recursive call.

* Before the recursive call is made, we **swap** the values of the last index with the first index and continue modifying the value of the `currentIndex` in order to traverse through the array entirely. 

* Initially, the value of `currentIndex` is 0, and the value at `array[0]` is swapped with the value at `array[7-1-0]`, meaning the size of the array is subtracted by 1 and the value of the `currentIndex`. The recursive method `invert` is then called.

* In each recursive call,
  * From **line 8 to line 10**, the values of the array are swapped using the process explained above.

  * The value of the  `currentIndex` **is increased by 1** in order to update the value of the index and swap the values of the array at these indices in the next recursive call. 

* The method is continually called through recursion until the base condition is met.


In this lesson,we will learn how to invert the position of the elements in an array using recursion.

Fundamentals of Recursion

Iteration to Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Invert the Position of Elements in an Array

Invert the Position of Elements

Implementing the Code

Understanding the Code