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

# What do we mean by merging alphabetically?

When given two strings that are in alphabetic order, we can combine them to create a string that is both sorted alphabetically and the combination of those two strings. 

To better understand, look see the illustration below:


# Implementing the Code

The code below shows how to merge alphabetically using recursion. First, let’s examine the code, and then we can go on to its explanation.

Try the code by changing the values of `one` and `two` to see how it works with other strings.

class ExampleClass {

    private static String alphabeticMerge(String one, String two) {
        if (one == null || one.equals("")) {
          return two==null? one:two;
        }
        else if (two == null || two.equals("")) {
            return one;
        }
        else if (two.charAt(0) > one.charAt(0)) {
            return one.charAt(0) + alphabeticMerge(one.substring(1, one.length()), two);
        }
        else {
            return two.charAt(0) + alphabeticMerge(one, two.substring(1, two.length()));
        }
    }

    public static void main( String args[] ) {
        String one = "adz";
        String two = "bfx";
        String answer = alphabeticMerge(one, two);
        System.out.println(answer); 
    }

}

# Understanding the Code

The recursive code can be broken down into two parts: the recursive method and the main where the method is called.

## Driver Method

The recursive method is called within the driver method so lets first look at what it does-from **line 19 to 22**. 

* Two string variables are declared:- `one` and `two`. Both have a value that is alphabetically **sorted**. 

* The main method then equates the method call `alphabeticMerge` to another string variable called `answer`. 

* The `answer` variable is displayed to show the sorted merge of both the sorted strings.

## Recursive Method

Now let’s examine the recursive method: `alphabeticMerge`. This is the code segment from **line 4 to 15** in the snippet above.

### Base Case

* The **first** `if` condition-from **line 4 to line 6** basically checks if the string `one` is null or an empty string. If the condition is true, it then checks if `two` is also null. If both strings are null, it returns `one`. However, if `one` is null but `two` is not null, then it returns the non-empty string, `two`. 

* The `else if condition` from **line 7 to line 9** condition checks if the string `two` is null or an empty string. If the condition is true then it returns the string `one`.


### Recursive Case

* The method takes in **two arguments** that are both of type *string*. The method also **returns** a string instead of simply modifying the input argument. Now, we create a new string and embed the additional characters into it with each **recursive call**. 

* The second `else if` condition from **line 10 to line 12** states that, provided both arguments are not empty, if the first character of `two` is greater than of `one`, it will return the **first element** of `one` and append it to the return value of the recursive method, `alphabeticMerge`. This recursive call takes `one` as it is but only takes the part of `two` that is not already appended in the **return call.**

* Lastly, if both the strings `one` and `two` are not empty, and the condition stated above is also not met, then the method makes the same return call but switches the roles of `one` and `two`. 


This lesson will teach you how to merge two already sorted strings using recursion so that the resulting string is also sorted.

Fundamentals of Recursion

Iteration to Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Merging Strings in Alphabetic Order

What do we mean by merging alphabetically?

Implementing the Code

Understanding the Code