Search in Rotated Sorted Array

Find target index in a rotated sorted array in O(log N) time.

Find First and Last Position of Element

Find starting and ending position of a given target value in a sorted array.

Koko Eating Bananas (Binary Search on Answer)

Find minimum integer eating speed K such that Koko can eat all bananas within H hours.

Median of Two Sorted Arrays

Find the median of two sorted arrays of size M and N in O(log(min(M, N))) time.

Searching & Sorting AlgorithmsBeginner LevelStudy Time: 15 mins

Binary Search Algorithm

Binary Search is an efficient Divide and Conquer search algorithm over sorted arrays that repeatedly cuts the search interval in half, achieving O(log N) lookup speed.

Binary Search Visualizer

Sorted Array loaded. Enter search value to start binary pointers.

12[0]

22[1]

34[2]

45[3]

56[4]

67[5]

78[6]

89[7]

Speed:

Binary Search Halving Trace

Sample Input:Sorted Array: [2, 5, 8, 12, 16, 23, 38, 56, 72, 91], Target: 23

Step 1

Step 1 - Initial Midpoint Calculation

low = 0, high = 9 -> mid = Math.floor((0 + 9) / 2) = 4. Compare arr[4] (16) with target 23.

arr[mid] = 16 < 23 -> Target must be in right half [5..9]. Set low = mid + 1 = 5.

Eliminates left 5 elements instantly in one check.

Step 2

Step 2 - Second Midpoint Calculation

low = 5, high = 9 -> mid = Math.floor((5 + 9) / 2) = 7. Compare arr[7] (56) with target 23.

arr[mid] = 56 > 23 -> Target must be in left sub-half [5..6]. Set high = mid - 1 = 6.

Search range narrowed down to 2 elements.

Step 3

Step 3 - Final Target Match

low = 5, high = 6 -> mid = Math.floor((5 + 6) / 2) = 5. Compare arr[5] (23) with target 23.

arr[mid] = 23 == 23 -> Target found at Index 5!

Target located in just 3 comparison steps out of 10 elements.

Real-world analogy: Dictionary Page Halving

Precondition

Midpoint

Hover over items for details

Opening a dictionary to the middle page. If your word comes alphabetically before the middle word, you eliminate the entire right half.

Precondition= Dataset MUST be sorted.
Midpoint= mid = low + (high - low) / 2.

Complexity analysis

Scenario Simulator: Dataset Size (N = 500)

Presets:

N = 10N = 10,000

Complexity Curve MapBinary Search: O(log N) Logarithmic Time

Hover curves to inspect classes

Time Steps (N=500)

~9 steps (Logarithmic)

O(log N) Logarithmic Time

Space Footprint

O(1) Constant Space

Memory growth rate as N expands.

Performance Rank

Optimal Tier

Relative efficiency rating for large N.

Operation	Time Complexity	Space Complexity
Best Case	O(1)	O(1)
Average Case	O(log N)	O(1)
Worst Case	O(log N)	O(1)

Code implementations

function binarySearch(arr, target) {
  let low = 0, high = arr.length - 1;
  while (low <= high) {
    const mid = Math.floor(low + (high - low) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] < target) low = mid + 1;
    else high = mid - 1;
  }
  return -1;
}