AntInLoop

Linear Search Algorithm Code Implementations

Complete Linear Search Algorithm code implementations in C++, Python, Java, and JavaScript with time and space complexity analysis on AntInLoop.

Read Linear Search Algorithm Guide ยท Launch Interactive Visualizer

C++ Implementation

// Linear Search Implementation in C++
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

class LinearSearch {
public:
    static int linearSearch(const std::vector<int>& arr, int target) {
        // Iterate through each element in the vector
        for (size_t i = 0; i < arr.size(); i++) {
            if (arr[i] == target) {
                return static_cast<int>(i); // Return index if element is found
            }
        }
        return -1; // Return -1 if element is not found
    }
    
    // Linear Search with early exit for sorted arrays
    static int linearSearchSorted(const std::vector<int>& arr, int target) {
        for (size_t i = 0; i < arr.size(); i++) {
            if (arr[i] == target) {
                return static_cast<int>(i);
            }
            // Early exit if we've passed where the element should be
            if (arr[i] > target) {
                return -1;
            }
        }
        return -1;
    }
    
    // Linear Search with multiple occurrences
    static std::vector<int> linearSearchAll(const std::vector<int>& arr, int target) {
        std::vector<int> indices;
        for (size_t i = 0; i < arr.size(); i++) {
            if (arr[i] == target) {
                indices.push_back(static_cast<int>(i));
            }
        }
        return indices;
    }
    
    // Linear Search with custom comparator
    template<typename T>
    static int linearSearchCustom(const std::vector<T>& arr, const T& target, 
                                std::function<bool(const T&, const T&)> comparator) {
        for (size_t i = 0; i < arr.size(); i++) {
            if (comparator(arr[i], target)) {
                return static_cast<int>(i);
            }
        }
        return -1;
    }
    
    // Linear Search using std::find
    static int linearSearchSTL(const std::vector<int>& arr, int target) {
        auto it = std::find(arr.begin(), arr.end(), target);
        if (it != arr.end()) {
            return static_cast<int>(std::distance(arr.begin(), it));
        }
        return -1;
    }
    
    // Linear Search for strings
    static int linearSearchString(const std::vector<std::string>& arr, const std::string& target) {
        for (size_t i = 0; i < arr.size(); i++) {
            if (arr[i] == target) {
                return static_cast<int>(i);
            }
        }
        return -1;
    }
};

JAVA Implementation

// Linear Search Implementation in Java
public class LinearSearch {
    public static int linearSearch(int[] arr, int target) {
        // Iterate through each element in the array
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i; // Return index if element is found
            }
        }
        return -1; // Return -1 if element is not found
    }
    
    // Linear Search with early exit for sorted arrays
    public static int linearSearchSorted(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
            // Early exit if we've passed where the element should be
            if (arr[i] > target) {
                return -1;
            }
        }
        return -1;
    }
    
    // Linear Search with multiple occurrences
    public static int[] linearSearchAll(int[] arr, int target) {
        java.util.List<Integer> indices = new java.util.ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                indices.add(i);
            }
        }
        return indices.stream().mapToInt(Integer::intValue).toArray();
    }
    
    // Linear Search with custom comparator
    public static <T> int linearSearchCustom(T[] arr, T target, java.util.function.BiPredicate<T, T> comparator) {
        for (int i = 0; i < arr.length; i++) {
            if (comparator.test(arr[i], target)) {
                return i;
            }
        }
        return -1;
    }
    
    // Linear Search for strings
    public static int linearSearchString(String[] arr, String target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals(target)) {
                return i;
            }
        }
        return -1;
    }
}

JAVASCRIPT Implementation

// Linear Search Implementation in JavaScript
function linearSearch(arr, target) {
  // Iterate through each element in the array
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i; // Return index if element is found
    }
  }
  return -1; // Return -1 if element is not found
}

// Linear Search with early exit for sorted arrays
function linearSearchSorted(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i;
    }
    // Early exit if we've passed where the element should be
    if (arr[i] > target) {
      return -1;
    }
  }
  return -1;
}

// Linear Search with multiple occurrences
function linearSearchAll(arr, target) {
  const indices = [];
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      indices.push(i);
    }
  }
  return indices;
}

// Linear Search with custom comparator
function linearSearchCustom(arr, target, comparator) {
  for (let i = 0; i < arr.length; i++) {
    if (comparator(arr[i], target)) {
      return i;
    }
  }
  return -1;
}

PYTHON Implementation

# Linear Search Implementation in Python
def linear_search(arr, target):
    # Iterate through each element in the list
    for i in range(len(arr)):
        if arr[i] == target:
            return i  # Return index if element is found
    return -1  # Return -1 if element is not found

# Linear Search with early exit for sorted arrays
def linear_search_sorted(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
        # Early exit if we've passed where the element should be
        if arr[i] > target:
            return -1
    return -1

# Linear Search with multiple occurrences
def linear_search_all(arr, target):
    indices = []
    for i in range(len(arr)):
        if arr[i] == target:
            indices.append(i)
    return indices

# Linear Search with custom comparator
def linear_search_custom(arr, target, comparator):
    for i in range(len(arr)):
        if comparator(arr[i], target):
            return i
    return -1

# Linear Search using enumerate
def linear_search_enumerate(arr, target):
    for index, element in enumerate(arr):
        if element == target:
            return index
    return -1