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

I,j,k,hilfe:longint;
Anzahl: integer;
begin
  k:=1;
repeat
  k:=3*k+1
until k>anzahl;
 repeat
   k:=k div 3;
for i:=k+1 to anzahl do begin
  hilfe:=h[i];
  j:=i;
while (h[j-k]>hilfe) and (j>k) do begin
  h[j]:=h[j-k];
  dec(j,k);
end;
  h[j]:=hilfe;
end;
 until k=1;					

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:

procedure ShellSort(var h: array of integer);
var
   anzahl,
   k,i,j,hilfe: integer;
begin
   { Shellsort basiert darauf, dass man sich eine 2 dimensionale Matrix zu Hilfe
     nimmt und diese dann mit den Werten füllt.
     Um sich allerdings nicht mit der lästigen Erstellung einer Matrix zu be-
     schäftigen, baut man sich nen Wert, mit dem man quasi von einer Spalte
     zur nächsten springen kann... }

   // die länge des arrays ermitteln
   anzahl := length(h);

   k := 1;
   repeat           // mit diesem "repeat until" lässt sich ermitteln, wie viele elemente eine
      k := 3*k+1;   // spalte der matrix beinhaltet. wird nachher gebraucht, um in der for -
   until k>anzahl;  // schleife die korrekte anzahl elemente zu vergleichen.

   repeat
      // die Spaltenbreite "ermitteln", indem der Spaltensprung immer kleiner wird
      // und am Ende aufeinanderfolgende Werte verglichen werden.
      // Dies wird benötigt, da es sich im Prinzip um einen Insertion-Sort
      // handelt, allerdings wird beim Shell-Sort noch das Feld vorsortiert,
      // wodurch der Insertion-Sort beschleunigt wird.
      k:=(k div 3);

      // jetzt
      for i:=k to anzahl do begin
         hilfe:=h[i]; // in einer hilfsvariablen wird der aktuelle wert
                      // gespeichert, den wir vergleichen wollen
                      
         j:=i;        // und jetzt noch den richtigen index nehmen
                      // hier ne "hilfsvariable", damit nicht auf die
                      // schleifen-variable zugegriffen wird, wodurch die
                      // schleife selbst "beeinträchtig" werden könnte ->
                      // falsche ergebnisse

         while (h[j-k]>hilfe) and (j>(k-1)) do begin
            // hier wird zuerst geprüft, ob der in der spalte vorhergehende
            // wert größer ist als der in "hilfe" stehende wert.
            // anschließend wird noch geprüft, ob man bereits an der Spitze
            // der Spalte angekommen ist -> weiter oben gibt's aber keine
            // werte mehr zu holen

            h[j]:=h[j-k]; // jetzt wird der Wert ersetzt.

            dec(j,k); // und zu guter letzt müssen wir j noch so verändern,
                      // damit wir im nächst-höheren element in der gerade
                      // aktiven spalte stehen. 
         end;

         h[j]:=hilfe; // und den wert wieder zurückschreiben.
      end;
   until k = 1;
end;