Open In App

Introduction to Linear Search Algorithm

Last Updated : 06 Jun, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

Linear Search Algorithm 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. In this article, we will learn about the basics of Linear Search Algorithm, Applications, Advantages, Disadvantages, etc. to provide a deep understanding of Linear Search.

Linear-Search-algorithm-banner-(1)

Linear Search is a method for searching an element in a collection of elements. In Linear Search, each element of the collection is visited one by one in a sequential fashion to find the desired element. Linear Search is also known as Sequential Search.

The algorithm for linear search can be broken down into the following steps:

  • Start: Begin at the first element of the collection of elements.
  • Compare: Compare the current element with the desired element.
  • Found: If the current element is equal to the desired element, return true or index to the current element.
  • Move: Otherwise, move to the next element in the collection.
  • Repeat: Repeat steps 2-4 until we have reached the end of collection.
  • Not found: If the end of the collection is reached without finding the desired element, return that the desired element is not in the array.

How Does Linear Search Algorithm Work?

In Linear Search Algorithm, 

  • Every element is considered as a potential match for the key and checked for the same.
  • If any element is found equal to the key, the search is successful and the index of that element is returned.
  • If no element is found equal to the key, the search yields “No match found”.

For example: Consider the array arr[] = {10, 50, 30, 70, 80, 20, 90, 40} and key = 30

Step 1: Start from the first element (index 0) and compare key with each element (arr[i]).

  • Comparing key with first element arr[0]. SInce not equal, the iterator moves to the next element as a potential match.
Compare key with arr[0]

Compare key with arr[0]

  • Comparing key with next element arr[1]. SInce not equal, the iterator moves to the next element as a potential match.
Compare key with arr[1]

Compare key with arr[1]

Step 2: Now when comparing arr[2] with key, the value matches. So the Linear Search Algorithm will yield a successful message and return the index of the element when key is found (here 2).

Compare key with arr[2]

Compare key with arr[2]

Implementation of Linear Search Algorithm:

In Linear Search, we iterate over all the elements of the array and check if it the current element is equal to the target element. If we find any element to be equal to the target element, then return the index of the current element. Otherwise, if no element is equal to the target element, then return -1 as the element is not found.

Below is the implementation of the linear search algorithm:

C++
// C++ code to linearly search x in arr[].

#include <bits/stdc++.h>
using namespace std;

int search(int arr[], int N, int x)
{
    for (int i = 0; i < N; i++)
        if (arr[i] == x)
            return i;
    return -1;
}

// Driver 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;
}
C
// C code to linearly search x in arr[].

#include <stdio.h>

int search(int arr[], int N, int x)
{
    for (int i = 0; i < N; i++)
        if (arr[i] == x)
            return i;
    return -1;
}

// Driver 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;
}
Java
// Java code for linearly searching x in arr[]. 

import java.io.*;

class GFG {
    public static int search(int arr[], int N, int x)
    {
        for (int i = 0; i < N; i++) {
            if (arr[i] == x)
                return i;
        }
        return -1;
    }

    // Driver code
    public static void main(String args[])
    {
        int arr[] = { 2, 3, 4, 10, 40 };
        int x = 10;

        // Function call
        int result = search(arr, arr.length, x);
        if (result == -1)
            System.out.print(
                "Element is not present in array");
        else
            System.out.print("Element is present at index "
                             + result);
    }
}
Python
# Python3 code to linearly search x in arr[].


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[].

using System;

class GFG {
    public static int search(int[] arr, int N, int x)
    {
        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, arr.Length, 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_
Javascript
// Javascript code to linearly search x in arr[].

function search(arr, n, x)
{
    for (let 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)
        ? console.log("Element is not present in array")
        : console.log("Element is present at index " + result);

// This code is contributed by Manoj
PHP
<?php
// PHP code for linearly search x in arr[].

function search($arr, $n, $x)
{
    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, sizeof($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
?>

Output
Element is present at index 3

Time Complexity:

  • Best Case: In the best case, the key might be present at the first index. So the best case complexity is O(1)
  • Worst Case: In the worst case, the key might be present at the last index i.e., opposite to the end from which the search has started in the list. So the worst-case complexity is O(N) where N is the size of the list.
  • Average Case: O(N)

Auxiliary Space: O(1) as except for the variable to iterate through the list, no other variable is used. 

  • Unsorted Lists: When we have an unsorted array or list, linear search is most commonly used to find any element in the collection.
  • Small Data Sets: Linear Search is preferred over binary search when we have small data sets with
  • Searching Linked Lists: In linked list implementations, linear search is commonly used to find elements within the list. Each node is checked sequentially until the desired element is found.
  • Simple Implementation: Linear Search is much easier to understand and implement as compared to Binary Search or Ternary Search.
  • Linear search can be used irrespective of whether the array is sorted or not. It can be used on arrays of any data type.
  • Does not require any additional memory.
  • It is a well-suited algorithm for small datasets.
  • Linear search has a time complexity of O(N), which in turn makes it slow for large datasets.
  • Not suitable for large arrays.
  • When we are dealing with a small dataset.
  • When you are searching for a dataset stored in contiguous memory.

1. What is linear search algorithm?

Linear search algorithm, also known as sequential search algorithm, is a simple searching algorithm that traverses a list or array sequentially to find a target element. In Linear Search, we can get the

2. How does linear search algorithm work?

Linear search algorithm iterates through each element in the list or array, comparing it with the target element until a match is found or the end of the list is reached. If the end of the list is reached, then it means that the target element is not present in the array.

3. What is the time complexity of linear search algorithm?

The time complexity of linear search algorithm is O(n), where n is the number of elements in the list or array being searched. This means the time taken for searching increases linearly with the size of the input.

4. When is linear search algorithm preferred over other searching algorithms?

Linear search algorithm is preferred when the list or array is unsorted, or when the size of the input is relatively small. It’s simple to implement and doesn’t require the data to be in any specific order.

5. What are the advantages of linear search algorithm?

Linear search algorithm is easy to implement, and it works efficiently on small-sized arrays or lists. It doesn’t require any pre-processing like sorting, making it suitable for dynamic data structures.

6. What are the disadvantages of linear search algorithm?

Linear search algorithm becomes inefficient for large-sized arrays or lists, as it needs to scan through each element sequentially. It has a time complexity of O(n), which means the search time grows linearly with the size of the input.

7. How do you implement linear search algorithm in programming languages like Python, Java, or C++?

Linear search algorithm can be implemented using loops to iterate through the elements of the array or list, comparing each element with the target value until a match is found or the end of the list is reached.

8. Can linear search algorithm be applied to other data structures?

Yes, linear search algorithm can be applied not only to arrays or lists but also to other linear data structures like linked lists. The principle remains the same: iterating through each element until the target is found or the end is reached.

9. Is linear search algorithm suitable for sorted arrays or lists?

While linear search algorithm can still be used on sorted arrays or lists, it’s not the most efficient option. Binary search, for example, is more suitable for sorted data as it has a time complexity of O(log n).

10. What are some real-world applications of linear search algorithm?

Linear search algorithm can be used in scenarios such as searching for a specific value in a phone book, searching for a name in an unsorted list of contacts, or finding an item in a grocery list. It’s often used in scenarios where the data size is small or not expected to grow significantly.

Related Articles:



Previous Article
Next Article

Similar Reads

Is Sentinel Linear Search better than normal Linear Search?
What is Sentinel Linear Search? Sentinel Linear search is a type of linear search where the element to be searched is placed in the last position and then all the indices are checked for the presence of the element without checking for the index out of bound case. The number of comparisons is reduced in this search as compared to a traditional line
9 min read
Linear Search vs Binary Search
Prerequisite: Linear SearchBinary SearchLINEAR SEARCH Assume that item is in an array in random order and we have to find an item. Then the only way to search for a target item is, to begin with, the first position and compare it to the target. If the item is at the same, we will return the position of the current item. Otherwise, we will move to t
11 min read
Which is faster between binary search and linear search?
In computer science, search algorithms are used to locate a specific element within a data structure. Two commonly used search algorithms are binary search and linear search. Understanding their relative speeds is crucial for optimizing search operations. Let's compare the speed of Binary Search and Linear Search to determine which one is faster. B
2 min read
Difference Between Linear Search and Jump Search
Linear Search and Jump Search are two different techniques used to find an element in a list. Each algorithm has its own set of characteristics, advantages, and limitations, making them suitable for different scenarios. This article explores the key differences between Linear Search and Jump Search. What is Linear Search?Linear Search, also known a
3 min read
Recursive 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. How Linear Search Works? Linear search works by comparing each element of the data structure with the key to be found. To learn the
6 min read
Time and Space Complexity of Linear Search Algorithm
The time complexity of the Linear Search algorithm is O(n), where n is the number of elements in the array. The space complexity is O(1) as it requires a constant amount of extra space regardless of the input size. AspectComplexityTime ComplexityO(n)Space ComplexityO(1)Let's explore the detailed time and space complexity of the Linear Search Algori
2 min read
Two Way Linear Search Algorithm
Two-Way Linear Search Algorithm is based on the principle of Linear Search, but the search is conducted from both ends towards the center of the array. In this article, we will learn about the basics of Two Way Linear Search Algorithm, its advantages, implementation etc. What is Two-Way Linear Search?Two Way Linear Search is a searching technique w
6 min read
Z algorithm (Linear time pattern searching Algorithm)
This algorithm finds all occurrences of a pattern in a text in linear time. Let length of text be n and of pattern be m, then total time taken is O(m + n) with linear space complexity. Now we can see that both time and space complexity is same as KMP algorithm but this algorithm is Simpler to understand.In this algorithm, we construct a Z array. Wh
13 min read
Difference between Linear and Non-linear Data Structures
Linear Data Structure: Data structure where data elements are arranged sequentially or linearly where each and every element is attached to its previous and next adjacent is called a linear data structure. In linear data structure, single level is involved. Therefore, we can traverse all the elements in single run only. Linear data structures are e
5 min read
Linear search using Multi-threading
Given a large file of integers, search for a particular element in it using multi-threading. Examples: Input : 1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220Output :if key = 20Key element foundInput :1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220Output :if key = 202Key not presentPrerequisite : Multi-threading Recommen
6 min read
Practice Tags :
three90RightbarBannerImg