Sorteeralgoritmen

Sorteren: aanpak 1 Hoe ga je een rij getallen sorteren met PC? Sorteren door selectie (= selection sort): Zoek de kleinste waarde Sorteer de andere waarden Voeg de kleinste waarde vooraan toe Sorteren door selectie kan recursief geïmplementeerd worden

Selection sort: implementatie 1 to ssort :list if emptyp :list [output [] ] localmake “smallest reduce “min : list output fput : smallest (ssort remove.once :smallest :list) end

Selection sort: implementatie 1 to remove.once : item :list if equalp :item first :list [output butfirst :list] output fput first :list (remove.once :item butfirst :list) end

Sorteren door selectie Probleem: je gaat 2 x door de lijst per oproep 1: om kleinste getal te vinden 2: om dit getal te verwijderen uit de lijst. In de recursieve oproep maak je gebruik van de nieuwe lijst.

Selection sort: implementatie 2 to ssort :list if emptyp : list [output [] ] output ssort1 (first :list) (butfirst :list) [] end

Selection sort: implementatie 2 to ssort1 :min : in :out if emptyp :in [output fput :min ssort :out] if lessthanp :min (first :in) ~ [output ssort1 :min (butfirst :in) (fput first :in out)] output ssort1 (first :in) (butfirst :in) (fput :min : out) end

Sorteren door selectie Stel: rij van 100 getallen Aantal nodige vergelijkingen stap 1: 99 stap 2: 98 …  Totaal : 4950 Voor rij van n getallen: (n – 1 ) * n / 2

Sorteren door invoegen Algoritme: Neem bvb het eerste getal van de rij Sorteer de overige waarden van de rij Plaats het gekozen getal op de juiste plaats Aantal vergelijkingen voor rij van lengte n: Hangt af van de input data Minimum: n – 1 (gesorteerde rij) Maximum: n * (n – 1) / 2 (omgekeerd gesorteerde rij)

Sorteren: aanpak 2 Hoe ga je 100 pagina’s op juiste volgorde steken? Rij van lengte 100: Opsplitsen in 2 groepen van ca. 50 getallen Sorteren via selectie 2 * 1225 = 2450 => Beter! Beter: Niet één keer, maar meerdere keren opsplitsen

Partition Sort: algoritme Bepaal een waarde die ca. mediaan is voor rij (= de rij in ca. gelijke helften deelt) Verdeel de input in een “kleine waarde” – en een “grote waarde” – helft Sorteer elk van beide helften Plaats de gesorteerde “kleine waarde” – helft voor de gesorteerde “grote waarde” – helft

Partition sort: implementatie 1 to psort :list if (count :list) < 2 [output : list] localmake “split guess.middle.value :list output sentence psort filter [? < :split] :list psort filter [not (? < :split)] :list end to guess.middle.value :list output ((first :list) + (last :list)) / 2 end

Partition sort: optimalisatie We willen het aantal vergelijkingen minimaliseren Waarde om rij in 2 groepen te delen (= “splitswaarde” ) is belangrijk Gemiddelde van eerste en laatste getal: [ ] geeft probleem Gemiddelde van alle getallen: [ ] geeft probleem Niet 2 keer door de input rij gaan

Partition sort: implementatie2 to psort :list if emptyp :list [output [] ] if emptyp butfirst :list [output :list] localmake “split ((first :list) + (last :list))/2 output psort1 :split :list [] [] end

Partition sort: implementatie 2 to psort1 :split :in :low :high if emptyp :in [output sentence (psort :low) (psort : high)] if lessthanp first :in : split ~ [output psort1 : split (butfirst :in) (fput first :in :low) :high] output psort1 :split (butfirst :in) :low (fput first :in :high) end

Partition Sort Stel als invoer: [ ] of [ ] => Problemen als eerste getal = laatste getal: Voorgaande algoritme niet zeker eindig => keuze van “splitswaarde” aanpassen Lijst overlopen op zoek naar eerste waarde die verschilt => eventueel veel extra vergelijkingen if equalp first :list last :list [ …]

Partition sort: aanpassing Rij splitsen in 3 “emmers” (laag, hoog, gelijk) De emmer “gelijk” moet je niet meer verder sorteren if lessthanp first :in :split […] if equaltop first :in :split […] => 2 bewerkingen nodig per vergelijking

Partition sort: implementatie 3 to psort :list if emptyp :list [output [] ] if emptyp butfirst :list [output :list] localmake “split ((first :list) + (last :list))/2 if lessthanp first :list :split ~ [output psort1 :split (butfirst :list) (list first :list) [] ] output psort1 :split (butlast :list) (list last :list) [] end

Partition sort: aantal vergelijkingen A. In beste geval: 1ste stap: 100 getallen verdelen over 2 emmers => 100 getallen vergelijken met splitswaarde 2de stap: ca. 2 (= voor elke emmer) * (50 getallen verdelen over 2 emmers) => ca. 100 getallen vergelijken met splitswaarde Elke stap: ca. 100 vergelijkingen Totaal: 100 * # keer

Partition sort: aantal vergelijkingen # keer is in beste geval = ²log n Totaal = n * ²log n B. In slechtste geval: Aantal nodige vergelijkingen stap 1: 100 stap 2: 99 stap 3: 98  totaal: ca. 5000

Mergesort Algoritme Verdeel de invoer willekeurig in 2 helften van gelijke grootte Sorteer elk van de beide helften afzonderlijk Voeg de 2 helften samen door de waarden te vergelijken Voordeel: We weten zeker dat de beide helften even groot zijn