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

#include<iostream>
using namespace std;

//Recursive function to sort the array
void SortArray(int arr[], int startIndex, int size)
{
  // find the minimum element in the unsorted subarray[i..n-1]
	// and swap it with arr[startIndex]
	int min = startIndex;
	for (int j = startIndex + 1; j < size; j++)
	{
		// if arr[j] element is less, then it is the new minimum
		if (arr[j] < arr[min])
			min = j;	// update index of min element
	}
	
    //swap values at two indices in the array
  int Swap= arr[startIndex]; 
  arr[startIndex]= arr[min]; 
  arr[min]= Swap;

   // base case
	if (startIndex + 1 < size) { //if one element is left to be sorted
		SortArray(arr, startIndex + 1, size); // recursive case
	}
}

void printSortArray(int *numbers, int size)
{
  SortArray(numbers, 0, size);//call the recursive function
    for (int i=0;i<size;i++)//print elements of the array
        cout << numbers[i] << ' ';
}
//Driver function
int main()
{
    int array[] = {3, 2, 9, 1, 8};// define an array
    int size=5;//define the size of array
    cout<<"Sorted Array:\n";
    printSortArray(array, size);//call the print function
    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 35 to 41**.
* In the driver code, an `array` of `size` 5 is defined.
* The function `printSortArray` is defined which takes two arguments i.e., the `array` and `size`.

## Utility Function
The utility function for printing the sorted array is defined from **line 28 to line 33**.
* The function calls the recursive function `SortArray` which takes three arguments, i.e., `array`, `0` (i.e., starting index), and `size` of the array.
* After the function call, the sorted array is returned which is printed using a for loop.


## Recursive Function
In the function, we define the base case and the recursive case.

### Base Case
The base case is defined on **line 23**.
* When one element is left to be sorted, the function terminates.


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

* The function takes in three arguments. The first argument is the `array`. The second argument is the `startIndex` which is the starting index of the array and gets updated in every recursive call. The third argument is the `size` of the array.

* Initially, the value of `startIndex` is 0.
* From **line 10 to line 15**, the index of the minimum value of the array is found and stored in the variable `min`.
*  The value of the array at `min` is swapped with the value of the array at the `startIndex`.
* After swapping, the value of `startIndex` is incremented by one and the function is called again.
* The recursive call continues until the base condition is met.
  

# Understanding Through a Stack
The following illustration explains the stack behavior to sort an array:


This lesson will give a detailed solution review of the problem in the previous lesson.

Recursion Fundamentals

Recursion with Numbers

Recursion With Strings

Recursion With Arrays

Recursion with Data Structures

Solution Review 2: Sort an Array