1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

procedure TForm1.SortierenClick(Sender: TObject);
var i, j, k, p, pivot, temp: integer; //zus. arr, ar1, ar2: arrays of integer; global definiert
begin

    p:=high(arr)-1;
    pivot:=arr[p];


    for j:=low(arr) to (pivot-1) do begin        //ar1 definieren
      setlength(ar1,((pivot-1)-(low(arr))));
      for i:=low(arr) to high(arr) do begin
        if arr[i]<pivot then begin
          ar1[j]:=arr[i];
          listbox2.items.Add(inttostr(ar1[j]));
        end;
      end;
    end;


    for k:=pivot to (high(arr)) do begin         //ar2 definieren
      setlength(ar2, ((high(arr)-pivot)));
      for i:=low(arr) to high(arr) do begin
        if arr[i]>=pivot then begin
          ar2[k]:=arr[i];
          listbox3.items.Add(inttostr(ar2[k]));
        end;
      end;


end;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

procedure QuickSort(Links,Rechts: Integer);
var
  Pivot,i,j,temp: Integer;
begin
  Pivot := (Links + Rechts) div 2;
  Pivot := F[Pivot];
  i := Links;
  j := Rechts;
  repeat
    while (F[i] < Pivot) do
      Inc(i);
    while (Pivot < F[j]) do
      Dec(j);
    if (i <= j) then begin
      temp := F[i];
      F[i] := F[j];
      F[j] := temp;
      Inc(i);
      Dec(j);
    end;
  until (i > j);
  if (links < j) then
    QuickSort (Links,j);
  if (i < Rechts) then
    QuickSort (i,Rechts);
end;					

1:
2:
3:
4:
5:
6:
7:

    pivot:=arr[p]; // nehmen wir an, arr[p] enthält 1000, also ist pivot = 1000
 
    for j:=low(arr) to (pivot-1) do begin // damit läuft die Schleife bis 999
      setlength(ar1,((pivot-1)-(low(arr))));  
      for i:=low(arr) to high(arr) do begin  
        if arr[i]<pivot then begin  
          ar1[j]:=arr[i]; // wenn ar1 weniger als 999 Elemente hat, dann knallt´s hier!					

1:
2:
3:

pivot := arr[2]; // jetzt ist pivot = 42
for j := low(arr] to (pivot-1) do // die Schleife läuft bis 41
  arr[j] := egal; // hier knallt´s, weil das array nur 5 Elemente hat!					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

vorn := 0; 
hinten := n-2;  
pivot := arr[n-1];

repeat
  while (arr[vorn] <= pivot) AND (vorn < n-1) do inc(vorn);
  while (arr[hinten] >= pivot) AND (hinten > vorn) do dec(hinten);

  if hinten > vorn then
    //die Funktion tausche muss man sich selbst bauen, das sind drei Zeilen
    tausche(arr[vorn], arr[hinten])
until vorn > hinten
// jetzt das Pivot-element arr[n-1] in die Mitte tauschen
// hier kommts recht genau auf den Index an, wahrscheinlich vertu ich mich um +/- 1/2
tausche(arr[pivot], arr[hinten] {+-1?} )					

1:
2:

MeinQicksort(arr, 0, vorn {+-1?});
MeinQuicksort(arr, vorn {+-1?}, n-1);					

1:
2:
3:
4:
5:
6:

procedure MeinQuicksort(arr: Array of Integer; linkeGrenze, rechteGrenze: integer);
begin
  vorn := linkeGrenze; 
  hinten := rechteGrenze - 1;  
  pivot := arr[rechteGrenze];
  // weiter wie oben					

1:

MeinQuicksort(arr, 0, high(arr));