Lineare Suche in Java

Die lineare Suche in Java ist einer der einfachsten Suchalgorithmen, der dabei hilft, in sequentieller Reihenfolge nach einem Element in der Liste zu suchen. Die lineare Suche wird jedoch selten verwendet, da andere Algorithmen wie binäre Suchalgorithmen und Hash-Tabellen eine schnellere Suche im Vergleich zur linearen Suche ermöglichen. Für jedes Element wird eine sequentielle Suche durchgeführt, d. h. jedes Element wird überprüft, und wenn eine Übereinstimmung gefunden wird, wird dieses Element zurückgegeben; Andernfalls wird die Suche bis zum Ende der Datenerfassung fortgesetzt. In Java gibt es Methoden zur Implementierung linearer Suchoperationen. Lassen Sie uns anhand einiger Beispiele tiefer in diese lineare Suche eintauchen und wie sie schrittweise in Java implementiert wird.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax

Da für Suchalgorithmen keine Syntax verfügbar sein wird, wird es einen Algorithmus geben, der uns hilft, den linearen Suchalgorithmus in jeder Programmiersprache zu implementieren.

Algorithmus:

Schritt 1: Zuerst müssen wir die Länge des Arrays ermitteln

Schritt 2: Holen Sie sich das zu durchsuchende Element und speichern Sie es in einer Variablen

Schritt 3: Vergleichen Sie nun jedes Element des Arrays mit dem durchsuchbaren Wert

Schritt 4: Falls ja, gibt es eine Übereinstimmung. Dann wird das durchsuchbare Element gefunden

Schritt 5: Wenn nicht, d. h. wenn keine Übereinstimmung gefunden wird. Dann wird das durchsuchbare Element nicht gefunden und gibt -1 zurück, falls angegeben

Wie führt man einen linearen Suchalgorithmus durch?

Wir werden die oben genannten algorithmischen Schritte befolgen, um den linearen Suchalgorithmus anhand eines Beispiels manuell zu implementieren, und dann auf programmatische Beispiele eingehen.

Beispiel:

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

Das durchsuchbare Element sei X=3;

Dies ist das Array, das nach X=3;

Wir benötigen die Länge des Arrays, wenn die lineare Suche programmgesteuert durchgeführt wird.

Beginnend mit dem ersten Element

Hier ist also X=3 = 4

Vergleich mit anderen Elementen

Also hier X=3 = 8

Wir, Will, gehen zum nächsten Element über

Hier ist also X=3 = 2

Wird weitermachen,

Hier ist also X=3 = 3

Gibt den Index des Elements zurück und gibt zurück. Der Index des Elements ist 3

Wenn bis zum Ende des Arrays kein Element gefunden wurde, wird -1 zurückgegeben, d. h. nicht gefunden.

Beispiel #1

Linearer Suchalgorithmus

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);
}
}

Ausgabe:

Beispiel #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");
}
}

Ausgabe 1:

Unten sind die Eingaben aufgeführt, die in der STDIN-Eingabeaufforderung erfolgen:

Nein. Anzahl der Array-Elemente: 6

Array-Elemente: 2, 4, 6, 8, 10, 1

Suchbarer Wert: 4

Ausgabe 2:

Nein. Anzahl der Array-Elemente: 8

Array-Elemente: 3, 5, 7, 9, 10, 34, 25, 21

Suchbarer Wert: 10

Ausgabe 3: Wenn Element nicht gefunden

Nein. Anzahl der Elemente: 5

Array-Elemente: 2, 4, 5, 6, 10

Suchbarer Wert: 9

Zeitkomplexität des linearen Suchalgorithmus

Da der lineare Suchalgorithmus selten verwendet wird, ermöglichen andere Suchalgorithmen wie Hash-Tabellen und die binäre Suche eine schnelle Suche. Die zeitliche Komplexität der linearen Suche ist wie folgt:

Wenn ein Element im Array gefunden wird: O(n) bis O(1)

Wenn das Element nicht im Array gefunden wird: O(n) bis O(n/2)

Damit schließen wir unser Thema „Lineare Suche in Java“ ab. Wir haben anhand eines Beispiels gesehen, was der lineare Suchalgorithmus ist und welche Implementierungsschritte er durchführt. Außerdem wurden Beispiele programmgesteuert gelöst und verschiedene Ausgaben angezeigt, z. B. wann das Element verfügbar ist und wann das Element nicht verfügbar ist. Auch die zeitliche Komplexität des linearen Suchalgorithmus basiert auf dem durchsuchbaren Wert, ob gefunden oder nicht. Danke! Viel Spaß beim Lernen!!

Das obige ist der detaillierte Inhalt vonLineare Suche in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!