Linear search in Java

Linear Search in Java is one of the simplest searching algorithms which helps to search for an element in the list in sequential order. But, linear search is rarely used as the other algorithms such as binary search algorithms, hash tables allow for faster search compared to linear search. Sequential search is performed for each item, i.e. every item is checked, and if there is a match found, then that item is returned; else, the search continues until the end of data collection. There are methods in Java to implement linear search operations. Let us dig deeper into this Linear Search and how it is implemented in Java in a stepwise manner with few examples.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Syntax

As there will be no Syntax available for Search Algorithms, there will be an Algorithm that will help us to implement Linear Search Algorithm in any Programming language.

Algorithm:

Step 1: First, we need to get the length of the array

Step 2: Get the element that has to be searched and store it in a variable

Step 3: Now, compare each element of the array with the searchable value

Step 4: If in case, there is a match. Then, the searchable element is found

Step 5: If not, i.e. if there is no match found. Then, the searchable element is not found and returns -1 if given

How to perform Linear Search Algorithm?

We will follow the above algorithmic steps to implement Linear Search Algorithm manually with an example and then get into programmatic examples.

Example:

Let Array A[4, 8, 2, 3, 6, 9]

Let searchable element X=3;

This is the array to be searched for X=3;

We need the length of the array when Linear Search is done Programmatically.

Starting from the first element

So Here X=3 = 4

Comparing with other elements

So here X=3 = 8

We, Will, move forward to the next element,

So here X=3 = 2

Will move forward,

So here X=3 = 3

Will return the index of the element and return. The index of the element is 3

If there was no element found until the end of the array, then it will return -1, i.e. not found.

Example #1

Linear Search Algorithm

class LinearSearchAlgorithm {
static int LSA(int array[], int length, int x)
{
for (int i = 0; i < length; i++) {
if (array[i] == x)
return i;
}
return -1;
}
public static void main(String[] args)
{
int[] array = { 4, 8, 2, 3, 6, 9 };
int length = array.length;
int x = 3;
int index = LSA(array, length, x);
if (index == -1)
System.out.println("Element not found in the array");
else
System.out.println("Element is found at index " + index);
}
}

Output:

Example #2

import java.util.Scanner;
class LSA
{
public static void main(String args[])
{
int length, k, i, array[];
Scanner input = new Scanner(System.in);
System.out.println("Enter length of the array:");
length = input.nextInt();
array = new int[length];
System.out.println("Enter " + length + " elements");
for (i = 0; i < length; i++)
{
array[i] = input.nextInt();
}
System.out.println("Enter the value to be searched:");
k = input.nextInt();
for (i = 0; i < length; i++)
{
if (array[i]== k)
{
System.out.println(k+" is found at index "+(i));
break;
}
}
if (i == length)
System.out.println(k + " is not found in the array");
}
}

Output 1:

Below are the inputs are given in the STDIN command prompt,

No. of array elements: 6

Array elements: 2, 4, 6, 8, 10, 1

Searchable value: 4

Output 2:

No. of array elements: 8

Array elements: 3, 5, 7, 9, 10, 34, 25, 21

Searchable value: 10

Output 3: If element not found

No. of elements: 5

Array elements: 2, 4, 5, 6, 10

Searchable value: 9

Time Complexity of Linear Search Algorithm

As the linear search algorithm is rarely used, other search algorithms such as hash tables and binary search allow fast search. The time complexity of Linear search is as follows:

If element is found in the array: O(n) to O(1)

If element is not found in the array: O(n) to O(n/2)

With this, we shall conclude our topic ‘Linear Search in Java’. We have seen what Linear Search Algorithm is and its implementation steps with an example. Also solved examples programmatically and showed various outputs, i.e. when the element is available and when the element is not available. Also seen the time complexity of the Linear Search Algorithm based on the searchable value if found or not. Thanks! Happy Learning!!

The above is the detailed content of Linear search in Java. For more information, please follow other related articles on the PHP Chinese website!