# Linear Search

• Difficulty Level : Basic
• Last Updated : 02 Aug, 2022

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

Approach:

Iterate from 0 to N-1 and compare the value of every index with key if they match return index, if the loop terminates then return -1.

Follow the below steps to Implement the above approach:

• 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 ` `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 code` `int` `main(``void``)` `{` `    ``int` `arr[] = { 2, 3, 4, 10, 40 };` `    ``int` `x = 10;` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `  `  `    ``// 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[]. If x` `// is present then return its location, otherwise` `// return -1`   `#include `   `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 code` `int` `main(``void``)` `{` `    ``int` `arr[] = { 2, 3, 4, 10, 40 };` `    ``int` `x = 10;` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `  `  `    ``// 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[]. 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 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` `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 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

 ``

## Javascript

 ``

Output

`Element is present at index 3`

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

Linear search is rarely used practically because other search algorithms such as the binary search algorithm and hash tables allow significantly faster searching compared to Linear search.

Improve Linear Search Worst-Case Complexity:

1. If element Found at last O(N) to O(1).
2. It is the same as the previous method because here we are performing two steps ‘if’ operations in one iteration of the loop and in the last method we performed only 1 ‘if’ operation. This makes both the time complexities the same.

Below is the implementation of the above approach:

## C++14

 `// C++ program for linear search` `#include` `using` `namespace` `std;`   `void` `search(vector<``int``> arr, ``int` `search_Element)` `{` `    ``int` `left = 0;` `    ``int` `length = arr.size();` `    ``int` `position = -1;` `      ``int` `right = length - 1;` `      `  `    ``// Run loop from 0 to right` `    ``for``(left = 0; left <= right;) ` `    ``{` `        `  `        ``// If search_element is found with` `        ``// left variable` `        ``if` `(arr[left] == search_Element) ` `        ``{` `            `  `            ``position = left;` `            ``cout << ``"Element found in Array at "` `                 ``<< position + 1 << ``" Position with "` `                 ``<< left + 1 << ``" Attempt"``;` `               `  `            ``break``;` `        ``}` `      `  `        ``// If search_element is found with` `        ``// right variable` `        ``if` `(arr[right] == search_Element) ` `        ``{` `            ``position = right;` `            ``cout << ``"Element found in Array at "` `                 ``<< position + 1 << ``" Position with "` `                 ``<< length - right << ``" Attempt"``;` `               `  `            ``break``;` `        ``}` `        ``left++;` `        ``right--;` `    ``}`   `    ``// If element not found` `    ``if` `(position == -1)` `        ``cout << ``"Not found in Array with "` `             ``<< left << ``" Attempt"``;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> arr{ 1, 2, 3, 4, 5 };` `    ``int` `search_element = 5;` `    `  `    ``// Function call` `    ``search(arr, search_element);` `}` `    `  `// This code is contributed by mayanktyagi1709`

## Java

 `// Java program for linear search`   `import` `java.io.*;`   `class` `GFG ` `{`   `    ``public` `static` `void` `search(``int` `arr[], ``int` `search_Element)` `    ``{` `        ``int` `left = ``0``;` `        ``int` `length = arr.length;` `        ``int` `right = length - ``1``;` `        ``int` `position = -``1``;`   `        ``// run loop from 0 to right` `        ``for` `(left = ``0``; left <= right;) ` `        ``{` `            `  `            ``// if search_element is found with left variable` `            ``if` `(arr[left] == search_Element) ` `            ``{` `                ``position = left;` `                ``System.out.println(` `                    ``"Element found in Array at "` `                    ``+ (position + ``1``) + ``" Position with "` `                    ``+ (left + ``1``) + ``" Attempt"``);` `                ``break``;` `            ``}` `          `  `            ``// if search_element is found with right variable` `            ``if` `(arr[right] == search_Element) ` `            ``{` `                ``position = right;` `                ``System.out.println(` `                    ``"Element found in Array at "` `                    ``+ (position + ``1``) + ``" Position with "` `                    ``+ (length - right) + ``" Attempt"``);` `                ``break``;` `            ``}` `            `  `            ``left++;` `            ``right--;` `        ``}`   `        ``// if element not found` `        ``if` `(position == -``1``)` `            ``System.out.println(``"Not found in Array with "` `                               ``+ left + ``" Attempt"``);` `    ``}` `  `  `   `  `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5` `};` `        ``int` `search_element = ``5``;` `      `  `        ``// Function call` `        ``search(arr,search_element);` `    ``}` `}`

## Python3

 `# Python3 program for linear search` `def` `search(arr, search_Element):` `    ``left ``=` `0` `    ``length ``=` `len``(arr)` `    ``position ``=` `-``1` `    ``right ``=` `length ``-` `1`   `    ``# Run loop from 0 to right` `    ``for` `left ``in` `range``(``0``, right, ``1``):`   `        ``# If search_element is found with` `        ``# left variable` `        ``if` `(arr[left] ``=``=` `search_Element):` `            ``position ``=` `left` `            ``print``(``"Element found in Array at "``, position ``+` `                  ``1``, ``" Position with "``, left ``+` `1``, ``" Attempt"``)` `            ``break`   `        ``# If search_element is found with` `        ``# right variable` `        ``if` `(arr[right] ``=``=` `search_Element):` `            ``position ``=` `right` `            ``print``(``"Element found in Array at "``, position ``+` `1``,` `                  ``" Position with "``, length ``-` `right, ``" Attempt"``)` `            ``break` `        ``left ``+``=` `1` `        ``right ``-``=` `1`   `    ``# If element not found` `    ``if` `(position ``=``=` `-``1``):` `        ``print``(``"Not found in Array with "``, left, ``" Attempt"``)`   `# Driver code` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `search_element ``=` `5`   `# Function call` `search(arr, search_element)`   `# This code is contributed by Dharanendra L V.`

## C#

 `// C# program for linear search` `using` `System;` `class` `GFG ` `{`   `    ``public` `static` `void` `search(``int` `[]arr, ` `                              ``int` `search_Element)` `    ``{` `        ``int` `left = 0;` `        ``int` `length = arr.Length;` `        ``int` `right = length - 1;` `        ``int` `position = -1;`   `        ``// run loop from 0 to right` `        ``for` `(left = 0; left <= right;) ` `        ``{` `            `  `            ``// if search_element is found with left variable` `            ``if` `(arr[left] == search_Element) ` `            ``{` `                ``position = left;` `                ``Console.WriteLine(` `                    ``"Element found in Array at "` `                    ``+ (position + 1) + ``" Position with "` `                    ``+ (left + 1) + ``" Attempt"``);` `                ``break``;` `            ``}` `          `  `            ``// if search_element is found with right variable` `            ``if` `(arr[right] == search_Element) ` `            ``{` `                ``position = right;` `                ``Console.WriteLine(` `                    ``"Element found in Array at "` `                    ``+ (position + 1) + ``" Position with "` `                    ``+ (length - right) + ``" Attempt"``);` `                ``break``;` `            ``}` `            `  `            ``left++;` `            ``right--;` `        ``}`   `        ``// if element not found` `        ``if` `(position == -1)` `            ``Console.WriteLine(``"Not found in Array with "` `                               ``+ left + ``" Attempt"``);` `    ``}` `  `  `   `  `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int` `[]arr = { 1, 2, 3, 4, 5 };` `        ``int` `search_element = 5;` `      `  `        ``// Function call` `        ``search(arr,search_element);` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`Element found in Array at 5 Position with 1 Attempt`

Time Complexity: O(n)
Auxiliary Space: O(1)

Another method: Recursive Approach For Linear Search

Approach:

• If the size of the array is zero then, return -1 representation 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 equals 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

 `// Recursive Code For Linear Search` `#include ` `using` `namespace` `std;` `int` `linearsearch(``int` `arr[], ``int` `size, ``int` `key)` `{` `    ``if` `(size == 0) {` `        ``return` `-1;` `    ``}` `    ``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 Code` `int` `main()` `{` `    ``int` `arr = { 5, 15, 6, 9, 4 };` `    ``int` `key = 4;` `    ``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`

## 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`   `    ``# Otherwise if the array consists of only one element and that element is not the one` `    ``# we are searching for then it will also return  -1`   `    ``elif` `size ``=``=` `1` `and` `arr[``0``] !``=` `key:` `        ``return` `-``1`   `    ``# ELse , if the element at the size index is same as the element we are searching for` `    ``# Then return the size. This will return the index position is 0 index manner.` `    ``# i.e if the element is present at 6th position it will return 5.` `    ``# To get the exact position in human readble format (counting starts from 1 not 0)` `    ``# Then just return size + 1`   `    ``elif` `arr[size] ``=``=` `key:` `        ``return` `size`   `    ``# If none of the conditions are True then in else condition we will call the` `    ``# function recursively by decreasing the size by 1 each time.`   `    ``else``:` `        ``return` `linear_search(arr, key, size``-``1``)`     `arr ``=` `[``5``, ``15``, ``6``, ``9``, ``4``]` `key ``=` `4` `size ``=` `len``(arr)``-``1`   `# Calling the Function` `print``(``"The element "``, key, ``" is found at index: "``,` `      ``linear_search(arr, key, size), ``" of given array"``)`     `# Code Contributed By - DwaipayanBandyopadhyay`

## Javascript

 `// JavaScript Recursive Code For Linear Search`   `let linearsearch = (arr, size, key) => {` `  ``if` `(size == 0) {` `    ``return` `-1;` `  ``}` `  ``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...`

Output

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

Time Complexity: O(n)
Auxiliary Space: O(1)

Also See – Binary Search