In my problem-solving journey as an aspiring problem solver and software developer, I came across the Binary Search algorithm — just like many other developers.

Initially, whenever I read a problem statement that mentioned searching in a sorted array, the word that immediately caught my attention was sorted. As a beginner, I interpreted this in a very narrow way: I thought sorted simply meant an array arranged in increasing or decreasing order.

With this understanding, I was happily applying binary search to such arrays and solving problems successfully. At that point, binary search felt like just another algorithm used for searching efficiently in sorted arrays.

But this perception started to change when I encountered more advanced variants of binary search problems.

Those problems forced me to rethink everything I believed about binary search.

Rethinking the Meaning of “Sorted”

The first important realization I had was this:

Sorted does not necessarily mean increasing or decreasing.

Instead, sorted means that the search space follows a consistent pattern — a pattern that remains valid throughout the search space and does not break arbitrarily.

This was a major shift in my understanding.

Binary search does not depend on increasing or decreasing order specifically. It depends on the existence of a pattern that allows us to make a decision about which part of the search space can be safely eliminated.

Revisiting the classical Binary Search Problem

What Binary Search Is Really Doing

Let’s revisit the classic example of binary search on an increasing array.

We find the middle element and compare it with the target.

If the middle element equals the target, we are done.

If the middle element is smaller than the target, we know something very important:

Every element to the left of mid is also smaller than the target, because the array follows a consistent increasing pattern.

This means the target cannot exist in the left half.

So we eliminate the entire left half of the search space.

Similarly, if the middle element is greater than the target, we eliminate the right half.

This made me realize something profound:

Binary search is not about searching. It is about eliminating.

We are not finding the target directly. We are repeatedly eliminating regions where the target cannot exist.

The Real Insight Came from a Different Problem

My understanding became much deeper when I encountered this problem:

Given a sorted array where every element appears exactly twice except one element which appears only once, find that single element.

At first glance, this problem does not look like a typical binary search problem.

The array is sorted, but simply knowing increasing order does not immediately tell us which direction to move.

So how do we eliminate search space here?

The answer lies in observing a pattern.

In this array, every pair follows a specific index pattern:

• The first occurrence appears at an even index

• The second occurrence appears at an odd index

This pattern continues until the single element appears.

Once the single element appears, this pattern gets disrupted.

This disruption is the key.

If at mid we observe that the pattern is still intact, it means the single element must be on the right side (or in more layman terms the single element has not appeared yet in the left and that’s why the pattern is still intact).

If the pattern is broken at mid, it means the single element must be on the left side (i.e somewhere in the left the single element has appered which has distorted the index pattern).

Again, we are not searching directly.

We are identifying which part of the search space can be safely eliminated.

The Most Important Realization

This is when binary search truly clicked for me.

Binary search does not require increasing or decreasing order.

Binary search requires only one thing:

A pattern that allows us to eliminate half of the search space with certainty.

If such a pattern exists, binary search can be applied.

The pattern could be:

• Increasing order

• Decreasing order

• Index parity pattern

• Monotonic function behavior

• Any consistent structure that allows elimination

Binary search is fundamentally an algorithm of elimination.

Searching is just a consequence.😉