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

# Total Occurrences of a Number

The number of occurrences of a number means the frequency a number **n** appears in the array.

The following illustration explains the concept:

# Implementing the Code
The following code explains how to find the frequency of a number in an array using recursion.

Experiment with the code by changing the values of `array` and `num` to see how it works!

import java.io.*;

class ArrayClass {

  private static int noOfOccurrences(int[] a, int key, int currentIndex) {
    if (a.length == currentIndex) {
      return 0;
    }
    else if (a[currentIndex] == key) {
      return 1 + noOfOccurrences(a, key, currentIndex+1);
    }
    else {
      return noOfOccurrences(a, key, currentIndex+1);
    }
  }
  
  public static void main(String[] args) {
    System.out.print("{");
    
    int[] array = {2,3,4,1,7,8,3};
    for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
    }

    System.out.println("}");
    
    int key = 3;
    int output = noOfOccurrences(array, key, 0);
    System.out.println("Number of occurrences of " + key + ": "  + output);  
  }
}

Recursive

class sample {
  
  private static int occurrences(int[] arr, int n) {
    int tmp = 0;
    for (int i=0; i<arr.length; i++) {
      if (arr[i] == n)
        tmp = tmp + 1;
      else
        tmp = tmp;
    }
    return tmp;
  }
  
  public static void main(String[] args) {
    
    int[] a = {1,2,3,32,2,2,2,5};
    for (int i = 0; i < a.length; i++) {
      System.out.println(a[i]);
    }
    
    System.out.println(" ");
    
    int t = occurrences(a, 2);
    System.out.println(t);
    
  }
}

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 found from **line 18** to **line 29**.

* From **line 20 to line 27** we have an `array` equal to 7 and the number `num` whose number of occurrence is to be found. 

* The method `noOfOccurences` takes in 3 arguments i.e., the first one is an `array` of size 7; the second is `num` whose number of occurrences is to be determined,the third is `0` (i.e. the first index).
When called, it returns the number of occurrences of `num`.
 
 
## Recursive Method
In the method, `noOfOccurrences`, we define the base case and the recursive case.

### Base Case

The method terminates when the following base condition is met:

* The base case is defined from **line 6** to **line 8**. If the whole array has been traversed,the function returns 0.

$$$$

### Recursive Case

The method takes in three arguments. The first argument is the `array`. The second argument is `num` - whose number of occurrences is to be determined. The third argument is `currentIndex` which depicts the current index of the array.  

The recursive case is called in two conditions: 

* If the base condition is not true, the value of `array` at the specified `currentIndex` is compared with `num`
* If the result of the comparison is true, the count is incremented by one, on **line 10** that the element is found on the given index. The recursive method is then called again by incrementing the value of the `currentIndex` by 1. This enables the method to compare the value of the array at the next index with `num`.

* If the result of the comparison is not true, the function keeps is continually called through recursion until the base condition is met.



This lesson will teach you how to find the number of occurrences  of a particular number in an array using recursion.

Fundamentals of Recursion

Iteration to Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Count the Number of Occurrences of a Number in an Array

Total Occurrences of a Number

Implementing the Code

Understanding the Code