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:

repeat
  getauscht := false;
  for i := 1 to Length(Teams)-2 do begin
    Tore1 := Teams[i].Tore.Tore_geschossen - Teams[i].Tore.Tore_kassiert;
    Tore2 := Teams[i+1].Tore.Tore_geschossen - Teams[i+1].Tore.Tore_kassiert;
    if Teams[i].Punkte < Teams[i+1].Punkte then begin
      TeamTemp := Teams[i];
      Teams[i] := Teams[i+1];
      Teams[i+1] := TeamTemp;
      getauscht := true;
    end;
    if (Teams[i].Punkte = Teams[i+1].Punkte) and (Tore1 < Tore2) then begin
      TeamTemp := Teams[i];
      Teams[i] := Teams[i+1];
      Teams[i+1] := TeamTemp;
      getauscht := true;
    end;
    if (Teams[i].Punkte = Teams[i+1].Punkte) and (Tore1 = Tore2) and (Teams[i].Tore.Tore_geschossen < Teams[i+1].Tore.Tore_geschossen) then begin;
      TeamTemp := Teams[i];
      Teams[i] := Teams[i+1];
      Teams[i+1] := TeamTemp;
      getauscht := true;
    end;
  end;
  until getauscht = false;					

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:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:

function ElementBigger(a, b: Integer): Boolean;
begin
  if fDescending then
    Result := a < b
  else
    Result := a > b;
end;

function ElementSmaller(a, b: Integer): Boolean;
begin
  if fDescending then
    Result := a > b
  else
    Result := a < b;
end;

procedure DoQuickSort(RangeFrom, RangeTo: Integer);
// es wird der Bereich übergeben, in dem gerade sortiert wird
var
  i, j, MiddleElement, tmp: Integer;
begin
  Inc(CurrentIteration);
    // Anzahl der Aufrufe zählen, also Zahl um eins erhöhen
  i := RangeFrom;
  j := RangeTo;
    // Startwerte für i und j, wir gehen ja von beiden Seiten bis zu der Stelle
    // wo unser Teil des Arrays wieder geteilt wird. Und zwar von dem Rändern
    // des Bereichs aus.
  MiddleElement := fData^[(i + j) div 2];
    // Da fData nur ein Pointer auf das Array ist, müssen wir diesen vorher
    // dereferenzieren, das heißt auf das Array selbst zugreifen. Das macht ^.

    // Der Einfacheit halber nehmen wir einfach das Element in der Mitte des zu
    // sortierenden Bereichs.
    // Besser wäre es theoretisch den Median zu nehmen, also das Element, das
    // nach Überprüfung aller Elemente in die Mitte gehört. Dies würde die
    // Komplexitätsklasse zwar nicht verändern, QuickSort wäre aber um einen
    // konstanten Faktor langsamer als andere Methoden.

  while (i <= j) and not Terminated do
  begin
//    while fData^[i] < MiddleElement do
    while ElementSmaller(fData^[i], MiddleElement) do
    begin
      Inc(i);
      // Wir suchen das erste Element von links aus, das größer oder gleich dem
      // mittleren Element ist.
      Inc(CurrentCompareOps);
    end;
//    while fData^[j] > MiddleElement do
    while ElementBigger(fData^[j], MiddleElement) do
    begin
      Dec(j);
      // Wir suchen das erste Element von rechts aus, das kleiner oder gleich
      // dem mittleren Element ist.
      Inc(CurrentCompareOps);
    end;

    // An dieser Stelle haben wir zwei Elemente i und j (die auch beide das
    // mittlere Element sein können!), wobei gilt
    // Element i >= mittleres Element <= Element j
    // Auf der linken Seite des mittleren Elements darf aber kein Element
    // stehen, das größer ist als dieses und auf der rechten keins, das kleiner
    // ist. Also vertauschen wir. Damit, dass wir >= statt > nehmen, das
    // mittlere Element also einbeziehen, funktioniert das ganze auch, wenn wir
    // nur noch auf einer Seite ein falsches Element finden.

    // Wir haben also am Ende ein i und ein j, die die Grenze der zwei Teile des
    // Arrays angeben, wobei links von j (einschließlich) nur Zahlen kleiner
    // oder gleich des mittleren Elements stehen und rechts von i
    // (einschließlich) nur solche, die größer oder gleich sind.

    if i <= j then
      // Wenn unser i jetzt noch links von j liegt müssen die beiden Elemente
      // vertauscht werden, weil diese noch falsch plaziert sind.
      // Wenn kein Element mehr an der falschen Stelle wäre, dann würden
      // i und j auf das mittlere Element zeigen.
      // Dieser Fall ist hier eingeschlossen, damit i und j noch um eins
      // vergrößert bzw. verkleinert werden.
      // j soll ja das Ende des linken Teils angeben und i den Anfang des
      // rechten Teils.
    begin
      Inc(CurrentOperation);
      tmp := fData^[i];
      fData^[i] := fData^[j];
      fData^[j] := tmp;
      Inc(i);
      Dec(j);
    end;
  end;

  if RangeFrom < j then
    DoQuickSort(RangeFrom, j);
    // wenn jetzt j rechts neben dem linken Rand des Sortierbereichs liegt,
    // dann sind da also noch mindestens 2 Elemente zum Sortieren da.
    // Also nochmal rekursiv DoQuickSort mit diesem Bereich aufrufen.
  if i < RangeTo then
    DoQuickSort(i, RangeTo);
    // genauso, nur mit i und dem rechten Teil
end;

procedure StartSort;
begin
  if Length(fData^) > 0 then
    DoQuickSort(0, Length(fData^));
      // QuickSort aufrufen
end;