Quicksort Abbruchbedingung ?

[Siro]

Ich habe mein Problem gefunden. Habe es selbst verursacht weil ich komplett mit unsigned Werten U16 gearbeitet habe.
Das geht hier schief. Ich muss Signed bzw. "int" benutzen. hab ich in Pascal ja auch getan.
Der Wert "right" landete bei -1 (also 65535) und dann ging natürlich die Abfrage falsch.
oder ich schreibe hinter der left++ Zeile, im unterem Abschnitt if (right) right--; dann geht es auch mit unsigned Werten.
Hier noch mal die korrigierte Version:

U16 ar[5] = {5,4,3,2,1};

void QSort(U16 lo, U16 hi)
{ U16 left,right,mid,tmp;
  left  = lo; 
  right = hi;
  mid   = ar[(lo+hi)/2];
  do 
  {    
     while (ar[left]  < mid) left++; 
     while (ar[right] > mid) right--;
     if (left <= right)
     {
       tmp       = ar[left];
       ar[left]  = ar[right];
       ar[right] = tmp;
       left++; 
       if (right) right--;
     }
  } while (left <= right);
  if (right > lo) QSort(lo,   right);
  if (left  < hi) QSort(left, hi);
}


int main(void)
{ 
  QSort(0,sizeof(ar) / sizeof(ar[0]) -1);
}

Ich glaub jetzt hab ich alle Probleme gelöst, wird ja auch Zeit fürs Wochenende.
Siro

[SprinterSB]

Hi Siro. Es gibt ein qsort in der avr-libc. Warum also das Rad neu erfinden?

[lokirobotics]

Hi Siro. Es gibt ein qsort in der avr-libc. Warum also das Rad neu erfinden?

Weil es so gut wie alles, was es hier gemacht wird, schon fertig gibt. Wozu also überhaupt noch was selber machen?
Ich find solche Kommentare in einem Forum wie diesen mehr als sinnlos.

Siro will wahrscheinlich was lernen und das tut man nicht, wenn man Fertigkomponenten benutzt.

[Felix G]

Es gibt fast alles schon irgendwo fertig, das stimmt...

Aber qsort gibt es nicht einfach nur irgendwo, sondern es ist Teil der C-Standardbibliothek, was vielen nicht bewusst ist. Von deinem Standpunkt aus betrachtet müsste man also auch z.B. die Existenz von Funktionen wie sprintf "geheimhalten", weil es ja sein könte, daß das Jemand lieber selber implementieren möchte um etwas dabei zu lernen.


Ich denke es sollte Jedem selbst überlassen sein, ob er Fertigkomponenten nutzen, oder lieber etwas eigenes implementieren möchte.

[lokirobotics]

Du hast meinen Standpunkt missverstanden! Dein letzter Absatz ist genau das, was ich meinte. Jeder sollte seine Projekte so umsetzen, wie er möchte.
Man muss auch nichts geheimhalten. Ich kann ja auch eine fremde Implementierung als Grundlage für eine Eigene nehmen.
Ich find halt diese "Warum das Rad neu erfinden"-Aussagen schwachsinnig.

Jaa, mein letzter Satz ist etwas übertrieben gewesen, natürlich lernt man auch, wenn man Fertigkomponenten einsetzt. Mir ging es in dem Fall nur darum, dass man die Funktionsweise des QSort nicht sehr gut mitbekommt, wenn man nur nen Aufruf einer fertigen Funktion tätigt. War etwas missverständlich geschrieben, stimmt.

MfG

[Siro]

zu SprinterSB
ich wuste das nicht, daß es die funktion in der standard lib gibt.
unabhängig davon wollte ich sie aber selbst implementieren.

zu Felix G
gut erkannt, ich benutze z.B. auch KEIN printf, habe mir was eigenes geschrieben, da mir der Source Code nicht zur Verfügung steht und die mitgelieferte LIB wesentlich zu viel Speicher dafür "verbrät".....

Klar gibt es fertige Algo-"Rhythmen". Lernen und Verständnis steht bei mir aber im Vordergrund.
Wenn es alles schon fertig gibt, bräuchte ich meine Software erst garnicht schreiben, die gibt es sicher auch schon Spass muss sein.

Durch die eigene Implementierung (Grundlage war aber "abgeguckt") hab ich die Vorgehensweise von QSort tatsächlich verstanden. Hat zwar einen Tag gedauert aber es hat sich gelohnt. Ich hab mir mal den Aufruf der Standardfunktion QSort angesehen. Die Idee ist eigentlich nicht schlecht. Hier muss man also eine eigene Funktion schreiben, welche 2 Werte (oder was auch immer) vergleicht und das Resultat zurück liefert. Der eigentlich Sortieralgo. ist damit universell. Ist echt zu überlegen, ob ich das nicht auch gleich so mache.

Danke Euch für die Infos.
Siro

[Felix G]

Hier muss man also eine eigene Funktion schreiben, welche 2 Werte (oder was auch immer) vergleicht und das Resultat zurück liefert. Der eigentlich Sortieralgo. ist damit universell. Ist echt zu überlegen, ob ich das nicht auch gleich so mache.

Das ist durchaus ein großer Vorteil dieser Implementierung, allerdings geht das natürlich auf Kosten der Typsicherheit, denn da die Parameter der Vergleichsfunktion void* sein müssen, sind keinerlei Typprüfungen durch den Compiler möglich (normalerweise ist das aber kein Problem, man muss eben selbst ein bischen besser aufpassen).

Außerdem ist die Performance natürlich etwas schlechter als bei einer auf einen bestimmten Typ zugeschnittenen Implementierung, dieser Unterschied ist aber sehr gering und spielt üblicherweise erst bei größeren Datenmengen eine Rolle.