The ultimate guide to recursion interviews. Developed by FAANG engineers, practice with real-world C++ problems, interactive code playgrounds, and get interview-ready in just a few hours.

If you’ve ever struggled with solving coding problems using recursion, or if you’ve just got an interview coming up and want to brush up on your knowledge, you’ll definitely 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, using interactive code playgrounds 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 C++

# Print Reversed Linked List
Given a linked list, we do not have to change the content of the list, but we have to access each node in such a way that the linked list is printed in a reversed manner.

The following illustration explains the concept:

# Implementing the Code
The following code helps to print the linked list in a reversed manner using recursion:

#include<iostream>
using namespace std; 
  
// Node Class
class Node  
{  
    public: 
    int data;  
    Node *next;  
};  
  
  
//prints a linked list in reverse manner 
void reverse(Node* head)  
{  //base case
    if(head == NULL)  
        return;  
    //recursive case
    reverse(head->next);  
    cout << head->data << " ";  
}  
  
  
//push a new node
void insertAtHead(Node** head, int new_data)  
{  
    //make a new node
    Node* new_node = new Node(); 
      
    //insert data in the node
    new_node->data = new_data;  
      
   //make the new_node->next points to head
    new_node->next = (*head);  
      
    //head points at new node
    (*head) = new_node;  
}  
  
//Driver Function
int main()  
{  
    //emty list
    Node* head = NULL;  
      
    //insert Data in the list
    insertAtHead(&head, 5);  
    insertAtHead(&head, 4);  
    insertAtHead(&head, 3);  
    insertAtHead(&head, 2);  
    insertAtHead(&head, 1);  
      
    cout<<"List 1->2->3->4->5 \n Reverse List:";  
    reverse(head);  
  
    return 0;  
}  
  

# Understanding the Code
A recursive code can be broken down into **two parts**. The  **recursive function** and the **main** where the function is called.

## Driver Function
The driver code is from **line 41 to line 57**.
* In the driver code, a linked list has been declared by calling the `insertAthead` method.
* The `reverse` function is called which takes only 1 argument i.e., the `head` of the list. 


## Recursive Function
Each recursive Function has two parts - **base case**  and **recursive case**.

### Base Case
The base case is defined on **line 16**.
When the `head` of the linked list points to null, it indicates that the entire list has been traversed, and the function terminates.

### Recursive Case
The recursive function is defined on **line 19**.

* The function takes only 1 argument, i.e., `head` which is a  pointer that points to the first node of the list. The `head` of the list gets updated in each call.
* Initially, `head` points to the start node. In every successive recursive call, the `head` points to the next node.
* When the `head` points to null, i.e., it reaches the end of the list, the base case is reached, then it prints the values of the node in a reverse manner.


# Understanding Through a Stack
The following illustration helps to understand the code through a stack:

This lesson helps you print the linked list in reversed manner using recursion.

Recursion Fundamentals

Recursion with Numbers

Recursion With Strings

Recursion With Arrays

Recursion with Data Structures

Print a Reversed Linked List

Print Reversed Linked List