The **binary search** is one of the first algorithms computer science students learn.

Below we're going to discuss how the binary search algorithm works and go into detail about how to implement the recursive binary search algorithm in **Java** — we'll provide an implementation for **Python** as well.

## What is Binary Search?

Suppose you had a sorted array of elements.

Now suppose you needed to be able to find a particular element within that array.

One way to do it would be to go through each element one at a time starting from the beginning (or the end), this method is called **linear search**.

Linear search has a time complexity of O(n), which means the time it will take is proportional to the value of n.

With **binary search** we select a value at the center of a sorted array, figure out if our value is greater or lower than our selected value, and then drop off whichever half our value isn't a part of.

## What is the Time Complexity of Binary Search?

Taking this approach we reduce the time complexity to O(Log n).

## Recursive Implementation of Binary Search in Java

### Declare a Class

We'll start by declaring a class and giving it a name of BinarySearch.

### Create the Method

Next we'll create our method (we'll name it binarySearchMethod) which takes four arguments:

- A sorted array
- 3 integer variables

leftTail represents the value at index 0 of our array. This should be the smallest value in the array.

rightTail should be the last value in the array (array.length - 1).

selectedValue is the value we're actually looking for.

### Body of the Method

Within our body we'll start with our outer conditional, which checks whether or not the rightTail is ≥ leftTail.

If it is, then we create a middle value (e.g., midValue) that will be equal to half the value of the leftTail plus the value of our rightTail – 1.

Okay, that may be a bit confusing so let's write it out:

Within our conditional we have more conditions though!

We'll check to see if our midValue is equal to our selectedValue and if it is, great, we can stop checking because we've found our answer (e.g., return midValue).

#### Time for Recursion

Otherwise, we'll check and see if our midValue is greater than our selectedValue.

If midValue is greater than selectedValue then we know that our value is somewhere between our leftTail and our midValue, right?

So we can now drop off all of the values greater than our midValue.

This is where our first bit of **recursion** occurs.

To do this we'll call our binarySearchMethod again and pass to it our sortedArray, our leftTail, our midValue – 1, and our selectedValue.

#### Déjà Vu

We wrap our up our outer conditional by recursively calling the binarySearchMethod again.

You see, if our midValue wasn't equal to our selectedValue nor greater than our selectedValue, then it must be less than our selectedValue.

In which case we drop all values to the left our of midValue and begin again.

So we'll call our binarySearchMethod and pass to it our sortedArray, our leftTail becomes midValue – 1, our rightTail, and finally our selectedValue.

#### Wrapping Up our binarySearchMethod

Now we wrap up our binarySearchMethod by terminating it. To do this we can return – 1.

If we don't…well, we'll get a **compilation error** due to a **missing return statement**.

## Let's Test Our Method

### Unit Testing

We can test our method in a variety of ways. We'll test it using unit tests.

We'll cover how to create unit tests in a later post, but for now, see below.

### Test Using System.out.println

You can also run some tests by calling the method and returning output to the print line. See below for the full implementation.

## Complete Recursive Binary Search Algorithm in Java

## Recursive Binary Search in Python

## Keep Learning

I hope this resource helped you understand the **Binary Search algorithm**. If you have any questions or suggestions, feel free to drop us an email. We would be glad to receive the input.

If you're feeling up to it, you can learn a bit more about the binary search algorithm by visiting the very well written Wikipedia page article on it.