Ich habe die beiden von mir entwickelten Pseudocodes (siehe oben) zu einem neuen vereint. Der Anfang und das Ende laufen auch hier wie beim ersten Code aufeinander zu, heißen aber nicht "i" und "j", sondern wie im zweiten Code "s" (smaller) und "b" (bigger). Ebenfalls wie beim zweiten Code, finden sich nach der Teilung alle Elemente die mit Pivot identisch sind, im Trennungsbereich zwischen "s" und "b". Hier befindet sich "s" aber immer eine Position weiter rechts und "b" immer eine Position weiter links. Wenn die Elemente "s" (smaller) und "b" (bigger) nicht getauscht werden können, dann läuft die "X-Suche" zwischen "s" und "b" so lange weiter, bis sie ein Element gefunden hat, das kleiner oder größer als Pivot ist und tauscht es mit der Position von "s" bzw. "b". Anschließend springt der Ablauf zurück zu den Positionen, wo kleinere bzw. größere Elemente als Pivot übersprungen werden. Um eine unsinnige Code-Struktur zu vermeiden, die die Arbeitsgeschwindigkeit unnötig ausbremsen würde, war es zwingend erforderlich zwei Sprungzeilen und fünf Mal den Goto-Befehl zu verwenden. funktion quicksort(links, rechts) // Autor: Martin Oppermann s := links b := rechts pivot := daten[s + Int[[b - s + 1] / 2]] x := s // Am Anfang kleinere Elemente als Pivot überspringen kleiner: // Sprungzeile "kleiner" falls daten[s] < pivot dann s := s + 1 GoTo kleiner // Springe direkt zur Position Sprungzeile "kleiner" ende // Am Ende größere Elemente als Pivot überspringen groesser: // Sprungzeile "groesser" falls daten[b] > pivot dann b := b - 1 GoTo groesser // Springe direkt zur Position Sprungzeile "groesser" ende // Wenn zutreffend, die Elemente "s" (kleiner) und "b" (größer) vertauschen falls daten[s] > pivot und daten[b] < pivot dann tausche daten[s] mit daten[b] s := s + 1 b := b - 1 GoTo kleiner // Springe direkt zur Position Sprungzeile "kleiner" ende // Die Suchposition darf sich nicht vor dem Bereich "kleiner als..." befinden falls x < s dann x := s ende wiederhole solange x < = b // Do , 2 x If-Then , x := x + 1 , Loop Until x > b // Nach kleineren Elementen als Pivot suchen falls daten[x] < pivot dann tausche daten[s] mit daten[x] s := s + 1 GoTo kleiner // Springe direkt zur Position Sprungzeile "kleiner" ende // Nach größeren Elementen als Pivot suchen falls daten[x] > pivot dann tausche daten[x] mit daten[b] b := b - 1 GoTo groesser // Springe direkt zur Position Sprungzeile "groesser" ende x := x + 1 ende // Wenn zutreffend, die Rekursion "kleiner als..." starten falls links < s - 1 dann starte funktion quicksort(links, s - 1) ende // Wenn zutreffend, die Rekursion "größer als..." starten falls b + 1 < rechts dann starte funktion quicksort(b + 1, rechts) ende ende -- 23:19, 18. Apr. 2022 (CEST)