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++

# What does reverse mean?

When given a string, we can do multiple actions with it. One of these being, reversing a string. By **reversing** we simply mean, we can take the string and flip it. All the letters in the front, go to the back and vice versa. The illustration below shows exactly how to do that!

> **Note:** Keep in mind that a string can be one word or multiple words.

# Implementing the Code

The code below shows how to do this with recursion! First, let's see the code then we can go on to its explanation. 

Try the code by changing the values of `sentence` and `word` to see how it works with other strings!

#include <iostream>
#include <string>
using namespace std;

  void reverseString(string &reversee, int index) 
{ 
    int n = reversee.length(); 
    if (index == n / 2) 
        return; 
    char swap = reversee[index];
    reversee[index] = reversee[n-index-1];
    reversee[n-index-1] = swap;

    reverseString(reversee, index + 1); 
} 
  

int main() {

    string sentence = "Hello World"; 
    string word = "Hello";
    int index = 0;
  
    cout<< "Reversing the sentence: "<<sentence<<endl;
    reverseString(sentence, index); 
    cout<< sentence <<endl;
    
    cout<< "Reversing the word: "<<word<<endl;
    reverseString(word, index); 
    cout<< word<< endl; 

}

# Understanding the Code

The recursive code can be broken down into **two parts**. The first is the **recursive function** and the second is the **main** where the function is called. 

## Driver Function

The recursive function is called within the driver function so lets first look at what it does, from **line 18 to 32**. 

* The main function simply declares two **string** variables, `sentence` and `word`. 

* Another variable of **int** type, `index` is declared which is set to 0 and is passed as the second argument to the `reverseString()` function. 

* The main function first displays the string, passes it to the reversal function, and then displays it again to show the changes! 

## Recursive Function

In a recursive function, there are two parts; base case and recursive case. 

### Base Case
* The **if condition from line 8 to 9** denotes that once the *middle* of the string is reached, i.e. `index` is equal to `n/2`, then return back to main. This is where the method will terminate. This allows us to know the point at which the recursion will stop. 

### Recursive Case

* The function takes in two arguments; the **first** argument is the address of the string being passed to it. This is denoted by the **&** sign. We take the address to ensure that the string is being altered outside the scope of the function as well. The **second** argument is the index at which the string will start its swap. This index is initially set to **0** for each string and is then increased as the code progresses for each swap. 

* The first step in the function is to find out the **length** of the string, which is done using the built-in function `length()`. This will help us find the middle of the string until we have to carry our recursion. 

* A **char** variable is declared called `swap`. This is a temporary variable that is created to store the value at the `index` position in the string so that it can be interchanged with the value at the `n-index-1` position in the string. The latter position simply takes the value that corresponds to the same position as index but from the end of the string and allows us to swap the two. 

* The last step in this function is to call the function, `reverseString` again. It takes in the same `reverse` string as the first argument but for the second argument, it now takes `index + 1`. This is to ensure that the next position and its corresponding end position can be swapped. 



This lesson will teach you how to reverse a string with recursion

Recursion Fundamentals

Recursion with Numbers

Recursion With Strings

Recursion With Arrays

Recursion with Data Structures

Reversing a String

What does reverse mean?