• Erledigen Sie die Anwendungssicherheit auf die richtige Weise! Erkennen, schützen, überwachen, beschleunigen und mehr…
  • Die Implementierung der Suche ist immer schwierig, aber nicht unmöglich.

    Im wirklichen Leben werden wir in keinem Muster suchen. Wir gehen einfach zu den Orten, an denen wir denken, dass es platziert werden könnte. In den meisten Fällen folgen wir keinem Muster.

    Funktioniert das auch in der Programmierwelt?

    Nein! Es muss ein Muster geben, um Dinge in Programmen zu suchen. In diesem Artikel werden einige Algorithmen vorgestellt, die unterschiedlichen Suchmustern folgen.

    Es gibt mehrere Algorithmen, die wir in der Programmierwelt finden können. In diesem Artikel werden die wichtigsten und am häufigsten verwendeten Algorithmen erläutert. Der Rest der Algorithmen ist für Sie ein Kinderspiel.

    Suchen bezieht sich auf Suchen eines Elements im Array In diesem Artikel.

    Lassen Sie uns sie eins nach dem anderen sehen.

    Lineare Suche

    Der Name deutet darauf hin, dass die linearer Suchalgorithmus folgt dem linear Anleitungen um die Elemente in einem Array zu durchsuchen. Der Algorithmus beginnt am Anfang des Arrays mit der Suche nach dem Element und bewegt sich bis zum Ende, bis das Element gefunden wird. Es stoppt die Ausführung des Programms, wenn es das gewünschte Element findet.

    Lassen Sie uns das veranschaulichen lineare Suchalgorithmen mit einigen coolen Illustrationen zum besseren Verständnis des Algorithmus.

    Wenn Sie das Suchmuster sorgfältig beobachten, werden Sie feststellen, dass die Zeit für die Ausführung des Programms benötigt wird O (n) in schlimmsten Fall. Wir müssen die Worst-Case-Zeitkomplexität der zu analysierenden Algorithmen berücksichtigen. Daher ist die zeitliche Komplexität des Algorithmus O (n).

    Sehen wir uns die Implementierung des linearen Suchalgorithmus an.

    Implementierung der linearen Suche

    Jetzt haben Sie ein gutes Verständnis des linearen Suchalgorithmus. Es ist Zeit, unsere Hände mit etwas Code schmutzig zu machen. Sehen wir uns zuerst die Schritte zum Implementieren der linearen Suche an. Dann versuchst du es codiere es. Mach dir keine Sorgen, auch wenn du nicht kannst; Ich werde Ihnen den Code anschließend zur Verfügung stellen.

    Sehen wir uns die Schritte zur Implementierung des linearen Suchalgorithmus an.

    • Initialisieren Sie eine Reihe von Elementen (Ihre Glückszahlen).
    • Schreiben Sie eine Funktion namens suchelement, Hiermit werden drei Argumente akzeptiert: Array, Länge des Arrays und zu durchsuchendes Element.
    • Suchelement (arr, n, Element):
      • Iterieren Sie über das angegebene Array.
        • Überprüfen Sie, ob das aktuelle Element dem gewünschten Element entspricht.
        • Wenn ja, dann kehre zurück Wahr.
      • Befindet sich die Ausführung nach Abschluss der Schleife noch in der Funktion, ist das Element nicht im Array vorhanden. Also kehre zurück falsch.
    • Drucken Sie die Nachricht basierend auf dem Rückgabewert der Funktion Suchelement.

    Schreiben Sie abschließend den Code mit Hilfe der obigen Schritte, um den linearen Suchalgorithmus zu implementieren.

    Haben Sie die Implementierung des linearen Suchalgorithmus abgeschlossen? Hoffentlich. Wenn Sie fertig sind, überprüfen Sie dies mit dem folgenden Code.

    Wenn Sie es nicht abgeschlossen haben, machen Sie sich keine Sorgen; Sehen Sie sich den folgenden Code an und erfahren Sie, wie wir ihn implementiert haben. Sie werden es ohne viel Aufwand bekommen.

    ## searching function
    def search_element(arr, n, element):
    
    	## iterating through the array
    	for i in range(n):
    
    		## checking the current element with required element
    		if arr[i] == element:
    			## returning True on match
    			return True
    
    	## element is not found hence the execution comes here
    	return False
    
    
    if __name__ == '__main__':
    	## initializing the array, length, and element to be searched
    	arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    	n = 10
    	element_to_be_searched = 6
    	# element_to_be_searched = 11
    
    	if search_element(arr, n, element_to_be_searched):
    		print(element_to_be_searched, "is found")
    	else:
    		print(element_to_be_searched, "is not found")
    

    Führen Sie zuerst das Programm mit einem Element aus, das im Array vorhanden ist. Führen Sie es anschließend mit einem Element aus, das im Array nicht vorhanden ist.

    Die zeitliche Komplexität des linearen Suchalgorithmus beträgt O (n).

    Können wir es mit verschiedenen Mustern etwas weiter reduzieren?

    Ja, wir können. Mal sehen.

    Binäre Suche

    Das binärer Suchalgorithmus Überprüft immer das mittlere Element des Arrays. Dieser Algorithmus durchsucht das Element in a sortiertes Array.

    Das  binärer Suchalgorithmus iteriert über das Array und überprüft das mittlere Element, falls gefunden, stoppt dann das Programm. Andernfalls, wenn das mittlere Element kleiner als das erforderliche Element ist, wird der linke Teil des Arrays aus dem mittleren Element bei der Suche weggelassen. Andernfalls, wenn das mittlere Element größer als das erforderliche Element ist, wird der rechte Teil des Arrays aus dem mittleren Element bei der Suche weggelassen.

    In jeder Iteration reduziert der binäre Suchalgorithmus den Bereich zum Durchsuchen des Elements. Die Anzahl der Überprüfungen ist also geringer als die Anzahl der Überprüfungen, die im linearen Suchalgorithmus durchgeführt werden.

    Abbildungen helfen uns, die binärer Suchalgorithmus. Lassen Sie uns sie überprüfen.

    Die zeitliche Komplexität des binären Suchalgorithmus beträgt O (log n). In jeder Iteration wird die Länge des Suchbereichs um die Hälfte reduziert. Es nimmt exponentiell ab.

    Implementierung der binären Suche

    Zuerst sehen wir die Schritte zum Implementieren des binären Suchalgorithmus und dann des Codes. Sehen wir uns die Schritte an, um die Implementierung des binären Suchalgorithmus abzuschließen.

    • Initialisieren Sie das Array mit Elementen (Ihre Glückszahlen)
    • Schreiben Sie eine Funktion namens suchelement, Hiermit werden drei Argumente akzeptiert: sortiertes Array, Länge des Arrays und zu durchsuchendes Element.
    • Suchelement (sortiert_arr, n, Element):
      • Initialisieren Sie die Indexvariable für Array-Iteration.
      • Initialisieren Sie als Nächstes zwei Variablen, um den Suchbereich des Arrays beizubehalten. Hier nennen wir sie wie Anfang und Ende wie sie Indizes anzeigen.
      • Iterieren Sie bis zum i ist kleiner als die Länge des Arrays.
        • Berechnen Sie den mittleren Index des Suchbereichs mit Anfang und Ende Werte. Das wird sein (Start + Ende) // 2.
        • Überprüfen Sie, ob das mittlere indizierte Element aus dem Suchbereich dem erforderlichen Element entspricht oder nicht.
        • Wenn ja, dann kehre zurück Wahr.
        • Andernfalls verschieben Sie das Element, wenn das mittlere indizierte Element kleiner als das erforderliche Element ist Anfang Index des Suchbereichs zu Mitte + 1.
        • Andernfalls verschieben Sie das Element, wenn das mittlere indizierte Element größer als das erforderliche Element ist Ende Index des Suchbereichs zu Mitte - 1.
        • Erhöhen Sie den Index des Arrays i.
      • Befindet sich die Ausführung nach Abschluss der Schleife noch in der Funktion, ist das Element nicht im Array vorhanden. Also kehre zurück falsch.
    • Drucken Sie die Nachricht basierend auf dem Rückgabewert der Funktion Suchelement.

    Versuchen Sie, den Code ähnlich der Implementierung des linearen Suchalgorithmus zu schreiben.

    ...

    Hast du den Code bekommen?

    Ja, vergleichen Sie es mit dem folgenden Code. Nein, mach dir keine Sorgen; Verstehen Sie die Implementierung mit dem folgenden Code.

    ## searching function
    def search_element(sorted_arr, n, element):
    
    	## array index for iteration
    	i = 0
    
    	## variables to track the search area
    	## initializing them with start and end indexes
    	start = 0
    	end = n - 1
    
    	## iterating over the array
    	while i < n:
    		## getting the index of the middle element
    		middle = (start + end) // 2
    
    		## checking the middle element with required element
    		if sorted_arr[middle] == element:
    			## returning True since the element is in the array
    			return True
    		elif sorted_arr[middle] < element:
    			## moving the start index of the search area to right
    			start = middle + 1
    		else:
    			## moving the end index of the search area to left
    			end = middle - 1
    		i += 1
    	return False
    
    
    if __name__ == '__main__':
    	## initializing the array, length, and element to be searched
    	arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    	n = 10
    	element_to_be_searched = 9
    	# element_to_be_searched = 11
    
    	if search_element(arr, n, element_to_be_searched):
    		print(element_to_be_searched, "is found")
    	else:
    		print(element_to_be_searched, "is not found")
    

    Testen Sie den Code in verschiedenen Fällen, in denen das Element vorhanden und in einigen Fällen nicht vorhanden ist.

    Fazit

    Das  binärer Suchalgorithmus ist viel effizienter als die linearer Suchalgorithmus. Wir müssen das Array für den binären Suchalgorithmus sortieren, was beim linearen Suchalgorithmus nicht der Fall ist. Das Sortieren dauert einige Zeit. Die Verwendung effizienter Algorithmen zum Sortieren bildet jedoch eine gute Kombination mit dem binären Suchalgorithmus.

    Jetzt haben Sie gute Kenntnisse über die am häufigsten verwendeten Algorithmen in Python.

    Als nächstes finden Sie einige der beliebtesten selbst gehostete Suchsoftware.

    Viel Spaß beim Programmieren 🙂 🧑‍💻