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