Binary Search - Practice Coding Problems

Binary Search - Problem

Binary Search is a fundamental algorithm for efficiently finding a target value in a sorted array. Given an array of integers nums sorted in ascending order and an integer target, your task is to write a function that searches for the target in the array. If the target exists, return its index position. If it doesn't exist, return -1. The challenge is to achieve this with O(log n) runtime complexity, making it much faster than a simple linear search. This algorithm works by repeatedly dividing the search space in half, eliminating half of the remaining elements at each step.

Input & Output

example_1.py — Standard Case

$ Input: nums = [-1,0,3,5,9,12], target = 9

› Output: 4

💡 Note: The target 9 exists in the array at index 4, so we return 4.

example_2.py — Target Not Found

$ Input: nums = [-1,0,3,5,9,12], target = 2

› Output: -1

💡 Note: The target 2 does not exist in the array, so we return -1.

example_3.py — Single Element

$ Input: nums = [5], target = 5

› Output: 0

💡 Note: The array has only one element which matches the target, so we return index 0.

Visualization

Tap to expand

Understanding the Visualization

Set Boundaries

Initialize left=0, right=length-1 to define search space

Find Middle

Calculate mid = left + (right-left)/2 to avoid overflow

Compare and Eliminate

If target > middle, search right half; if target < middle, search left half

Repeat or Return

Continue until target found or search space exhausted

Key Takeaway

🎯 Key Insight: Binary search achieves O(log n) complexity by eliminating half the search space with each comparison, making it exponentially faster than linear search for large sorted arrays.

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We eliminate half of the search space at each step, leading to logarithmic time complexity

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra space for pointers

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁴ < nums[i], target < 10⁴
All integers in nums are unique
nums is sorted in ascending order

Asked in

G Google 127 a Amazon 89 ⊞ Microsoft 76 f Meta 52

The optimal solution uses Binary Search with O(log n) time complexity. By maintaining left and right pointers and comparing the target with the middle element, we can eliminate half of the search space at each step. This approach is significantly more efficient than linear search, especially for large datasets.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log n)	O(1)	Efficiently search by repeatedly dividing the search space in half
Linear Search (Brute Force)	O(n)	O(1)	Check every element one by one until we find the target

Binary Search (Optimal) — Algorithm Steps

Initialize left pointer to 0 and right pointer to length - 1
While left <= right, calculate middle index
If middle element equals target, return middle index
If target is less than middle element, search left half (right = mid - 1)
If target is greater than middle element, search right half (left = mid + 1)
If left > right, target not found, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize pointers

Set left=0, right=5, calculate mid=2

Compare with middle

nums[2]=3 < target=9, so search right half

Update search space

Set left=3, right=5, calculate mid=4

Found target

nums[4]=9 equals target, return index 4

Code -

solution.c — C

#include <stdio.h>

int search(int* nums, int numsSize, int target) {
    int left = 0;
    int right = numsSize - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return -1;
}

int main() {
    int nums[] = {-1, 0, 3, 5, 9, 12};
    int target = 9;
    printf("%d\n", search(nums, 6, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We eliminate half of the search space at each step, leading to logarithmic time complexity

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra space for pointers

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁴ < nums[i], target < 10⁴
All integers in nums are unique
nums is sorted in ascending order

98.4K Views

Very High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler