Die eigentliche Magie von Quicksort geschieht in der partition-Funktion. Grob gesagt passiert hier folgendes: zuerst wird in Zeile (8) und (9) durch die Funktion choose ein Pivot-Element ausgewählt (siehe dazu unten); im Anschluss wird in Zeile (10) das Pivot-Element vorübergehend ans rechte Ende des Feldes geschoben. In den Zeilen (12) bis (15) wird durch das Feld von links nach rechts iteriert (mit Ausnahme des Pivot-Elements ganz rechts) und der in Zeile (11) initialisierte Index immer dann erhöht, wenn im Feld ein Element kleiner als das Pivot-Element gefunden wird; der Index markiert dabei die Stelle im Feld, bis zu der alle Elemente kleiner als das Pivot sind. Durch die Vertauschung in Zeile (14) wird sichergestellt, dass alle Element links des Indexes diese Bedingung erfüllen. Im Anschluss wird in Zeile (16) das temporär nach rechts geschobene Pivot-Element an die Stelle des Indexes kopiert, so dass die eben genannte Bedingung tatsächlich gilt und alle Elemente links des Pivot-Elements kleiner als das Element selber sind; schließlich wird in Zeile (17) der bestimmte Index zur weiteren Verwendung zurückgegeben.

Ein kleines Beispiel zur Verdeutlichung; nehmen wir an, wir haben das folgende (Teil-)Feld zum Sortieren:

1  4  5  2  3

Durch die Funktion choose wird nun zum Beispiel die 4 als Pivot-Element gewählt (markiert durch ein kleines p):

1  4  5  2  3
p

Als erstes wird das Pivot nun ganz nach rechts gesetzt, so dass sich folgendes Bild ergibt:

1  3  5  2  4
p

Nun beginnt der eigentliche Algorithmus; das Feld wird von links nach rechts durchlaufen (markiert durch die Laufvariable i), wobei der Index (markiert durch ^) immer dann verschoben wird, wenn ein Element kleiner als das Pivot-Element angetroffen wird; gleichzeitig wird in einem solchen Fall das gefundene Element mit dem Element an der Index-Position vertauscht wird (zu sehen in der 5. Zeile):

1  3  5  2  4
î           p
1  3  5  2  4
î        p
1  3  5  2  4
î     p
1  3  5  2  4
^  i  p
1  3  2  5  4
^  i/p

Als Endzustand ergibt sich also das folgende Umsortierte Feld, in welchem alle Elemente links des Pivot-Elements kleiner, alle rechts davon größer als das Pivot-Element selber sind. Die zurückgegebene Index-Position entspricht hier der Position der 4:

1  3  2  4  5
^

Nun würde man den Quicksort-Algorithmus rekursiv auf das linke und rechte Teilfeld anwenden (wobei beim rechten Teilfeld, bestehend aus der 5, keine weitere Sortierung nötig ist) und so Stück für Stück das gesamte Feld sortieren. Die Wahl des Pivot-Indexes kann übrigens nach unterschiedlichen Kriterien erfolgen; so kann zum Beispiel immer das Element ganz links oder rechts im Feld gewählt werden (wenngleich sich diese Wahl als ungünstig herausgestellt hat), es kann ein zufälliges Element gewählt werden oder ein Element, von dem erwartet werden kann, dass es ungefähr in der Mitte des Feldes zum Liegen kommt – letzteres wäre die beste Wahl für einen möglichst effizienten Algorithmus.

Die hier beschriebene Umsetzung des Quicksort-Algorithmus ist übrigens nur eine von vielen Varianten; die Bestimmung der Index-Position mit den dazu nötigen Vertauschungen kann auf unterschiedlichste Art und Weise erfolgen. In jedem Fall ist der Algorithmus aber sehr effizient und wird heutzutage als Standard-Sortieralgorithmus in vielen Programmen eingesetzt.

Und noch eine abschließende Information: Quicksort ist in der hier vorgestellten Implementierung ein sogenannter in-place-Algorithmus; derartige Algorithmen führen den Hauptteil ihrer Operationen auf den Eingabedaten selbst durch, benötigen also keinen zusätzlichen Speicherplatz zur Abarbeitung. Demgegenüber stehen die out-of-place-Algorithmen, welche folgerichtig zusätzlichen Speicherplatz benötigen (für die Interessierten: von Quicksort existiert auch eine out-of-place-Variante, welche mit Hilfe von Listen umgesetzt werden kann).

1 / 2

Kommentare (8)

  1. #1 m
    Oktober 24, 2011

    in place bis auf O(log n) index-Variablen (im Beispiel sogar O(n) worst case)</pingelig>

  2. #2 rolak
    Oktober 25, 2011

    moin m, so weit ich weiß, gibt es eine engere und eine weitere Auffassung von in/out-of-place, letztere bezieht sich auf das direkte Manipulieren bzw Überschreiben des Inputs, erstere zusätzlich auf die Problemunabhängigkeit des zusätzlich benötigten Speicherplatzes.

  3. #3 m
    Oktober 26, 2011

    Mist, definitionen. Allerdings scheint mir die weitere Auffassung etwas beliebig; damit kann man wohl jeden Sortieralgorithmus in-place implementieren, in dem man ein Feld/eine Liste mit Indices mit einem beliebigen Verfahren sortiert, and dann das Eingabefeld in die so erhaltene Reihenfolge bringt.

  4. #4 Marcus Frenkel
    Oktober 26, 2011

    @m
    Der ursprüngliche Einwand war korrekt, rolaks Korrektur aber auch. In-Place-Algorithmen beziehen sich in der engeren Bedeutung darauf, dass die Eingabe direkt manipuliert wird. In der allgemeinen Auffassung in Bezug auf den tatsächlich benötigten Speicherplatz ist Quicksort in der Tat kein in-place-Algorithmus, da durch die Rekursion viel Speicher benötigt wird. An der Stelle ist die Begrifflichkeit leider ein wenig schwammig, da stimme ich zu.

  5. #5 michael
    Oktober 27, 2011

    > da durch die Rekursion viel Speicher benötigt wird.

    Die Rekursionstiefe ist aber durch die Länge des Eingabevektor beschränkt, und damit ist der benötigte Speicherplatz durch Konstante * Länge des Eingabevektor beschränkt.

    Die Rekursion kann man auch mit Hilfe einer Queue z.B. eliminieren, wenn es denn sein muss.

  6. #6 Marcus Frenkel
    Oktober 27, 2011

    @michael
    Prinzipiell richtig, aber da der benötigte Speicherplatz von der Länge des Eingabevektors und damit von der Problemgröße abhängt, hat man eben doch keinen absolut reinen in-place-Algorithmus in der Betrachtung auf den absolut benötigten Speicherplatz (sondern nur, wenn man allein die zu sortierenden Daten betrachtet).
    Die Queue hilft diesbezüglich auch nicht weiter, da deren Länge natürlich genauso von der Eingabe abhängt.

  7. #7 sebix
    Oktober 29, 2011

    Ich hab auch noch was zum Meckern 😀
    “Für den Einsatz in Programmen, wo Geschwindigkeit wichtig ist und große Datenmengen sortiert werden müssen, können sie daher nicht wirklich eingesetzt werden.”
    Da der Quicksort auf O(n²) ausarten kann, ist er nicht in geschwindigkeits-relevanten Programmen verwendbar, bspw in Mail-Servern. Dort wird dann eine Mischung aus Quicksort und Mergesort verwendet.
    In der Standard-Template-Library STL (C++) wurde früher Quicksort verwendet, inzwischen wechselte man aber zum sog. Introsort (siehe dazu die SGI-Doku)

  8. #8 Marcus Frenkel
    Oktober 29, 2011

    @sebix
    Einwand teilweise angenommen. 😉
    Das Quicksort nicht der Weisheit letzter Schluss ist, ist absolut korrekt – habe ich aber auch gar nicht behauptet. Nur, dass es ein ziemlich häufig verwendeter Algorithmus ist, was vermutlich auch an der einfachen Implementierung liegen dürfte.
    Sobald es ernsthaft auf die Geschwindigkeit angeht und um wirklich große Datenmengen geht, kommt man um spezialisierte Algorithmen vermutlich ohnehin nicht mehr herum, die etwas genauer an das zu lösende Problem angepasst sind. Die ganzen X-Sort-Algorithmen sind ja mehr oder weniger Standardlösungen, die ohne das Wissen um die Problemdomäne benutzt werden können (und da liegt ihr Charme).

    Dass die STL aber gar kein Quicksort mehr verwendet, ist an mir vorbeigegangen. Vielen Dank für den Hinweis.