{"id":842911,"date":"2023-09-10T22:11:53","date_gmt":"2023-09-11T03:11:53","guid":{"rendered":"https:\/\/blogging-techies.com\/ge\/implementierungen-von-suchalgorithmen-in-python\/"},"modified":"2023-09-10T22:11:53","modified_gmt":"2023-09-11T03:11:53","slug":"implementierungen-von-suchalgorithmen-in-python","status":"publish","type":"post","link":"https:\/\/blogging-techies.com\/ge\/implementierungen-von-suchalgorithmen-in-python\/","title":{"rendered":"Implementierungen von Suchalgorithmen in Python"},"content":{"rendered":"

Die Implementierung einer Suche ist immer eine Herausforderung, aber nicht unm\u00f6glich.<\/p>\n

Im wirklichen Leben werden wir ohne Muster suchen. Wir gehen einfach zu den Orten, an denen wir glauben, dass es platziert werden k\u00f6nnte. In den meisten F\u00e4llen folgen wir keinem Muster.<\/p>\n

Funktioniert das Gleiche auch in der Welt des Programmierens?<\/p>\n

NEIN! Es muss ein bestimmtes Muster f\u00fcr die Suche nach Dingen in Programmen geben. In diesem Artikel werden wir uns einige Algorithmen ansehen, die unterschiedlichen Suchmustern folgen.<\/p>\n

Es gibt mehrere Algorithmen, die wir in der Welt der Programmierung finden k\u00f6nnen. Wir werden in diesem Artikel die wichtigsten und am h\u00e4ufigsten verwendeten Algorithmen diskutieren. Und der Rest der Algorithmen wird f\u00fcr Sie ein Kinderspiel sein.<\/p>\n

Die Suche bezieht sich auf Suche nach einem Element im Array <\/strong>In diesem Artikel.<\/p>\n

Schauen wir sie uns einzeln an.<\/p>\n

Lineare Suche<\/h2>\n

Der Name l\u00e4sst vermuten, dass die linearer Suchalgorithmus <\/strong>Folge dem linear <\/strong>Muster<\/strong> um nach Elementen in einem Array zu suchen. Der Algorithmus beginnt mit der Suche nach dem Element am Anfang des Arrays und geht bis zum Ende, bis er das Element findet. Stoppt die Programmausf\u00fchrung, wenn das erforderliche Element gefunden wird.<\/p>\n

Lassen Sie uns das veranschaulichen lineare Suchalgorithmen <\/strong>mit einigen coolen Illustrationen zum besseren Verst\u00e4ndnis des Algorithmus.<\/p>\n

\"\" \"\" \"\" \"\" \"\" \"\"<\/p>\n

Wenn Sie sich das Suchmuster genau ansehen, werden Sie feststellen, dass die Ausf\u00fchrung des Programms einige Zeit in Anspruch nimmt In) <\/strong>drin der schlimmste Fall<\/strong>. Wir m\u00fcssen die zeitliche Komplexit\u00e4t der zu analysierenden Algorithmen im ung\u00fcnstigsten Fall ber\u00fccksichtigen. Daher betr\u00e4gt die zeitliche Komplexit\u00e4t des Algorithmus In)<\/strong>.<\/p>\n

Schauen wir uns die Implementierung des linearen Suchalgorithmus an.<\/p>\n

Implementierung der linearen Suche<\/h3>\n

Jetzt haben Sie ein gutes Verst\u00e4ndnis des linearen Suchalgorithmus. Es ist Zeit, sich mit etwas Code die H\u00e4nde schmutzig zu machen. Schauen wir uns zun\u00e4chst die Schritte zur Implementierung der linearen Suche an. Dann versuchen Sie es zu codieren. Machen Sie sich keine Sorgen, auch wenn Sie es nicht k\u00f6nnen. Ich werde Ihnen den Code sp\u00e4ter zur Verf\u00fcgung stellen.<\/p>\n

Schauen wir uns die Schritte zur Implementierung des linearen Suchalgorithmus an.<\/p>\n

    \n
  • Initialisieren Sie ein Array von Elementen (Ihre Gl\u00fcckszahlen).<\/li>\n
  • Schreiben Sie eine Funktion namens search_item, <\/strong>das drei Argumente akzeptiert: Array, Array-L\u00e4nge und zu suchendes Element.<\/li>\n
  • search_item(arr, n, item):<\/strong>\n
      \n
    • Iterieren Sie \u00fcber das angegebene Array.\n
        \n
      • \u00dcberpr\u00fcfen Sie, ob das aktuelle Element dem erforderlichen Element entspricht.<\/li>\n
      • Wenn ja, dann komm zur\u00fcck WAHR<\/strong>.<\/li>\n<\/ul>\n<\/li>\n
      • Wenn sich die Ausf\u00fchrung nach Abschluss der Schleife noch in der Funktion befindet, ist das Element nicht im Array vorhanden. Deshalb kehre ich zur\u00fcck Gef\u00e4lscht<\/strong>.<\/li>\n<\/ul>\n<\/li>\n
      • Drucken Sie die Nachricht basierend auf dem R\u00fcckgabewert der Funktion search_item<\/strong>.<\/li>\n<\/ul>\n

        Schreiben Sie abschlie\u00dfend den Code mithilfe der oben genannten Schritte, um den linearen Suchalgorithmus zu implementieren.<\/p>\n

        Haben Sie die Implementierung des linearen Suchalgorithmus abgeschlossen? Ich hoffe es. Wenn der Vorgang abgeschlossen ist, \u00fcberpr\u00fcfen Sie ihn mit dem folgenden Code.<\/p>\n

        Wenn Sie es nicht abgeschlossen haben, machen Sie sich keine Sorgen. Sehen Sie sich den Code unten an und erfahren Sie, wie wir ihn implementieren. Sie werden es ohne gro\u00dfen Aufwand erreichen.<\/p>\n

        ## searching function\ndef search_element(arr, n, element):\n\n\t## iterating through the array\n\tfor i in range(n):\n\n\t\t## checking the current element with required element\n\t\tif arr[i] == element:\n\t\t\t## returning True on match\n\t\t\treturn True\n\n\t## element is not found hence the execution comes here\n\treturn False\n\n\nif __name__ == '__main__':\n\t## initializing the array, length, and element to be searched\n\tarr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\tn = 10\n\telement_to_be_searched = 6\n\t# element_to_be_searched = 11\n\n\tif search_element(arr, n, element_to_be_searched):\n\t\tprint(element_to_be_searched, \"is found\")\n\telse:\n\t\tprint(element_to_be_searched, \"is not found\")\n<\/pre>\n
        F\u00fchren Sie zun\u00e4chst das Programm mit einem Element aus, das im Array vorhanden ist.  Und f\u00fchren Sie es dann mit einem Element aus, das nicht im Array vorhanden ist.<\/p>\n
        Die zeitliche Komplexit\u00e4t des linearen Suchalgorithmus betr\u00e4gt In)<\/strong>.<\/p>\n
        K\u00f6nnen wir es mit verschiedenen Mustern etwas weiter eingrenzen?<\/p>\n
        Wenn wir k\u00f6nnen.  Mal sehen.<\/p>\n
        Bin\u00e4re Suche<\/h2>\n
        Die bin\u00e4rer Suchalgorithmus <\/strong>pr\u00fcft immer das mittlere Element des Arrays.  Dieser Algorithmus sucht nach dem Element in a sortiertes Array<\/strong>.<\/p>\n
        Die bin\u00e4rer Suchalgorithmus <\/strong>Es durchl\u00e4uft das Array und \u00fcberpr\u00fcft das mittlere Element. Wenn es es findet, stoppt es das Programm.  Andernfalls, wenn das mittlere Element kleiner als das erforderliche Element ist, wird der linke Teil des mittleren Elementarrays bei der Suche \u00fcbersprungen.  Andernfalls, wenn das mittlere Element gr\u00f6\u00dfer als das erforderliche Element ist, wird der rechte Teil des mittleren Elementarrays bei der Suche \u00fcbersprungen.<\/p>\n
        Bei jeder Iteration reduziert der bin\u00e4re Suchalgorithmus den Suchbereich f\u00fcr das Element.  Daher ist die Anzahl der Pr\u00fcfungen geringer als die Anzahl der im linearen Suchalgorithmus durchgef\u00fchrten Pr\u00fcfungen.<\/p>\n
        Die Abbildungen helfen uns, das besser zu verstehen bin\u00e4rer Suchalgorithmus<\/strong>.  Lassen Sie uns sie \u00fcberpr\u00fcfen.<\/p>\n
        \"\"<\/p>\n
         \"\" \"\" \"\" \"\"<\/p>\n
        Die zeitliche Komplexit\u00e4t des bin\u00e4ren Suchalgorithmus betr\u00e4gt O (Datensatz n)<\/strong>.  Bei jeder Iteration wird die L\u00e4nge des Suchbereichs um die H\u00e4lfte reduziert.  Es nimmt exponentiell ab.<\/p>\n
        Implementierung der bin\u00e4ren Suche<\/h3>\n
        Wir werden uns zun\u00e4chst die Schritte zur Implementierung des bin\u00e4ren Suchalgorithmus und dann den Code ansehen.  Schauen wir uns die Schritte zum Abschluss der Implementierung des bin\u00e4ren Suchalgorithmus an.<\/p>\n
          \n
        • Initialisieren Sie das Array mit Elementen (Ihren Gl\u00fcckszahlen)<\/li>\n
        • Schreiben Sie eine Funktion namens search_item, <\/strong>das drei Argumente akzeptiert: sortiertes Array, Array-L\u00e4nge und zu suchendes Element.<\/li>\n
        • search_item(arr_sort, n, item):<\/strong>\n
            \n
          • Indexvariable initialisieren Yo <\/strong>f\u00fcr Array-Iteration.<\/li>\n
          • Initialisieren Sie dann zwei Variablen, um den Suchbereich des Arrays beizubehalten.  Hier nennen wir sie so Anfang <\/strong>Und Finale <\/strong>wie die Indizes zeigen.<\/li>\n
          • Iterieren bis Yo <\/strong>ist kleiner als die L\u00e4nge des Arrays.\n
              \n
            • Berechnen Sie den durchschnittlichen Index des Suchbereichs mithilfe von Anfang <\/strong>Und Finale <\/strong>Werte.  Das wird sein (Anfang + Ende) \/\/ 2<\/strong>.<\/li>\n
            • \u00dcberpr\u00fcfen Sie, ob das mittlere indizierte Element des Suchbereichs mit dem erforderlichen Element \u00fcbereinstimmt oder nicht.<\/li>\n
            • Wenn ja, dann komm zur\u00fcck WAHR<\/strong>.<\/li>\n
            • Andernfalls, wenn das mittlere indizierte Element kleiner als das erforderliche Element ist, verschieben Sie das Anfang <\/strong>Suchbereichsindex f\u00fcr mittel + 1<\/strong>.<\/li>\n
            • Andernfalls, wenn das mittlere indizierte Element gr\u00f6\u00dfer als das erforderliche Element ist, verschieben Sie es Finale <\/strong>Suchbereichsindex f\u00fcr mittel \u2013 1<\/strong>.<\/li>\n
            • Erh\u00f6ht den Index des Arrays. Yo<\/strong>.<\/li>\n<\/ul>\n<\/li>\n
            • Wenn sich die Ausf\u00fchrung nach Abschluss der Schleife noch in der Funktion befindet, ist das Element nicht im Array vorhanden.  Deshalb kehre ich zur\u00fcck Gef\u00e4lscht<\/strong>.<\/li>\n<\/ul>\n<\/li>\n
            • Drucken Sie die Nachricht basierend auf dem R\u00fcckgabewert der Funktion search_item<\/strong>.<\/li>\n<\/ul>\n
              Versuchen Sie, den Code \u00e4hnlich der Implementierung des linearen Suchalgorithmus zu schreiben.<\/p>\n
              \u2026<\/p>\n
              Hast du den Code bekommen?<\/p>\n
              Ja, vergleichen Sie es mit dem folgenden Code.  Nein, keine Angst;  Verstehen Sie die Implementierung mit dem folgenden Code.<\/p>\n
              ## searching function\ndef search_element(sorted_arr, n, element):\n\n\t## array index for iteration\n\ti = 0\n\n\t## variables to track the search area\n\t## initializing them with start and end indexes\n\tstart = 0\n\tend = n - 1\n\n\t## iterating over the array\n\twhile i < n:\n\t\t## getting the index of the middle element\n\t\tmiddle = (start + end) \/\/ 2\n\n\t\t## checking the middle element with required element\n\t\tif sorted_arr[middle] == element:\n\t\t\t## returning True since the element is in the array\n\t\t\treturn True\n\t\telif sorted_arr[middle] < element:\n\t\t\t## moving the start index of the search area to right\n\t\t\tstart = middle + 1\n\t\telse:\n\t\t\t## moving the end index of the search area to left\n\t\t\tend = middle - 1\n\t\ti += 1\n\treturn False\n\n\nif __name__ == '__main__':\n\t## initializing the array, length, and element to be searched\n\tarr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\tn = 10\n\telement_to_be_searched = 9\n\t# element_to_be_searched = 11\n\n\tif search_element(arr, n, element_to_be_searched):\n\t\tprint(element_to_be_searched, \"is found\")\n\telse:\n\t\tprint(element_to_be_searched, \"is not found\")\n<\/pre>\n
              Testen Sie den Code mit verschiedenen F\u00e4llen, in denen das Element vorhanden ist und in einigen F\u00e4llen nicht.<\/p>\n
              Abschluss<\/h3>\n
              Die bin\u00e4rer Suchalgorithmus <\/strong>Es ist viel effizienter als linearer Suchalgorithmus<\/strong>.  Wir m\u00fcssen das Array f\u00fcr den bin\u00e4ren Suchalgorithmus sortieren, dies ist beim linearen Suchalgorithmus nicht der Fall.  Das Sortieren nimmt einige Zeit in Anspruch.  Die Verwendung effizienter Sortieralgorithmen l\u00e4sst sich jedoch gut mit dem bin\u00e4ren Suchalgorithmus kombinieren.<\/p>\n
              Jetzt haben Sie ein gutes Verst\u00e4ndnis der am h\u00e4ufigsten verwendeten Algorithmen in Python.<\/p>\n
              Entdecken Sie unten einige der beliebten selbst gehosteten Suchprogramme.<\/p>\n
              Viel Spa\u00df beim Codieren \ud83d\ude42 \ud83e\uddd1\u200d\ud83d\udcbb<\/p>\n   ","protected":false},"excerpt":{"rendered":"
              Die Implementierung einer Suche ist immer eine Herausforderung, aber nicht unm\u00f6glich. Im wirklichen Leben werden wir ohne Muster suchen. Wir gehen einfach zu den Orten, an denen wir glauben, dass es platziert werden k\u00f6nnte. In den meisten F\u00e4llen folgen wir keinem Muster. Funktioniert das Gleiche auch in der Welt des Programmierens? NEIN! Es muss ein […]<\/p>\n","protected":false},"author":1,"featured_media":842912,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":"","fifu_image_url":"https:\/\/blogging-techies.com\/wp-content\/uploads\/2023\/06\/3.webp","fifu_image_alt":""},"categories":[7],"tags":[],"_links":{"self":[{"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/posts\/842911"}],"collection":[{"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/comments?post=842911"}],"version-history":[{"count":0,"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/posts\/842911\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/media\/842912"}],"wp:attachment":[{"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/media?parent=842911"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/categories?post=842911"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogging-techies.com\/ge\/wp-json\/wp\/v2\/tags?post=842911"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}