Binary Search

Binary Search - Problem

Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums.

If target exists, then return its index. Otherwise, return -1.

You must write an algorithm with O(log n) runtime complexity.

Input & Output

Example 1 — Target Found

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

› Output: 4

💡 Note: 9 exists in nums and its index is 4

Example 2 — Target Not Found

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

› Output: -1

💡 Note: 2 does not exist in nums so return -1

Example 3 — Single Element

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

› Output: 0

💡 Note: Target found at index 0 in single-element array

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is to leverage the sorted array property by using binary search to eliminate half the search space with each comparison. Best approach is binary search with Time: O(log n), Space: O(1).

Common Approaches

✓ Binary Search

⏱️ Time: O(log n) Space: O(1)

Use two pointers (left and right) to maintain search boundaries. Compare middle element with target and eliminate half the array in each iteration.

Linear Search

⏱️ Time: O(n) Space: O(1)

Iterate through the array from left to right, comparing each element with the target. Return the index when found, or -1 if not found.

Binary Search — Algorithm Steps

Set left = 0, right = length - 1
Calculate mid = (left + right) / 2
Compare nums[mid] with target
Adjust boundaries based on comparison
Repeat until found or boundaries cross

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set left=0, right=4, find middle

Compare

Compare middle with target

Narrow

Adjust boundaries and repeat

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* nums, int numsSize, int target) {
    int left = 0, 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() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%d\n", solution(nums, numsSize, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each comparison eliminates half the remaining elements

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers

✓ Linear Space

312.7K Views

Very High Frequency

~15 min Avg. Time

8.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler