Visualizers

Linear Search Visualizer

Step-through animation of Linear Search showing sequential scanning.

native (Canvas API) Client-side

Target Value

Input Mode

Array Size (5-20)

Speed

Ready to visualize

Execution Log

Comparisons: 0

Current Action:

Idle

Legend:

Unvisited

Active Check (No Match)

Match Found

Linear Search Algorithm

Linear Search (or Sequential Search) is a method for finding an element within a list. It sequentially checks each element of the list until a match is found or the whole list has been searched.

How It Works

Start from the leftmost element of the array and compare the target value with each element.
If the target value matches an element, return the index of the element.
If the target value does not match any of the elements, continue to the next index.
If the search reaches the end of the array without a match, return -1 (not found).

Implementation

function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i; // index found
    }
  }
  return -1; // not found
}

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i  # index found
    return -1  # not found

public class LinearSearch {
    public static int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i; // index found
            }
        }
        return -1; // not found
    }
}

#include <vector>

int linearSearch(const std::vector<int>& arr, int target) {
    for (size_t i = 0; i < arr.size(); i++) {
        if (arr[i] == target) {
            return i; // index found
        }
    }
    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.