Visualizers

Binary Search Visualizer

Step-through animation of Binary Search on a sorted array.

native (Canvas API) Client-side

Target Value

Input Mode

Array Size (5-20)

Speed

Ready to visualize

Execution Log

Comparisons: 0

Low Pointer (L): 0

Mid Pointer (M): -

High Pointer (H): -

Current Action:

Idle

Legend:

Out of Search Range

In Search Range

Boundary (L / H)

Midpoint check

Match Found

Binary Search Algorithm

Binary Search is a search algorithm that finds the position of a target value within a sorted array. It compares the target value to the middle element of the array; if they are not equal, the half in which the target cannot lie is eliminated, and the search continues on the remaining half.

How It Works

Start with the search range covering the entire sorted array: low = 0, high = N - 1.
Compute mid = floor((low + high) / 2).
If array[mid] matches target, return mid.
If array[mid] is less than target, search the right half: low = mid + 1.
If array[mid] is greater than target, search the left half: high = mid - 1.
Repeat until low > high (element not found).

Implementation

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

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid  # index found
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1  # not found

public class BinarySearch {
    public static int binarySearch(int[] arr, int target) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (arr[mid] == target) {
                return mid; // index found
            } else if (arr[mid] < target) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return -1; // not found
    }
}

#include <vector>

int binarySearch(const std::vector<int>& arr, int target) {
    int low = 0;
    int high = arr.size() - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] == target) {
            return mid; // index found
        } else if (arr[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return -1; // not found
}

Related Tools

Big-O Visualizer

Interactive growth-curve chart for common complexity classes.

Data Structure Visualizer

Animated operations on linked lists, trees, stacks and hash tables.

Algorithm Visualizer

Step-through animations for sorting and pathfinding algorithms.