Quicksort Algo für Strings optimieren

[Union]

Und hier das überarbeitete durch kcx von Derek van Daal entwendete Meisterwerk...

Delphi-Quellcode:

procedure QuickSort(var Strings: TStringArray; Start, Stop: Integer);
var
  Left: Integer;
  Right: Integer;
  Mid: Integer;
  Pivot: string;
  //  Temp: string;
  PTemp : integer;
begin
  // Dieses repeat...
  repeat
     Left  := Start;
     Right := Stop;
     // Mid   := (Start + Stop) div 2;
     Mid   := (Start + Stop) shr 1;
     Pivot := Strings[mid];
     repeat
       while Strings[Left] < Pivot do Inc(Left);
       while Pivot < Strings[Right] do Dec(Right);
       if Left <= Right then
       begin
         // So wars vorher...
         // Temp           := Strings[Left];
         // Strings[Left]  := Strings[Right]; // Swops the two Strings
         // Strings[Right] := Temp;
         // Es stürzt nicht ab, aber ist das auch richtig? Na wenigstens 30x so schnell...
         PTemp := integer(Strings[Left]);
         integer(Strings[Left])  := integer(Strings[Right]);
         integer(Strings[Right]) := PTemp;
         Inc(Left);
         Dec(Right);
       end;
     until Left > Right;

     if Start < Right then
       QuickSort(Strings, Start, Right); // Uses Recursion
     Start := Left;
  // ... mit diesem Until verringert die Anzahl der Rekursiven Aufrufe. Aufrufe = Stack + Parameter + Push+Pop -> BÖSE
  until Left >= Stop;
end;

Neue Messreihe:

Code:

Original  77,163 0.969 us 74.756 ms
Shr 1     77,163 0.883 us 68.138 ms
repeat    49,152 1.287 us 63.280 ms
Swap int  49,152 0.787 us 38,663 ms

Swap Original 77,163 0.393 us 30.356 ms
Swap Integer  77,163 0,015 us  1.133 ms