Binary Search LeetCode 704: The Template Every Variant Builds On

If there is one problem every programmer should solve before touching any other binary search variant, it is LeetCode 704. Binary search leetcode 704 is not just another easy problem — it is the template. Every rotation, every boundary twist, every "find the minimum" variation is just this core algorithm with one extra condition bolted on.

Think of #704 as the scales a musician practices before playing a concerto. The notes are simple, but the muscle memory you build here carries into Search Insert Position (#35), Find Minimum in Rotated Sorted Array (#153), and dozens of medium and hard problems.

In this walkthrough you will learn the exact left-right-mid template, understand why every line matters, and walk through a visual example step by step. By the end, the basic binary search pattern will be second nature.

The problem statement is refreshingly short. You are given a sorted array of integers nums and a target value. Return the index of the target if it exists, or -1 if it does not. The constraint: your solution must run in O(log n) time.

That O(log n) requirement is the key. A simple for-loop scan would work in O(n), but the problem explicitly forbids it. You need to cut the search space in half on every step — and that is exactly what binary search does.

Because the array is sorted, you can compare the middle element to your target and immediately discard half the remaining elements. This halving is what gives binary search its logarithmic time complexity. For an array of one million elements, you need at most 20 comparisons instead of one million.

Here is the binary search template in its purest form. Every binary search variant starts from these exact lines and adds one modification. Memorize this pattern and you have the foundation for every binary search problem on LeetCode.

Initialize two pointers: left = 0 and right = len(nums) - 1. These define the current search space — every element between left and right (inclusive) is still a candidate. Then enter the loop: while left <= right, compute mid = left + (right - left) // 2.

Now compare nums[mid] to the target. If they are equal, you found the answer — return mid. If the target is greater than nums[mid], the answer must be to the right, so set left = mid + 1. If the target is smaller, set right = mid - 1. When the loop ends without finding the target, return -1.

This single character — the equals sign in <= — is the most common source of binary search bugs. Understanding why it matters will save you from subtle off-by-one errors in every binary search problem you tackle.

The loop condition left <= right means the search space can narrow all the way down to a single element (where left == right) and still be checked. If you use left < right instead, the loop exits when left equals right, and that last remaining element is never examined.

Imagine searching for 9 in the array [-1, 0, 3, 5, 9, 12]. In the final iteration, both left and right point to index 4 (the element 9). With left <= right, you enter the loop, check nums[4], find the target, and return 4. With left < right, the loop skips this iteration entirely and incorrectly returns -1.

The rule is simple: when your search space is [left, right] inclusive and you shrink it with mid + 1 and mid - 1, always use left <= right. This is the standard binary search template and the correct choice for LeetCode 704.

Let us trace the binary search template step by step on the array [-1, 0, 3, 5, 9, 12] with a target of 9. This is the binary search left right mid pattern in action.

Step 1: left = 0, right = 5. mid = (0 + 5) // 2 = 2. nums[2] = 3. Since 9 > 3, set left = mid + 1 = 3. The search space shrinks to [3, 5, 9, 12].

Step 2: left = 3, right = 5. mid = (3 + 5) // 2 = 4. nums[4] = 9. Since 9 == 9, return 4. Done in just two iterations.

Now consider searching for 2 in the same array. Step 1: left = 0, right = 5, mid = 2, nums[2] = 3. Since 2 < 3, set right = mid - 1 = 1. Step 2: left = 0, right = 1, mid = 0, nums[0] = -1. Since 2 > -1, set left = 1. Step 3: left = 1, right = 1, mid = 1, nums[1] = 0. Since 2 > 0, set left = 2. Now left > right, so the loop exits and we return -1.

The template handles the happy path, but interviews love edge cases. Here are the scenarios you should test mentally before submitting any binary search solution.

Empty array: If nums has length 0, left starts at 0 and right starts at -1. The condition left <= right is false immediately, so the loop never executes and you return -1. No special case needed — the template handles it.

Single element: If nums has one element, left and right both equal 0. You compute mid = 0 and check nums[0]. If it matches, return 0. If not, you adjust left or right so the loop exits next iteration. Again, the template covers this naturally because of the <= condition.

Target at boundaries: When the target is the first or last element, binary search still converges. It may take log(n) steps to reach the boundary, but the narrowing logic always gets there. Test with target = nums[0] and target = nums[n-1] to build confidence.

LeetCode 704 is not just a problem — it is a foundation. The binary search template you learned here is the exact skeleton used in Search Insert Position (#35), where you return the insertion index instead of -1. It is the same skeleton in Find Peak Element (#162), where the comparison changes from target vs. mid to mid vs. mid+1.

Every binary search variant modifies exactly one piece of this template: the comparison logic, the return value, or the search space boundaries. Once the basic pattern is in your muscle memory, learning each variant becomes a matter of identifying which piece changes.

Practice this template until you can write it without thinking. Then move on to the variants — rotated arrays, peak finding, search ranges — and notice how each one is just #704 with a twist. YeetCode flashcards can help you drill the pattern with spaced repetition so it sticks for interview day.