Linear Search Algorithm
Linear search:-
Linear search is the simplest method for searching.
In Linear search technique of searching; the element to be found in searching the elements to
be found is searched sequentially in the list.
This method can be performed on a sorted or an unsorted list (usually arrays).
In case of a sorted list searching starts from 0th element and continues until the element is
found from the list or the element whose value is greater than (assuming the list is sorted in
ascending order), the value being searched is reached.
As against this, searching in case of unsorted list also begins from the 0th element and
continues until the element or the end of the list is reached.
The linear search algorithm searches all elements in the array sequentially.
Its best execution time is 1, whereas the worst execution time is n, where n is the total
number of items in the search array.
It is the most simple search algorithm in data structure and checks each item in the set of
elements until it matches the search element until the end of data collection.
When data is unsorted, a linear search algorithm is preferred.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
Step 1: First, read the search element (Target element) in the array.
Step 2: In the second step compare the search element with the first element in the array.
Step 3: If both are matched, display “Target element is found” and terminate the Linear Search
function.
Step 4: If both are not matched, compare the search element with the next element in the array.
Step 5: In this step, repeat steps 3 and 4 until the search (Target) element is compared with the
last element of the array.
Step 6 – If the last element in the list does not match, the Linear Search Function will be
terminated, and the message “Element is not found” will be displayed.
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 6Input: 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:
- Set the first element of the array as the current element.
- If the current element is the target element, return its index.
- If the current element is not the target element and if there are more elements in the array, set the current element to the next element and repeat step 2.
- If the current element is not the target element and there are no more elements in the array, return -1 to indicate that the element was not found.
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> |
Element is present at index 3
Time complexity: O(N)
Auxiliary Space: O(1)
Using STL:
The Approach:
Here we have a vector and we use find build function of vector library i.e vector iterator.
C++
#include <bits/stdc++.h> //Including the bits/stdc++ library for using vector and find functions #include <iostream> using namespace std; int main() { vector< int > v{ 5, 15, 6, 9, 4 }; // Declaring a vector v with initial values int key = 4; // Variable to store the element to be searched vector< int >::iterator it; // Declaring an iterator to // iterate through the vector it = find(v.begin(), v.end(), key); // find function to search for the // element in the vector if (it != v.end()) { // Checking if the element is // present in the vector cout << key << " is Present in the vector" << endl; // Printing if the element is present // in the vector } else { cout << key << " is Not-Present in the vector" << endl; // Printing if the element is not // present in the vector } return 0; } |
4 is Present in the vector
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 ?> |
C
#include <stdio.h> // Define a function to perform the linear search int linearSearch( int arr[], int size, int key) { // If the size of the array is zero, return -1 if (size == 0) { return -1; } // Check if the element at the current index is equal to the key if (arr[size - 1] == key) { // If equal, return the index return size - 1; } else { // If not equal, call the function again with the size reduced by 1 return linearSearch(arr, size - 1, key); } } int main() { // Driver's code int arr[] = {5, 15, 6, 9, 4}; int key = 4; int index = linearSearch(arr, sizeof (arr) / sizeof ( int ), key); if (index == -1) { printf ( "Key not found in the array.\n" ); } else { printf ( "The element %d is found at %d index of the given array \n" ,key,index); } return 0; } |
The element 4 is found at 4 index of the given array.
Linear Search Complexity
Linear search Complexity as given below:
Space Complexity
Space complexity for linear search is O (n) as it does not use any extra space where
n is the number of elements in an array.
Time Complexity
Best- case complexity = O (1) occurs when the search element is present at the first
element in the search array.
Worst- case complexity = O (n) occurs when the search element is not present in the
set of elements or array.
Average complexity = O (n) is referred to when the element is present somewhere
in the search array
Time Complexity: O(N)
Auxiliary Space: O(N), for using recursive stack space.
Advantages of Linear Search:
- Linear search is simple to implement and easy to understand.
- 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.
Drawbacks of Linear Search:
- Linear search has a time complexity of O(n), which in turn makes it slow for large datasets.
- Not suitable for large array.
- Linear search can be less efficient than other algorithms, such as hash tables.
When to use Linear Search:
- When we are dealing with a small dataset.
- When you need to find an exact value.
- When you are searching a dataset stored in contiguous memory.
- When you want to implement a simple algorithm.
Summary:
- Linear search is a simple and flexible algorithm for finding whether an element is present within an array.
- It sequentially examines each element of the array.
- The time complexity of linear search is O(n).
- It is used for searching databases, lists, and arrays.
Please Login to comment...