Linear Search Algorithm

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

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.