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

class Solution { 
    /* Returns count of nodes in linked list */
    public static int lengthOfList(Node head) 
    { 
        // Base case 
        if (head == null) {
            return 0; 
        }
        // Recursive case
        else {
            return 1 + lengthOfList(head.next); 
        }
    } 
  
    public static void main(String[] args) 
    { 
        /* Start with the empty list */
        LinkedList llist = new LinkedList(); 
        llist.push(1); 
        llist.push(3); 
        llist.push(1); 
        llist.push(2); 
        llist.push(1); 
  
        System.out.println("Count of nodes is = " + lengthOfList(llist.head)); 
    } 
} 

# Understanding the Code

The code given 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 from **line 17 to line 25**.

* In the driver code, from **line 18 to line 23**, a new linked list `llist` is created and 5 new nodes are added to the list.

* The `lengthOfList` method is called. This takes only 1 argument, the `head`, which points to the first element of the list.

* The `lengthOfList` method returns the length of the list when it is called. 


## Recursive Method
Each recursive method has two parts: the **base case**  and the **recursive case**.

### Base Case
The base case is defined on **line 6**.

If the list has been fully traversed, i.e, `head` equals null, then the method returns the length of the list. It also covers the case when the list is empty. If the head equals null, then the method should simply terminate.

### Recursive Case
The recursive method is defined on **line 11**.

* The method takes only 1 argument, `head`, which is a reference variable that points to the first node of the list. The `head` of the list gets updated in each call to the method.

* Initially, `head` points to the start node.

* In every successive recursive call, the `head` points to the next node while adding 1.

* When the `head` points to null, meaning, it reaches the end of the list, the base case is reached.

* The length of the linked list is then returned.

This lesson provides a detailed review of the solution to the challenge in the previous lesson.

Fundamentals of Recursion

Iteration to Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Solution Review: Length of a Linked List

Solution: Length of a Linked List

Understanding the Code