Shearsort, Variante 2 (Alternative)

Hierbei handelt es sich um eine Abwandlung der Original-Variante, die Oetsort besser erkennen läßt.

Die Wurzel aus "r-l+1" muß ganzzahlig sein, damit die Laufzeitabschätzung (average case) zutrifft!

Eine rekursive Realisierung (Variante 2.b) ist möglich.

Variante 2.a (iterativ)
Typ standard
Eigenschaften iterativ, in-place, instabil, parallelisierbar
Datenstrukturen Felder
Speicher Ω(1) Θ(1) Ο(1)
Laufzeit (p) Ω(n1/2logn) Θ(n1/2logn) Ο(n)
Laufzeit Ω(n3/2logn) Θ(n3/2logn) Ο(n²)
Vergleiche n3/2logn/2 n3/2logn/2 n²/2
Vertauschungen n/4 n3/2logn/6 n²/2

shearsort(field A, int l, int r) {
  rows:= Round(Down, Math.sqrt(r-l+1));
  while (rows > 1) and (((r-l+1) mod rows) <> 0) do {
    rows--;
  }
  cols:= (r-l+1)/rows;

  for k:= Round(Up, log(rows)) downto 1 do {
    for i:= l to r step cols do parallel {
      oetsort(A, i, i+cols-1, cols, 1, ((((i-l)/cols) mod 2) = 0));
    }
    for i:= l to l+cols-1 do parallel {
      oetsort(A, l+i, r-l-cols+i+1, rows, cols, true);
    }
  }
  for i:= l to r step cols do parallel {
    oetsort(A, i, i+cols-1, cols, 1, true);
  }
}

oetsort(ifield A, int l, int r, int n, int gap, boolean asc) {
  for i:= 1 to n do {
    oet(A, l+(i mod 2)*gap, r, gap, asc);
  }
}

oet(ifield A, int l, int r, int gap, boolean asc) {
  for i:= l to r-gap step 2*gap do parallel {
    if ((A[i] > A[i+gap]) == asc) {
      exchange(A[i], A[i+gap]);
    }
  }
}


Shearsort, Variante 2