So führen Sie eine sequentielle Suche in Java durch

Sequentielle Suche ist definiert als eine Technik, bei der die Elemente vom Anfang bis zum Ende mit dem gewünschten Element verglichen werden. Die sequentielle Suche endet, wenn das gewünschte Element mit den in der Liste verfügbaren Elementen übereinstimmt.

In diesem Artikel werden wir Folgendes im Detail besprechen:

  • Algorithmus der sequentiellen Suche.
  • Bildbeispiel.
  • Code-Implementierung.

Wie führe ich eine sequentielle Suche in Java durch/aus?

Um eine auszuführen sequentielle Suche in Java, wird das gewünschte Element mit jedem Element in der Liste linear verglichen. Diese Suche beginnt beim ersten Element in der Liste, bis die Übereinstimmung gefunden wird, bis die Liste endet. Wenn das gewünschte Element gefunden wird, werden die Ergebnisse entsprechend gedruckt, andernfalls wird die Ausgabe angezeigt Es gibt kein passendes Element in der Liste“. Daher wird diese Suche auch als bezeichnet Lineare Suche.

Werfen wir einen Blick auf den Algorithmus der sequentiellen Suche.

Algorithmus

Der folgende Algorithmus hilft dabei, die sequentielle Suche genauer zu verstehen:

1- Initialisieren Sie das Array als x=0

2- Wenn x>0 (Kein Element gefunden drucken).

3- Wenn Array[x]= gewünschtes Element (Druckelement gefunden, Schritt Nummer 7)

4- Stellen Sie nun den Wert von x auf x=x+1 ein.

5- Gehen Sie zurück zu Schritt 2.

6- Drucken Sie nun das gewünschte Element aus, das sich am spezifischen Index der Liste befindet, und fahren Sie mit Schritt 8 fort.

7- Geben Sie „Das Element wurde nicht gefunden“ aus.

8- Stopp.

Bildbeispiel

Betrachten wir das folgende Beispiel, um das Konzept der sequentiellen Suche in Java vollständig zu verstehen.

Das Array wird unten deklariert:

Betrachten wir nun das Schlüsselwert ist 14. Um den Schlüsselwert zu finden, vergleichen wir den gewünschten Wert von Elementen in der Liste von Anfang bis Ende.

1- Vergleich des ersten Elements, das 12 ist.

Das gewünschte Element oder der Schlüsselwert stimmt nicht mit dem Element am Index 0 überein.

2- Jetzt bewegt sich der Iterator zum nächsten Element in der Liste, nämlich 13.

Das gewünschte Element oder der Schlüsselwert stimmt nicht mit dem Element an Index 1 überein.

3- Der Schlüsselwert wurde immer noch nicht gefunden. Jetzt wechselt der Iterator zum nächsten Wert in der Liste.

Der Schlüsselwert stimmt hier mit dem Element in der Liste am zweiten Index überein. Daher wird die Iteration hier beendet.

Der oben beschriebene Algorithmus und die bildliche Darstellung haben das Konzept der sequentiellen Suche in Java deutlich verständlich gemacht.

Kommen wir zum Code, der zum vollständigen Verständnis der sequentiellen Suche beiträgt.

Beispiel 1:

Im folgenden Beispiel wird eine sequentielle Suche durchgeführt, um die Indexnummer des übereinstimmenden Schlüssels auszugeben.

public class sequentialsearch{   
public static int searchlinear(int myarray[], int keyvalue){   
        for(int x=0;x<myarray.length;x++){  //If the element in the array has a key value return the element   
            if(myarray[x] == keyvalue){   
                return x;   
            }   
        }    //If the value is not in the array return -1
        return -1;   
    }   
    public static void main(String s1[]){ //Declare values in the array  
        int[] s= {12,13,14,17,19,20,30};   
        int keyvalue = 14;    //Search for the key value in the array
        int result = searchlinear(s, keyvalue);//If the key value is not in the array
        if (result == -1)
            System.out.print(keyvalue+ " is not present in array");
        else
        System.out.println(keyvalue+" is present at index number: "+searchlinear(s, keyvalue));   
    }
}

Im Code oben:

  • Es wird eine for-Schleife deklariert, gefolgt von einer if-Anweisung.
  • Wenn das Array den Schlüsselwert enthält, wird der Index zurückgegeben, der diesen Wert enthält.
  • Andernfalls bewegt sich der Iterator linear auf jedem Element, bis der gewünschte Schlüssel gefunden wird.
  • Die Ausgabe erscheint so, als sei das Element nicht im Array vorhanden, wenn der gewünschte Schlüssel nicht übereinstimmt.

Ausgabe

Die obige Ausgabe zeigt, dass der Schlüsselwert, der im obigen Code als 14 deklariert wurde, an Indexnummer 2 der Liste vorhanden ist.

Beispiel 2:

Der unten genannte Codeabschnitt stellt ein Szenario dar, in dem der Schlüssel nicht im Array verfügbar ist.

public class sequentialsearch{   
public static int searchlinear(int myarray[], int keyvalue){   
        for(int x=0;x<myarray.length;x++){  //If the element in the array has a key value return the element   
            if(myarray[x] == keyvalue){   
                return x;   
            }   
        }    //If the value is not in the array return -1
        return -1;   
    }   
    public static void main(String s1[]){ //Declare values in the array  
        int[] s= {12,13,14,17,19,20,30};//10 is not present i the array
        int keyvalue = 10;    //Search for the key value in the array
        int result = searchlinear(s, keyvalue);//If the key value is not in the array
        if (result == -1)
            System.out.print(keyvalue+ " is not present in array");
        else
        System.out.println(keyvalue+" is present at index number: "+searchlinear(s, keyvalue));   
    }
}

Ausgabe

Die obige Ausgabe zeigt, dass der gewünschte Wert, nämlich 10, nicht in der Liste verfügbar ist.

Beispiel 3:

Der unten genannte Codeabschnitt fordert den Benutzer zur Eingabe auf, um eine sequentielle Suche durchzuführen:

//Import util.Scanner for user inputimport java. util.Scanner;public class user input {
private static Scanner user;
public static void main(String[] args) {
int x, y;
user = new Scanner(System.in);//User enters the size of array.
System.out.print("Enter size of Array = ");
x = user.nextInt();
int[] array = new int[x];//User enters the number of elements in the array.
System.out.format("Enter number of elements you want in  Array = ",x);
for(y = 0; y < x; y++) {
array[y] = user.nextInt();
}//User enters the key value.
System.out.print("Enter keyvalue =  ");
int digit = user.nextInt();
for(y = 0; y < array.length; y++)
{
if(array[y] == digit)
{//Index is printed for the value.
System.out.println("Index of " + digit + " is " + y);
break;
}
}
if(y == array.length)
{//If the number entered is not present in the array.
System.out.println("The number is not present in the Array");
}
}
}

Der obige Code funktioniert auf die gleiche Weise wie der vorherige. Der Unterschied im obigen Code tritt dort auf, wo der Benutzer zur Eingabe aufgefordert wurde.

Ausgabe

Die Ausgabe zeigt, dass der Schlüsselwert am zweiten Ort vorhanden ist.

Nachteil

Der Hauptnachteil der Verwendung sequenzieller Suchvorgänge besteht darin, dass sie bei großen Arrays tendenziell hektisch sind.

Dies fasst den Prozess der Durchführung sequenzieller Suchvorgänge in Java zusammen.

Abschluss

Um eine auszuführen sequentielle Suche in Java, wird das gewünschte Element mit jedem Element in der Liste linear verglichen. Der Hauptvorteil der sequentiellen Suche besteht darin, dass die Suche auch dann erfolgt, wenn die Elemente im Array nicht sortiert sind. Dieser Artikel hat den Funktionsmechanismus der sequentiellen Suche in Java effektiv demonstriert. Daher hilft die sequentielle Suche dabei, den Schlüsselwert effizient zu finden.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen