{"id":11672,"date":"2020-06-11T09:00:00","date_gmt":"2020-06-11T07:00:00","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=11672"},"modified":"2025-06-12T09:22:48","modified_gmt":"2025-06-12T07:22:48","slug":"sortieralgorithmen","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/algorithmen\/sortieralgorithmen\/","title":{"rendered":"Sortieralgorithmen [Ultimate Guide]"},"content":{"rendered":"\n<p class=\"wp-block-paragraph\">Sortieralgorithmen sind Thema jeder Informatiker-Ausbildung. Viele von uns haben irgendwann einmal die genaue Funktionsweise von Insertion Sort bis Merge- und Quicksort auswendig lernen m\u00fcssen, einschlie\u00dflich deren Zeitkomplexit\u00e4ten im <em>best<\/em>, <em>average<\/em> und <em>worst case<\/em> in Big-O-Notation ... um nach der Pr\u00fcfung das meiste davon wieder zu vergessen ;-)<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wenn du eine Auffrischung brauchst, wie die gebr\u00e4uchlichsten Sortieralgorithmen funktionieren und wie sie sich unterscheiden, ist diese Artikelserie genau das Richtige f\u00fcr dich.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Dieser erste Artikel behandelt folgende Fragen:<\/p>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>Welches sind die gebr\u00e4uchlichsten Sortierverfahren?<\/li>\n\n\n\n<li>In welchen Eigenschaften unterscheiden sie sich?<\/li>\n\n\n\n<li>Wie ist das Laufzeitverhalten der einzelnen Sortiermethoden (Platz- und Zeitkomplexit\u00e4t)?<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">M\u00f6chtest du wissen, wie ein bestimmter Sortieralgorithmus genau funktioniert? Jedes aufgelistete Sortierverfahren linkt zu einem vertiefenden Artikel, welcher...<\/p>\n\n\n\n<ul class=\"wp-block-list hc-checked-list\">\n<li>die Funktionsweise des jeweiligen Verfahrens anhand eines Beispiels erkl\u00e4rt,<\/li>\n\n\n\n<li>die Zeitkomplexit\u00e4t herleitet (auf anschauliche Weise, ohne komplizierte mathematische Beweise),<\/li>\n\n\n\n<li>zeigt, wie man den jeweiligen Sortieralgorithmus in Java implementiert, und<\/li>\n\n\n\n<li>die Performance der Java-Implementierung misst und mit dem theoretischen Laufzeitverhalten abgleicht.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Die Quellcodes der gesamten Artikelserie findest du in meinem <a rel=\"noopener\" href=\"https:\/\/github.com\/SvenWoltmann\/sorting-algorithms-ultimate-guide\" target=\"_blank\">GitHub-Repository<\/a>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"eigenschaften-von-sortieralgorithmen\">Eigenschaften von Sortieralgorithmen<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Sortierverfahren unterscheiden sich haupts\u00e4chlich in den folgenden Eigenschaften (Erkl\u00e4rungen findest du in den folgenden Abschnitten):<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Geschwindigkeit (oder besser: Zeitkomplexit\u00e4t)<\/li>\n\n\n\n<li>Platzkomplexit\u00e4t<\/li>\n\n\n\n<li>Stabilit\u00e4t<\/li>\n\n\n\n<li>Vergleichsbasiert \/ nicht-vergleichsbasiert<\/li>\n\n\n\n<li>Parallelisierbarkeit<\/li>\n\n\n\n<li>Rekursiv \/ nicht rekursiv<\/li>\n\n\n\n<li>Adaptionsf\u00e4higkeit<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Du kannst die Erkl\u00e4rungen auch erstmal \u00fcberspringen und sp\u00e4ter hierher zur\u00fcckkehren. Hier geht es direkt zu den <a href=\"#Vergleich_der_wichtigsten_Sortieralgorithmen\">wichtigsten Sortieralgorithmen<\/a>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"zeitkomplexitaet-von-sortieralgorithmen\">Zeitkomplexit\u00e4t von Sortieralgorithmen<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Das wichtigste Kriterium bei der Auswahl eines Sortierverfahrens ist in den meisten F\u00e4llen dessen Geschwindigkeit. Interessant ist hierbei in erster Linie, wie sich die Geschwindigkeit in Abh\u00e4ngigkeit von der Anzahl der zu sortierenden Elemente \u00e4ndert.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Denn ein Algorithmus kann bei hundert Elementen doppelt so schnell sein wie ein anderer, bei tausend Elementen aber durchaus f\u00fcnf mal langsamer (oder noch viel viel langsamer; aber das lie\u00df sich nicht mehr gut in dem Diagramm abbilden):<\/p>\n\n\n<div class=\"wp-block-image hc-img-border-grey\">\n<figure class=\"aligncenter size-full is-resized\"><img decoding=\"async\" width=\"1520\" height=\"850\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2.png\" alt=\"Sortieralgorithmen: linearer vs. quadratischer Aufwand\" class=\"wp-image-13292\" style=\"width:760px;height:425px\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2.png 1520w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-224x125.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-336x188.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-504x282.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-672x376.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-400x224.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-600x336.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-800x447.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-944x528.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_linearer_vs_quadratischer_Aufwand_v2-1200x671.png 1200w\" sizes=\"(max-width: 1520px) 100vw, 1520px\" \/><\/figure>\n<\/div>\n\n\n<p class=\"wp-block-paragraph\">Deshalb gibt man die Laufzeit eines Algorithmus im allgemeinen als Zeitkomplexit\u00e4t in der sogenannten <a href=\"\/de\/algorithmen\/o-notation-zeitkomplexitaet\/\">\"O-Notation\"<\/a> (englisch: \"Big O notation\") an.<\/p>\n\n\n<div class=\"convertkit-form wp-block-convertkit-form\" style=\"\"><script async data-uid=\"5c918c0177\" src=\"https:\/\/happycoders.kit.com\/5c918c0177\/index.js\" data-jetpack-boost=\"ignore\" data-no-defer=\"1\" data-no-optimize=\"1\" nowprocket><\/script><\/div>\n\n\n\n<p class=\"wp-block-paragraph\">Die folgenden Klassen von Zeitkomplexit\u00e4ten sind f\u00fcr Sortieralgorithmen relevant (detailliertere Beschreibungen dieser Komplexit\u00e4tsklassen findest Du in dem jeweils verlinkten Artikel):<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><a href=\"\/de\/algorithmen\/o-notation-zeitkomplexitaet\/#On_linearer_Aufwand\"><em>O(n)<\/em> (ausgesprochen \"O von n\"): linearer Aufwand<\/a> \u2013 f\u00fcr doppelt so viel Elemente ben\u00f6tigt die Sortiermethode doppelt so lange;<\/li>\n\n\n\n<li><a href=\"\/de\/algorithmen\/o-notation-zeitkomplexitaet\/#On_log_n_quasi-linearer_Aufwand\"><em>O(n log n)<\/em> (ausgesprochen \"O von n log n\"): quasi-linearer Aufwand<\/a> \u2013 fast so gut wie linearer Aufwand;<\/li>\n\n\n\n<li><a href=\"\/de\/algorithmen\/o-notation-zeitkomplexitaet\/#On_quadratischer_Aufwand\"><em>O(n\u00b2)<\/em> (ausgesprochen: \"O von n Quadrat\"): quadratischer Aufwand<\/a> \u2013 f\u00fcr doppelt so viele Elemente ben\u00f6tigt die Sortierfunktion viermal so lange, f\u00fcr 10\u00d7 so viele Elemente 100\u00d7 so lang, f\u00fcr 1000\u00d7 so viele Elemente 1.000.000\u00d7 so lang, usw.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Hier noch einmal das Diagramm von oben mit der Angabe der Zeitkomplexit\u00e4ten und einer zus\u00e4tzlichen Kurve f\u00fcr quasilinearen Aufwand. Da die Zeitkomplexit\u00e4t keine Aussage \u00fcber die absolut ben\u00f6tigten Zeiten macht, sind die Achsen hier nicht mehr mit Werten beschriftet.<\/p>\n\n\n<div class=\"wp-block-image hc-img-border-grey\">\n<figure class=\"aligncenter size-full is-resized\"><img decoding=\"async\" width=\"1432\" height=\"820\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet.png\" alt=\"Sortieralgorithmen: Zeitkomplexit\u00e4t\" class=\"wp-image-13293\" style=\"width:716px;height:410px\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet.png 1432w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-224x128.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-336x192.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-504x289.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-672x385.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-400x229.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-600x344.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-800x458.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-944x541.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/Sortieralgorithmen_Zeitkomplexitaet-1200x687.png 1200w\" sizes=\"(max-width: 1432px) 100vw, 1432px\" \/><\/figure>\n<\/div>\n\n\n<p class=\"wp-block-paragraph\">Bei quadratischer Komplexit\u00e4t st\u00f6\u00dft man relativ schnell an die Leistungsgrenzen heutiger Hardware:<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">W\u00e4hrend Quicksort auf meinem Laptop eine Milliarde Elemente in 90 Sekunden sortiert, breche ich den Versuch mit Insertion Sort nach einer Viertelstunde ab. Ausgehend von etwa 100 Sekunden f\u00fcr eine Million Elemente, w\u00fcrde Insertion Sort f\u00fcr eine Milliarde Elemente beeindruckende drei Jahre und zwei Monate brauchen. <\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Quadratische Komplexit\u00e4t sollte also, wenn m\u00f6glich, vermieden werden.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"platzkomplexitaet-von-sortieralgorithmen\">Platzkomplexit\u00e4t von Sortieralgorithmen<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Nicht nur Zeitkomplexit\u00e4t ist f\u00fcr Sortierverfahren relevant, sondern auch die Platzkomplexit\u00e4t. Diese gibt an, wie viel zus\u00e4tzlichen Speicherplatz der Algorithmus in Abh\u00e4ngigkeit von der Anzahl der zu sortierenden Elemente ben\u00f6tigt. Damit ist nicht der Speicherplatz gemeint, der f\u00fcr die zu sortierenden Elemente selbst ben\u00f6tigt wird, sondern dar\u00fcberhinaus ben\u00f6tigter Platz f\u00fcr z. B. Hilfsvariablen, Schleifenz\u00e4hler und tempor\u00e4re Arrays.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Platzkomplexit\u00e4t wird mit den gleichen Klassen angegeben wie Zeitkomplexit\u00e4t. Hier treffen wir noch auf eine weitere Klasse:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><a href=\"\/de\/algorithmen\/o-notation-zeitkomplexitaet\/#O1_konstanter_Aufwand\"><em>O(1)<\/em> (ausgesprochen \"O von 1\"): konstanter Aufwand<\/a> \u2013 bei vielen Sortieralgorithmen ist der zus\u00e4tzliche Speicherbedarf unabh\u00e4ngig von der Anzahl der zu sortierenden Elemente.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"stabile-und-nicht-stabile-sortierverfahren\">Stabile und nicht-stabile Sortierverfahren<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Bei stabilen Sortierverfahren wird die relative Reihenfolge von Elementen, die den gleichen Sortierschl\u00fcssel haben, beibehalten. Bei nicht-stabilen Sortierverfahren wird dies nicht garantiert: Die relative Reihenfolge kann beibehalten werden, muss es aber nicht.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Was bedeutet das?<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In folgendem Beispiel haben wir eine zuf\u00e4llig erzeugte Namensliste. Die Liste ist zun\u00e4chst nach Vornamen sortiert:<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter hc-sa-table1\"><table><tbody><tr><td class=\"has-text-align-center\" data-align=\"center\">Annika Weigert<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Fabio M\u00fcller<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Gertrud Selig<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Jonathan Heydrich<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Mathias M\u00fcller<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Waltraud Birke<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Diese Liste soll nun \u2013 ohne die Vornamen zu betrachten \u2013 nach Nachnamen sortiert werden. Wenn wir daf\u00fcr ein stabiles Sortierverfahren anwenden, ist das Ergebnis immer:<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter hc-sa-table1\"><table><tbody><tr><td class=\"has-text-align-center\" data-align=\"center\">Waltraud Birke<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Jonathan Heydrich<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\"><strong>Fabio M\u00fcller<\/strong><\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\"><strong>Mathias M\u00fcller<\/strong><\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Annika Weigert<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Gertrud Selig<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">D. h. die Reihenfolge von Fabio und Mathias bleibt bei einem stabilen Sortierverfahren immer unver\u00e4ndert. Bei einem unstabilen Sortierverfahren kann auch folgendes Sortierergebnis herauskommen:<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter hc-sa-table1\"><table><tbody><tr><td class=\"has-text-align-center\" data-align=\"center\">Waltraud Birke<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Jonathan Heydrich<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\"><strong>Mathias M\u00fcller<\/strong><\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\"><strong><strong>Fabio<\/strong><\/strong> <strong>M\u00fcller<\/strong><\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Annika Weigert<\/td><\/tr><tr><td class=\"has-text-align-center\" data-align=\"center\">Gertrud Selig<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Mathias und Fabio sind hierbei gegen\u00fcber der Ausgangsreihenfolge vertauscht.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"vergleichsbasierte-und-nicht-vergleichsbasierte-sortierverfahren\">Vergleichsbasierte und nicht-vergleichsbasierte Sortierverfahren<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Die meisten der bekannten Sortierverfahren basieren auf dem Vergleich zweier Elemente auf <em>kleiner<\/em>, <em>gr\u00f6\u00dfer<\/em> oder <em>gleich<\/em>. Es existieren jedoch auch nicht-vergleichsbasierte Sortieralgorithmen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wie das funktionieren kann, erf\u00e4hrst du in den Abschnitten <a href=\"#Counting_Sort\">Counting Sort<\/a> und <a href=\"#Radix_Sort\">Radix Sort<\/a>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"parallelisierbarkeit\">Parallelisierbarkeit<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Diese Eigenschaft beschreibt, ob und in wie weit sich ein Sortieralgorithmus f\u00fcr die parallele Abarbeitung auf mehreren CPU Cores eignet.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"rekursive-nicht-rekusive-sortiermethoden\">Rekursive \/ nicht-rekusive Sortiermethoden<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Ein rekursiver Sortieralgorithmus ben\u00f6tigt zus\u00e4tzlichen Speicherplatz auf dem Stack. Bei zu tiefer Rekursion droht die gef\u00fcrchtete <code>StackOverflowExecption<\/code>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"adaptionsfaehigkeit-adaptability\">Adaptionsf\u00e4higkeit (adaptability)<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Ein adaptiver Sortieralgorithmus kann sein Verhalten w\u00e4hrend der Laufzeit an bestimmte Eingabedaten (z. B. vorsortierte Elemente) anpassen und diese deutlich schneller sortieren als zuf\u00e4llig verteilte Elemente.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"vergleich-der-wichtigsten-sortieralgorithmen\">Vergleich der wichtigsten Sortieralgorithmen<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Die folgende Tabelle gibt einen \u00dcberblick \u00fcber alle in dieser Artikelserie vorgestellten Sortieralgorithmen. Es handelt sich um eine Auswahl der am meisten verbreitetsten Sortierverfahren. Dies sind auch die, die man in der Regel in der Informatik-Ausbildung lernt.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Jeder Eintrag ist verlinkt zu einem vertiefenden Artikel, der den jeweiligen Algorithmus und dessen Eigenschaften im Detail beschreibt und auch dessen Quellcode enth\u00e4lt.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wenn dir zun\u00e4chst ein \u00dcberblick gen\u00fcgt, findest du im Anschluss an die Tabelle die Sortieralgorithmen in jeweils einem Satz erkl\u00e4rt.<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes hc-sa-table2\"><table><thead><tr><th>Algorithmus<\/th><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><a href=\"\/de\/algorithmen\/insertion-sort\/\">Insertion Sort<\/a><\/td><td><em>O(n)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(1)<\/em><\/td><td>Ja<\/td><\/tr><tr><td><a href=\"\/de\/algorithmen\/selection-sort\/\">Selection Sort<\/a><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(1)<\/em><\/td><td>Nein<\/td><\/tr><tr><td><a href=\"\/de\/algorithmen\/bubble-sort\/\">Bubble Sort<\/a><\/td><td><em>O(n)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(1)<\/em><\/td><td><span style=\"white-space:pre\"> <\/span>Ja<\/td><\/tr><tr><td><a href=\"\/de\/algorithmen\/quicksort\/\">Quicksort<\/a><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(log n)<\/em><\/td><td>Nein<\/td><\/tr><tr><td><a href=\"\/de\/algorithmen\/mergesort\/\">Mergesort<\/a><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n)<\/em><\/td><td>Ja<\/td><\/tr><tr><td><a href=\"\/de\/algorithmen\/heapsort\/\">Heapsort<\/a><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(1)<\/em><\/td><td>Nein<\/td><\/tr><tr><td><a href=\"\/de\/algorithmen\/counting-sort\/\">Counting Sort<\/a><\/td><td><em>O(n + k)<\/em><\/td><td><em>O(n + k)<\/em><\/td><td><em>O(n + k)<\/em><\/td><td><em>O(n + k)<\/em><\/td><td>Ja<\/td><\/tr><tr><td><a href=\"\/de\/algorithmen\/radix-sort\/\">Radix Sort<\/a><\/td><td><em>O(k \u00b7 (b + n))<\/em><\/td><td><em>O(k \u00b7 (b + n))<\/em><\/td><td><em>O(k \u00b7 (b + n))<\/em><\/td><td><em>O(b + n)<\/em><\/td><td>Ja<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Die Variable <em>k<\/em> steht bei Counting Sort steht f\u00fcr <em>keys<\/em> (die Anzahl der m\u00f6glichen Schl\u00fcsselwerte) und bei Radix Sort f\u00fcr <em>key length<\/em> (die maximale L\u00e4nge eines Schl\u00fcssels). Die Variable <em>b<\/em> bei Radix Sort steht f\u00fcr <em>Basis<\/em>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"einfache-sortierverfahren\">Einfache Sortierverfahren<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Einfache Sortierverfahren sind gut geeignet, um kleine Listen zu sortieren. F\u00fcr gro\u00dfe Listen sind sie aufgrund des quadratischen Aufwands ungeeignet. Insbesondere Insertion Sort (was aufgrund von weniger Vergleichen ungef\u00e4hr doppelt so schnell ist wie Selection Sort) wird gerne verwendet, um effiziente Sortieralgorithmen wie Quicksort und Mergesort weiter zu optimieren. Dazu l\u00e4sst man diese Verfahren kleine Teillisten im Gr\u00f6\u00dfenbereich bis ca. 50 Elemente mit Insertion Sort sortieren.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Insertion Sort<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\"><a href=\"\/de\/algorithmen\/insertion-sort\/\">Insertion Sort<\/a> verwendet man zum Beispiel beim Sortieren von Spielkarten: man nimmt eine Karte nach der anderen auf und f\u00fcgt sie an der richtigen Stelle in die bereits sortieren Karten ein (auf deutsch: Einf\u00fcge-Sortieren).<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter is-style-stripes hc-sa-table2 hc-max-width-480\"><table class=\"has-fixed-layout\"><thead><tr><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><em>O(n)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(1)<\/em><\/td><td>Ja<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Selection Sort<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\"><a href=\"\/de\/algorithmen\/selection-sort\/\">Selection Sort<\/a> kannst du dir anhand des Spielkartenbeispiels so vorstellen, dass alle einzusortierenden Karten offen vor dir liegen. Du suchst die kleinste Karte und nimmst sie auf, dann suchst du die n\u00e4chstgr\u00f6\u00dfere Karte und nimmst sie rechts neben die zuerst aufgenommene Karte, usw. bis du als letztes die gr\u00f6\u00dfte Karte aufnimmst und nach ganz rechts auf die Hand nimmst.<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter is-style-stripes hc-sa-table2 hc-max-width-480\"><table class=\"has-fixed-layout\"><thead><tr><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><em>O(n\u00b2)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(1)<\/em><\/td><td>Nein<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Bubble Sort<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">Bei <a href=\"\/de\/algorithmen\/bubble-sort\/\">Bubble Sort<\/a> werden von links nach rechts jeweils nebeneinanderliegende Elemente verglichen und \u2013 falls diese in der falschen Reihenfolge vorliegen \u2013 miteinander vertauscht. Dieser Vorgang wird so oft wiederholt bis alle Elemente sortiert sind.<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter is-style-stripes hc-sa-table2 hc-max-width-480\"><table class=\"has-fixed-layout\"><thead><tr><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><em>O(n)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(1)<\/em><\/td><td>Ja<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"effiziente-sortierverfahren\">Effiziente Sortierverfahren<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Effiziente Sortieralgorithmen erreichen eine deutlich bessere Zeitkomplexit\u00e4t von <em>O(n log n)<\/em>. Sie eignen sich daher auch f\u00fcr gro\u00dfe Datens\u00e4tze mit Milliarden von Elementen.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Quicksort<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\"><a href=\"\/de\/algorithmen\/quicksort\/\">Quicksort<\/a> funktioniert nach dem \"Teile und Herrsche\"-Prinzip. Durch eine sogenannte <em>Partitionierung<\/em> wird der Datensatz zun\u00e4chst grob in kleine und gro\u00dfe Elemente aufgeteilt: kleine kommen nach links, gro\u00dfe nach rechts. Jede dieser Partitionen wird danach rekursiv wieder partitioniert, solange bis eine Partition nur noch ein Element enth\u00e4lt und damit als sortiert gilt. <\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Sobald f\u00fcr alle Partionen und Teil-Partitionen die tiefste Rekursionsstufe erreicht ist, ist die gesamte Liste sortiert.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Quicksort hat zwei Nachteile:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Im <em>worst case<\/em> (bei absteigend sortierten Elementen) ist die Zeitkomplexit\u00e4t <em>O(n\u00b2)<\/em>.<\/li>\n\n\n\n<li>Quicksort ist nicht stabil.<\/li>\n<\/ul>\n\n\n\n<figure class=\"wp-block-table aligncenter is-style-stripes hc-sa-table2 hc-max-width-480\"><table class=\"has-fixed-layout\"><thead><tr><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n\u00b2)<\/em><\/td><td><em>O(log n)<\/em><\/td><td>Nein<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Mergesort<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\"><a href=\"\/de\/algorithmen\/mergesort\/\">Mergesort<\/a> funktioniert ebenfalls nach dem \"Teile und Herrsche\"-Prinzip. Wobei hier sozusagen in umgekehrter Reihenfolge vorgegangen wird wie bei Quicksort: Anstatt zuerst zu sortieren und dann in die Rekursion abzusteigen, geht Mergesort zuerst in die Rekursion, bis Teillisten mit nur noch einem Element erreicht sind und f\u00fcgt dann jeweils zwei Teillisten so zusammen (\"merged\" sie), dass eine sortierte Teilliste entsteht.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Beim letzten Schritt aus der Rekursion heraus werden zwei verbleibende Teillisten gemerged und ergeben das sortierte Gesamtergebnis.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Mergesort hat gegen\u00fcber Quicksort den Vorteil, dass auch im <em>worst case<\/em> die Zeitkomplexit\u00e4t <em>O(n log n)<\/em> nicht \u00fcberschreitet und dass es stabil ist. Allerdings erkauft man sich diese Vorteile durch einen zus\u00e4tzlichen Platzbedarf in der Gr\u00f6\u00dfenordnung <em>O(n)<\/em>.<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter is-style-stripes hc-sa-table2 hc-max-width-480\"><table class=\"has-fixed-layout\"><thead><tr><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n)<\/em><\/td><td>Ja<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Heapsort<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">Der Begriff <em>Heapsort<\/em> ist f\u00fcr Java-Entwickler oft verwirrend, da man ihn zun\u00e4chst mit dem Java Heap in Verbindung bringt. Die Heaps von Heapsort und Java sind allerdings zwei v\u00f6llig unterschiedliche Dinge.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><a href=\"\/de\/algorithmen\/heapsort\/\">Heapsort<\/a> arbeitet mit der <a href=\"\/de\/algorithmen\/heapsort\/#Was_ist_ein_Heap\">Datenstruktur Heap<\/a>, einem <a href=\"\/de\/algorithmen\/binaerbaum-java\/#Array-Darstellung_des_Binarbaums\">auf ein Array abgebildeter Bin\u00e4rbaum<\/a>, in dem jeder Knoten gr\u00f6\u00dfer oder gleich seiner Kinder ist. Das gr\u00f6\u00dfte Element liegt also immer auf der Wurzelposition. <\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Dieses Wurzelelement wird entnommen, dann wird das letzte Element auf die Wurzelposition gesetzt und danach der Baum per \"Heapify\"-Operation repariert, woraufhin wiederum das gr\u00f6\u00dfte der verbleibenden Element auf der Wurzelposition liegt. Der Prozess wird solange wiederholt, bis der Baum leer ist. Die dem Baum entnommenen Elemente ergeben das sortierte Ergebnis.<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter is-style-stripes hc-sa-table2 hc-max-width-480\"><table class=\"has-fixed-layout\"><thead><tr><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(n log n)<\/em><\/td><td><em>O(1)<\/em><\/td><td>Nein<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"nicht-vergleichsbasierte-sortierverfahren\">Nicht vergleichsbasierte Sortierverfahren<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Nicht vergleichsbasierte Sortierverfahren basieren nicht auf dem Vergleich zweier Element auf <em>kleiner<\/em>,&nbsp;<em>gr\u00f6\u00dfer<\/em>&nbsp;oder&nbsp;<em>gleich<\/em>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wie k\u00f6nnen sie dann funktionieren?<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Am besten l\u00e4sst sich das an einem Beispiel erkl\u00e4ren \u2013 im folgenden anhand von Counting Sort.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Counting Sort<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">Bei <a href=\"\/de\/algorithmen\/counting-sort\/\">Counting Sort<\/a> werden Elemente \u2013 wie der Name schon sagt \u2013 gez\u00e4hlt. Um beispielsweise ein Array mit Zahlen aus dem Bereich 1 bis 10 zu sortieren, z\u00e4hlen wir (in einem einzigen Durchgang), wie oft die 1 vorkommt, wie oft die 2, usw. bis zur 10. <\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Im zweiten Durchgang schreiben wir dann die 1 so oft von links beginnend in das Array, wie sie vorkommt, dann die 2 so oft, wie diese vorkommt, usw. wiederum bis zur 10.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Dieses Verfahren wird in der Regel nur f\u00fcr kleine Zahlentypen wie <em>byte<\/em>, <em>char<\/em> oder <em>short<\/em> eingesetzt, oder wenn der Bereich der zu sortierenden Zahlen bekannt ist (z. B. <em>ints<\/em> zwischen 0 und 150). Der Grund daf\u00fcr ist, dass wir f\u00fcr das Z\u00e4hlen der Elemente ein zus\u00e4tzliches Array entsprechend der Gr\u00f6\u00dfe des Zahlenbereichs ben\u00f6tigen.<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter is-style-stripes hc-sa-table2 hc-max-width-480\"><table class=\"has-fixed-layout\"><thead><tr><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><em>O(n + k)<\/em><\/td><td><em>O(n<em> + k<\/em>)<\/em><\/td><td><em>O(n + k)<\/em><\/td><td><em>O(k)<\/em><\/td><td>Ja<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Die Variable&nbsp;<em>k<\/em>&nbsp;steht f\u00fcr die Anzahl der m\u00f6glichen Werte (<em>keys<\/em>).<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Radix Sort<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">Bei Radix Sort werden die Elemente Ziffer f\u00fcr Ziffer sortiert. Dreistellige Zahlen z. B. zuerst nach den Einerstellen, dann nach den Zehnerstellen und zuletzt nach den Hunderterstellen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Dieses Verfahren eignet sich im Gegensatz zu Counting Sort auch f\u00fcr gro\u00dfe Zahlenr\u00e4ume wie <code>int<\/code> und <code>long<\/code>, ist stabil und kann sogar schneller sein als Quicksort, hat jedoch mit <em>O(n)<\/em> eine h\u00f6here Platzkomplexit\u00e4t und wird daher seltener eingesetzt.<\/p>\n\n\n\n<figure class=\"wp-block-table aligncenter is-style-stripes hc-sa-table2 hc-max-width-480\"><table class=\"has-fixed-layout\"><thead><tr><th>Zeit<br>best case<\/th><th>Zeit<br>avg. case<\/th><th>Zeit<br>worst case<\/th><th>Platz<\/th><th>Stabil<\/th><\/tr><\/thead><tbody><tr><td><em><em>O(k \u00b7 (b + n))<\/em><\/em><\/td><td><em><em>O(k \u00b7 (b + n))<\/em><\/em><\/td><td><em><em>O(k \u00b7 (b + n))<\/em><\/em><\/td><td><em>O(n)<\/em><\/td><td>Ja<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"sonstige-sortieralgorithmen\">Sonstige Sortieralgorithmen<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Es gibt zahlreiche weitere Sortieralgorithmen (Shell Sort, Comb Sort, Bucket Sort, um nur ein paar zu nennen). Die in diesem Artikel vorgestellten Methoden zu kennen stellt meiner Meinung nach jedoch ein sehr gutes Grundlagenwissen dar.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Falls du dir die Javadocs von <code>List.sort()<\/code> und <code>Arrays.sort()<\/code> durchgelesen hast, fragst du dich vielleicht, warum ich hier <em>Timsort<\/em> und <em>Dual-Pivot Quicksort<\/em> nicht auff\u00fchre.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><em>Timsort<\/em> ist kein komlett eigenst\u00e4ndiges Sortierverfahren. Vielmehr ist es eine Kombination aus Mergesort, Insertion Sort und etwas zus\u00e4tzlicher Logik. Ich werde Timsort im Artikel \u00fcber Mergesort beschreiben.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Ebenso ist <em>Dual-Pivot Quicksort<\/em> eine Variante des regul\u00e4ren Quicksort und wird im entsprechenden Artikel beschrieben werden.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"zusamenfassung\">Zusamenfassung<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Dieser Artikel hat einen \u00dcberblick \u00fcber die g\u00e4ngigsten Sortieralgorithmen gegeben und die Eigenschaften beschrieben, in denen sich diese haupts\u00e4chlich unterscheiden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In den folgenden Teilen dieser Serie beschreibe ich je einen Sortieralgorithmus im Detail \u2013 anhand von Beispielen und mit Quellcodes.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In einem weiteren Teil gebe ich einen <a href=\"\/de\/algorithmen\/sortieren-in-java\/\">\u00dcberblick \u00fcber die Sortiermethoden, die Java<\/a> bereitstellt, und zeige, wie man zum einen primitive Datentypen sortiert und zum anderen Objekte mit Hilfe von <a href=\"\/de\/java\/comparator-comparable-compareto\/\">Comparator und Comparable<\/a>.<\/p>\n<aside><p>Wenn dir der Artikel weitergeholfen hat, w\u00fcrde ich mich sehr \u00fcber eine positive Bewertung auf meinem <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">ProvenExpert-Profil<\/a> freuen. Dein Feedback hilft mir, meine Inhalte weiter zu verbessern und motiviert mich, neue informative Artikel zu schreiben.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">Bewertung abgeben<\/a><\/p>\r\n                        <p>M\u00f6chtest du auf dem Laufenden bleiben und informiert werden, wenn neue Artikel auf HappyCoders.eu ver\u00f6ffentlicht werden? Dann <a href=\"#\" data-formkit-toggle=\"d8ee997126\">klicke hier<\/a>, um dich f\u00fcr den HappyCoders-Newsletter anzumelden.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"#\" data-formkit-toggle=\"d8ee997126\">Newsletter-Anmeldung<\/a><\/p><\/aside>","protected":false},"excerpt":{"rendered":"<p>Wenn du eine Auffrischung brauchst, wie die gebr\u00e4uchlichsten Sortieralgorithmen funktionieren und wie sie sich unterscheiden, ist diese Artikelserie genau das Richtige f\u00fcr dich.<\/p>\n","protected":false},"author":1,"featured_media":43233,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_titles_title":"","_seopress_titles_desc":"Die wichtigsten Sortierverfahren und ihre Zeitkomplexit\u00e4t: Insertion Sort, Selection Sort, Bubble Sort, Quicksort, Mergesort, Heapsort und mehr.","_seopress_robots_index":"","_seopress_robots_follow":"","_seopress_robots_imageindex":"","_seopress_robots_snippet":"","_seopress_robots_primary_cat":"none","_seopress_robots_breadcrumbs":"","_seopress_robots_freeze_modified_date":"","_seopress_robots_custom_modified_date":"","_seopress_robots_canonical":"","_seopress_social_fb_title":"","_seopress_social_fb_desc":"","_seopress_social_fb_img":"","_seopress_social_fb_img_attachment_id":0,"_seopress_social_fb_img_width":0,"_seopress_social_fb_img_height":0,"_seopress_social_twitter_title":"","_seopress_social_twitter_desc":"","_seopress_social_twitter_img":"","_seopress_social_twitter_img_attachment_id":0,"_seopress_social_twitter_img_width":0,"_seopress_social_twitter_img_height":0,"_seopress_redirections_value":"","_seopress_redirections_enabled":"","_seopress_redirections_enabled_regex":"","_seopress_redirections_logged_status":"","_seopress_redirections_param":"","_seopress_redirections_type":301,"_seopress_analysis_target_kw":"sortieralgorithmen,sortierverfahren,sortieren","_seopress_news_disabled":"","_seopress_video_disabled":"","_seopress_video":[{"url":"","title":"","desc":"","thumbnail":"","duration":"","rating":"","view_count":"","tag":"","cat":""}],"_seopress_pro_schemas_manual":[{"_seopress_pro_rich_snippets_type":"none"}],"_seopress_pro_rich_snippets_disable_all":"","_seopress_pro_rich_snippets_disable":[],"_seopress_pro_schemas":[],"_uag_custom_page_level_css":"","_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"_metis_text_type":"standard","_metis_text_length":15445,"_post_count":0,"footnotes":""},"categories":[127],"tags":[129],"class_list":["post-11672","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-algorithmen","tag-sortieralgorithmen"],"uagb_featured_image_src":{"full":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/06\/sorting-algorithms-java-feature-image.jpg",1770,986,false]},"uagb_author_info":{"display_name":"Sven Woltmann","author_link":"https:\/\/www.happycoders.eu\/de\/author\/sven\/"},"uagb_comment_info":3,"uagb_excerpt":"Wenn du eine Auffrischung brauchst, wie die gebr\u00e4uchlichsten Sortieralgorithmen funktionieren und wie sie sich unterscheiden, ist diese Artikelserie genau das Richtige f\u00fcr dich.","public_identification_id":"9005bca787d94948a88f449605073cd1","private_identification_id":"ce313d84c3e64239bcf64c558ab9d036","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/11672","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/comments?post=11672"}],"version-history":[{"count":10,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/11672\/revisions"}],"predecessor-version":[{"id":52509,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/11672\/revisions\/52509"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/43233"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=11672"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=11672"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=11672"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}