Danke schonmal im voraus

Aber die Stackgröße kannst du dem Compiler übergeben, also nicht zur Laufzeit.

Grüße,

Martin

OT: *gruebel* gabs nichtmal irgendeinen Beweis, dass jede Rekusrion auch iterativ loesbar ist?

Ja, die allgemeine Lösung läuft darauf hinaus, den Callstack der rekursiven Aufrufe in den Algorithmus zu integrieren

@Tom: Was war denn das für ein Algorithmus?

OT: *gruebel* gabs nichtmal irgendeinen Beweis, dass jede Rekusrion auch iterativ loesbar ist?

Mag sein. Aber ich löse ehrlich gesagt rekursive Aufgaben besser rekursiv. Das geht Gehirnmäßig einfacher, als wenn man eine rekursive Aufgabe in iterativ umdenken muß.

Aber der Beweis würde mich schon interessieren, keine Frage.

Das war ein Algorithmus zur Berechnung einer convexen Hülle für eine Menge von Messwerten. Das Problem war folgender Code:

protected static void quicksort(int lo, int hi)
    {
        int i=lo, j=hi;
        Point q=p[(lo+hi)/2];
        while (i<=j)
        {
            while (p[i].isLess(q)) i++;
            while (q.isLess(p[j])) j--;
            if (i<=j) exchange(i++, j--);
        }
        if (lo<j) quicksort(lo, j);
        if (i<hi) quicksort(i, hi);
    }

Mir ist für diesen Fall leider keine Lösung mit einer Schleife eingefallen.
Und recursiver Code kommt nicht in Frage, weil die Anzahl der Messwerte nicht begrenzt ist. Können also auch viele Tausend sein.

mfg Tom

//Quicksort iterativ   (im Vergleich zur rekursiven Funktion ganz schön kompliziert)
procedure sortieren(var aa:array of real;von,bis:integer);
   var p,i,j:integer;
begin
  p:=bis;
  while p> 1 do Begin
    p:=p div 2;
    i:=von;
    repeat
      if aa[i+p]<aa[i] then BEgin
        tausche(aa[i],aa[i+p]);
        j:=i;
        while j-p>=von do BEGin
          if aa[j]<aa[j-p] then bEgin
             tausche(aa[j],aa[j-p]);
             j:=pred(j)
          eNd  else j:=0;
        END;
      ENd;
      i:=succ(i)
    until i+p>bis
  End;
end;

Ist in Delphi und einfach von hier kopiert, vielleicht gehts ja.. Aber du musst wirklich viele Datensätze haben, ich hatte bei Quicksort noch nie einen Stack-Überlauf

Nein Stop. So wie ich das sehe ist das nicht der quicksort zum auf- oder absteigenden sortieren von Zahlen. Dieser Code hier sortiert glaub irgendwie anders. Der Sortiert irgendwie die Werte relativ zu irgend einem anderen Wert.

Stimmt, das ist einfach quicksort im Sinne von Point::isLess() - was sich im Grunde aufs gleiche rauskommt. Im Klartext: Wo normalerweise ein "if (a < b)" steht, steht hier ein "if a.isLess(b)" - vom Sinn her ists genau das selbe wie Zahlen sortieren.