Skip to content
Related Articles

Related Articles

Linear Search Algorithm

Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 23 Sep, 2022
Improve Article
Save Article

Linear Search is defined as a sequential search algorithm that starts at one end and goes through each element of a list until the desired element is found, otherwise the search continues till the end of the data set. It is the easiest searching algorithm

Linear Search Algorithm

Given an array arr[] of N elements, the task is to write a function to search a given element x in arr[].

Examples:

Input: arr[] = {10, 20, 80, 30, 60, 50,110, 100, 130, 170}, x = 110;
Output: 6
Explanation: Element x is present at index 6

Input: arr[] = {10, 20, 80, 30, 60, 50,110, 100, 130, 170}, x = 175;
Output: -1
Explanation: Element x is not present in arr[].

Follow the below idea to solve the problem:

Iterate from 0 to N-1 and compare the value of every index with x if they match return index

 Follow the given steps to solve the problem:

  • Start from the leftmost element of arr[] and one by one compare x with each element of arr[]
  • If x matches with an element, return the index.
  • If x doesn’t match with any of the elements, return -1.

Below is the implementation of the above approach:

C




// C code to linearly search x in arr[]. If x
// is present then return its location, otherwise
// return -1
 
#include <stdio.h>
 
int search(int arr[], int N, int x)
{
    int i;
    for (i = 0; i < N; i++)
        if (arr[i] == x)
            return i;
    return -1;
}
 
// Driver's code
int main(void)
{
    int arr[] = { 2, 3, 4, 10, 40 };
    int x = 10;
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call
    int result = search(arr, N, x);
    (result == -1)
        ? printf("Element is not present in array")
        : printf("Element is present at index %d", result);
    return 0;
}


C++




// C++ code to linearly search x in arr[]. If x
// is present then return its location, otherwise
// return -1
 
#include <iostream>
using namespace std;
 
int search(int arr[], int N, int x)
{
    int i;
    for (i = 0; i < N; i++)
        if (arr[i] == x)
            return i;
    return -1;
}
 
// Driver's code
int main(void)
{
    int arr[] = { 2, 3, 4, 10, 40 };
    int x = 10;
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call
    int result = search(arr, N, x);
    (result == -1)
        ? cout << "Element is not present in array"
        : cout << "Element is present at index " << result;
    return 0;
}


Java




// Java code for linearly searching x in arr[]. If x
// is present then return its location, otherwise
// return -1
 
class GFG {
    public static int search(int arr[], int x)
    {
        int N = arr.length;
        for (int i = 0; i < N; i++) {
            if (arr[i] == x)
                return i;
        }
        return -1;
    }
 
    // Driver's code
    public static void main(String args[])
    {
        int arr[] = { 2, 3, 4, 10, 40 };
        int x = 10;
 
        // Function call
        int result = search(arr, x);
        if (result == -1)
            System.out.print(
                "Element is not present in array");
        else
            System.out.print("Element is present at index "
                             + result);
    }
}


Python3




# Python3 code to linearly search x in arr[].
# If x is present then return its location,
# otherwise return -1
 
 
def search(arr, N, x):
 
    for i in range(0, N):
        if (arr[i] == x):
            return i
    return -1
 
 
# Driver Code
if __name__ == "__main__":
    arr = [2, 3, 4, 10, 40]
    x = 10
    N = len(arr)
 
    # Function call
    result = search(arr, N, x)
    if(result == -1):
        print("Element is not present in array")
    else:
        print("Element is present at index", result)


C#




// C# code to linearly search x in arr[]. If x
// is present then return its location, otherwise
// return -1
using System;
 
class GFG {
    public static int search(int[] arr, int x)
    {
        int N = arr.Length;
        for (int i = 0; i < N; i++) {
            if (arr[i] == x)
                return i;
        }
        return -1;
    }
 
    // Driver's code
    public static void Main()
    {
        int[] arr = { 2, 3, 4, 10, 40 };
        int x = 10;
 
        // Function call
        int result = search(arr, x);
        if (result == -1)
            Console.WriteLine(
                "Element is not present in array");
        else
            Console.WriteLine("Element is present at index "
                              + result);
    }
}
 
// This code is contributed by DrRoot_


PHP




<?php
// PHP code for linearly search x in arr[].
// If x is present then return its location,
// otherwise return -1
 
function search($arr, $x)
{
    $n = sizeof($arr);
    for($i = 0; $i < $n; $i++)
    {
        if($arr[$i] == $x)
            return $i;
    }
    return -1;
}
 
// Driver Code
$arr = array(2, 3, 4, 10, 40);
$x = 10;
 
// Function call
$result = search($arr, $x);
if($result == -1)
    echo "Element is not present in array";
else
    echo "Element is present at index " ,
                                 $result;
 
// This code is contributed
// by jit_t
?>


Javascript




<script>
 
// Javascript code to linearly search x in arr[]. If x
// is present then return its location, otherwise
// return -1
 
function search(arr, n, x)
{
    let i;
    for (i = 0; i < n; i++)
        if (arr[i] == x)
            return i;
    return -1;
}
 
// Driver code
 
    let arr = [ 2, 3, 4, 10, 40 ];
    let x = 10;
    let n = arr.length;
 
    // Function call
    let result = search(arr, n, x);
    (result == -1)
        ? document.write("Element is not present in array")
        : document.write("Element is present at index " + result);
 
// This code is contributed by Manoj
 
</script>


Output

Element is present at index 3

Time complexity: O(N)
Auxiliary Space: O(1)

Linear Search Recursive Approach:

 Follow the given steps to solve the problem:

  • If the size of the array is zero then, return -1, representing that the element is not found. This can also be treated as the base condition of a recursion call.
  • Otherwise, check if the element at the current index in the array is equal to the key or not i.e, arr[size – 1] == key
    • If equal, then return the index of the found key.

Below is the implementation of the above approach:

C++14




// C++ Recursive Code For Linear Search
#include <iostream>
using namespace std;
 
int linearsearch(int arr[], int size, int key)
{
    if (size == 0) {
        return -1;
    }
    else if (arr[size - 1] == key) {
        // Return the index of found key.
        return size - 1;
    }
    else {
        int ans = linearsearch(arr, size - 1, key);
        return ans;
    }
}
 
// Driver's Code
int main()
{
    int arr[5] = {5, 15, 6, 9, 4 };
    int key = 4;
   
      // Function call
    int ans = linearsearch(arr, 5, key);
    if (ans == -1) {
        cout << "The element " << key << " is not found."
             << endl;
    }
    else {
        cout << "The element " << key << " is found at "
             << ans << " index of the given array." << endl;
    }
    return 0;
}
// Code contributed by pragatikohli


Java




// Java Recursive Code For Linear Search
import java.io.*;
 
class Test {
    static int arr[] = { 5, 15, 6, 9, 4 };
 
    // Recursive Method to search key in the array
    static int linearsearch(int arr[], int size, int key)
    {
        if (size == 0) {
            return -1;
        }
        else if (arr[size - 1] == key) {
            // Return the index of found key.
            return size - 1;
        }
        else {
            return linearsearch(arr, size - 1, key);
        }
    }
 
    // Driver method
    public static void main(String[] args)
    {
        int key = 4;
 
        // Function call to find key
        int index = linearsearch(arr, arr.length, key);
        if (index != -1)
            System.out.println(
                "The element " + key + " is found at "
                + index + " index of the given array.");
 
        else
            System.out.println("The element " + key
                               + " is not found.");
    }
}
 
// This Code is submitted by Susobhan Akhuli


Python3




"""Python Program to Implement Linear Search Recursively"""
 
 
def linear_search(arr, key, size):
   
  # If the array is empty we will return -1
    if (size == 0):
        return -1
 
    elif (arr[size - 1] == key):
        # Return the index of found key.
        return size - 1
    else:
        return linear_search(arr, key, size - 1)
 
 
# Driver's code
if __name__ == "__main__":
    arr = [5, 15, 6, 9, 4]
    key = 4
    size = len(arr)
    ans = linear_search(arr, key, size)  # Calling the Function
    if ans != -1:
        print("The element", key, "is found at",
              ans, "index of the given array.")
    else:
        print("The element", key, "is not found.")
 
# Code Contributed By - DwaipayanBandyopadhyay
# Code is modified by Susobhan Akhuli


C#




// C# Recursive Code For Linear Search
using System;
 
static class Test {
    static int[] arr = { 5, 15, 6, 9, 4 };
 
    // Recursive Method to search key in the array
    static int linearsearch(int[] arr, int size, int key)
    {
        if (size == 0) {
            return -1;
        }
        else if (arr[size - 1] == key) {
            // Return the index of found key.
            return size - 1;
        }
        else {
            return linearsearch(arr, size - 1, key);
        }
    }
 
    // Driver method
    public static void Main(String[] args)
    {
        int key = 4;
 
        // Method call to find key
        int index = linearsearch(arr, arr.Length, key);
 
        if (index != -1)
            Console.Write("The element " + key
                          + " is found at " + index
                          + " index of the given array.");
        else
            Console.Write("The element " + key
                          + " is not found.");
    }
}
 
// This Code is submitted by Susobhan Akhuli


Javascript




// JavaScript Recursive Code For Linear Search
 
let linearsearch = (arr, size, key) => {
  if (size == 0) {
    return -1;
  }
  else if (arr[size - 1] == key)
  {
   
    // Return the index of found key.
    return size - 1;
  }
  else
  {
    let ans = linearsearch(arr, size - 1, key);
    return ans;
  }
};
 
// Driver Code
let main = () => {
  let arr = [5, 15, 6, 9, 4];
  let key = 4;
  let ans = linearsearch(arr, 5, key);
  if (ans == -1) {
    console.log(`The element ${key} is not found.`);
  } else {
    console.log(
      `The element ${key} is found at ${ans} index of the given array.`
    );
  }
  return 0;
};
 
main();
 
// This code is contributed by Aman Singla...


PHP




<?php
// PHP Recursive Code For Linear Search
 
// Recursive function to search key in the array
function linearsearch($arr, int $size, int $x)
{
    if ($size == 0)
        return -1;
    else if ($arr[$size - 1] == $x)
        return $size - 1; // return index
    return linearsearch($arr, $size - 1, $x);
}
 
// Driver Code
$arr = array(5, 15, 6, 9, 4);
$i;
$n = count($arr);
$key = 4;
$ans = linearsearch($arr, $n, $key);
if ($ans != -1)
    echo "The element ", $key, " is found at ", $ans,
        " index of the given array.";
else
    echo "The element ", $key, " is not found.";
// This code is submitted by Susobhan Akhuli
?>


Output

The element 4 is found at 4 index of the given array.

Time Complexity: O(N)
Auxiliary Space: O(N), for using recursive stack space. 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!