Algorithmen und Datenstrukturen I

Transkript

1 Algorithmen und Datenstrukturen I Sortierverfahren D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg Winter 2009/10, 18. Januar 2010, c 2009/10 D.Rösner D. Rösner AuD I 2009/

2 Gliederung 1 Sortieren Selection sort Quicksort Insertion sort Merge sort Selection sort Insertion sort Mergesort Heapsort Tree sort D. Rösner AuD I 2009/

3 Sortieren Sortieren von Daten anhand von sog. Schlüsseln ist eine immmer wiederkehrende Aufgabe siehe z.b. folgende Meldung vom Nov. 2008: Google stellt neuen Sortier-Rekord auf Ein Petabyte in sechs Stunden sortiert Quelle: / / _ha_CZ.html?thes= D. Rösner AuD I 2009/

4 Sortieren Sortieraufgabe für die im folgenden behandelten Algorithmen: eine Liste von Schlüsseln soll gemäss einem Vergleichsoperator in aufsteigender Reihenfolge angeordnet werden m.a.w.: in Haskell müssen die Schlüssel zur Klasse Ord gehören Signatur: sort :: (Ord a) => [a] -> [a] D. Rösner AuD I 2009/

5 Sortieren durch Sortieren durch (engl. comparison-based sorting): nacheinander werden jeweils zwei Werte miteinander verglichen und ihre relative Position ggf. verändert grundsätzliches Prinzip der Algorithmen: zerlege die ursprüngliche Liste L in zwei Listen L1 und L2, sortiere diese rekursiv, dann füge die Resultate zusammen. vgl. [RL99], Ch. 6 D. Rösner AuD I 2009/

6 Sortieren durch Unterschiede zwischen Sortieralgorithmen betreffen den Aufwand für das Zerlegen der Liste (hard vs. easy split), die Grössenverhältnisse von L1 und L2 (singleton vs. equal size lists), den Aufwand für das Zusammenfügen der Listen L1 und L2 (hard vs. easy join) es gibt (leider) keine Algorithmen, bei denen gleichzeitig easy split und easy join vorliegt vgl. [RL99], Ch. 6 D. Rösner AuD I 2009/

7 Sortieren durch Auswahl Grundidee von Selection sort : extrahiere aus der ursprünglichen Liste den Schlüssel mit dem minimalen Wert füge diesen in die erste Position einer Resultatliste wiederhole dieses Vorgehen solange, bis die ursprüngliche Liste leer ist vgl. [RL99], Ch. 6 D. Rösner AuD I 2009/

8 Sortieren durch Auswahl Beispiel direkte Implementierung: ssort :: (Ord a) => [a] -> [a] ssort [] = [] ssort xs = m : ssort (delete m xs) where m = minimum xs Analyse: Aufwand für Split:... Verhältnis der Teillisten:... Aufwand für Join:... vgl. [RL99], Fig. 6.2 D. Rösner AuD I 2009/

9 Quicksort Sortieren Grundidee von Quicksort : nimm erstes Listenelement als sog. Pivotelement zerlege den Rest so in zwei Teillisten, dass die eine die Elemente enthält, die kleiner oder gleich dem Pivot, und die andere diejenigen, die grösser als der Pivot sind sortiere die Teillisten rekursiv füge die sortieren Teillisten mit dem Pivot wieder zusammen vgl. [RL99], Ch. 6 D. Rösner AuD I 2009/

10 Quicksort Sortieren Beispiel direkte Implementierung: qsort :: (Ord a) => [a] -> [a] qsort [] = [] qsort (pivot:rest) = qsort lower ++ [pivot] ++ qsort upper where lower = [ x x <- rest, x <= pivot] upper = [ x x <- rest, x > pivot] Analyse: Aufwand für Split:... Verhältnis der Teillisten:... Aufwand für Join:... vgl. [RL99], Fig. 6.3 D. Rösner AuD I 2009/

11 Sortieren durch Einfügen Grundidee von Insertion sort : nimm erstes Listenelement füge es an die richtige Position in den rekursiv sortierten Rest der Liste ein Alltagsbeispiel: sukzessives Einfügen von Spielkarten in eine sortierte Kartenhand vgl. [RL99], Ch. 6 D. Rösner AuD I 2009/

12 Sortieren durch Einfügen Beispiel direkte Implementierung: insert :: (Ord a) => a -> [a] -> [a] insert x xs = takewhile (<= x) xs ++ [x] ++ dropwhile (<= x) xs isort :: (Ord a) => [a] -> [a] isort [] = [] isort (x:xs) = insert x (isort xs) Analyse: Aufwand für Split:... Verhältnis der Teillisten:... Aufwand für Join:... vgl. [RL99], Fig. 6.4 D. Rösner AuD I 2009/

13 Sortieren durch Zusammenfügen Grundidee von Mergesort : teile die ursprüngliche Liste in zwei Hälften sortiere diese rekursiv füge die sortierten Hälften wieder zusammen vgl. [RL99], Ch. 6 D. Rösner AuD I 2009/

14 Sortieren durch Zusammenfügen Beispiel direkte Implementierung: msort :: (Ord a) => [a] -> [a] msort [] = [] msort [x] = [x] msort l = merge (msort l1)(msort l2) where l1 = (take k l ) l2 = (drop k l) k = (length l) div 2 vgl. [RL99], Fig. 6.5 D. Rösner AuD I 2009/

15 Sortieren durch Zusammenfügen Beispiel Fortsetzung direkte Implementierung: Hilfsfunktion merge zum ordnungserhaltenden Zusammenfügen zweier bereits sortierter Listen merge :: (Ord a) => [a] -> [a] -> [a] merge [] b = b merge a [] = a merge a@(x:xs) b@(y:ys) (x<=y) = x : (merge xs b) otherwise = y : (merge a ys) vgl. [RL99], Fig. 6.5 D. Rösner AuD I 2009/

16 Sortieren durch Zusammenfügen Analyse: Aufwand für Split:... Verhältnis der Teillisten:... Aufwand für Join:... vgl. [RL99], Fig. 6.5 D. Rösner AuD I 2009/

17 Sortieren durch Auswählen Nachteil der direkten Implementierung: ssort :: (Ord a) => [a] -> [a] ssort [] = [] ssort xs = m : ssort (delete m xs) where m = minimum xs die ursprüngliche Liste wird zweimal traversiert: einmal zur Bestimmung des Minimums (mit minimum), dann erneut zur Entfernung (des ersten Vorkommens) des Minimums (mit delete) vgl. [RL99], Fig. 6.2 D. Rösner AuD I 2009/

18 Sortieren durch Auswählen Vorgehen: die folgende Variante vermeidet zweifaches Traversieren: die Bestimmung des Minimums und die Bestimmung der Restliste erfolgen gleichzeitig Hilfsfunktion split: split :: (Ord a) => [a] -> a -> [a] -> [a] split [] m r = m : (ssort r) split (x:xs) m r = if x < m then split xs x (m:r) else split xs m (x:r) damit: ssort [] = [] ssort (x:xs) = split xs x [] vgl. [RL99], D. Rösner AuD I 2009/

19 Sortieren durch Einfügen implementiert als Zusammenspiel mit Hilfsfunktion insert, die ein Element an die richtige Stelle in einer sortierten Liste platziert insert x xs = takewhile (<= x) xs ++ [x] ++ dropwhile (<= x) xs isort [] = [] isort (x:xs) = insert x (isort xs) alternativ dargestellt: isort xs = foldr insert [] xs D. Rösner AuD I 2009/

20 Sortieren durch Einfügen Nachteil der obigen Implementierung von insert: die unabhängige Verwendung von takewhile und dropwhile führt zu zwei Listentraversierungen die folgende Variante, bei der das Ergebnis von insert akkumulierend gewonnen wird, vermeidet diesen Aufwand: insert key [] = [key] insert key l@(x:xs) key <= x = key : l otherwise = x : (insert key xs) isort xs = foldr insert [] xs D. Rösner AuD I 2009/

21 Sortieren durch Zusammenfügen aufgrund der rekursiven Definitionen (s.o.) zerlegt Mergesort eine Liste der Länge n zunächst in zwei Listen der Länge n/2, dann diese in vier Listen der Länge n/4, usw. bis n Listen der Länge 1 vorliegen. Erst dann beginnt das Zusammenfügen mit merge. vgl. [RL99], D. Rösner AuD I 2009/

22 Sortieren durch Zusammenfügen Die Variante bottom-up mergesort startet mit n Listen der Länge 1, die dann rekursiv jeweils paarweise zusammengefügt werden. Für das Aufteilen werden dann auch nicht mehr take und drop benötigt. vgl. [RL99], D. Rösner AuD I 2009/

23 Sortieren: bottom-up mergesort der Haskell-Code für bottom-up mergesort Hilfsfunktion split: aus Liste wird Liste mit einelementigen Listen mit den ursprünglichen Elementen split :: (Ord a) => [a] -> [[a]] split [] = [] split (x:xs) = [x] : split xs Variante mit map:... D. Rösner AuD I 2009/

24 Sortieren: bottom-up mergesort Haskell-Code für bottom-up mergesort (cont.) mergepairs :: (Ord a) => [[a]] -> [[a]] mergepairs [] = [] mergepairs x@[l] = x mergepairs (l1:l2:rest) = (merge l1 l2) : (mergepairs rest) D. Rösner AuD I 2009/

25 Sortieren: bottom-up mergesort der Haskell-Code für bottom-up mergesort (cont.) msort :: (Ord a) => [a] -> [a] msort l = ms (split l) where ms [r] = r ms l = ms (mergepairs l) D. Rösner AuD I 2009/

26 Baumbasierte Sortierverfahren verwenden Bäume zum optimierten Zugriff im folgenden betrachtet: Heapsort (vgl. [RL99], 6.4.1) Tree sort (vgl. [RL99], 6.4.2) D. Rösner AuD I 2009/

27 Heapsort Sortieren Vorgehen: die Elemente der unsortierten Ausgangsliste werden nacheinander in eine (als Heap implementierte) Prioritätswarteschlange eingefügt, dann wird solange, bis die Warteschlange leer, wiederholt das jeweils kleinste Element entnommen und in die (damit dann sortierte) Ergebnisliste eingefügt Heapsort kann als Optimierung von Selection sort angesehen werden, denn das jeweils kleinste Element ist mit konstantem Aufwand erreichbar D. Rösner AuD I 2009/

28 Heapsort Sortieren Haskell-Implementierung (vgl. [RL99], 6.4.1): Hilfsfunktion zum Aufbau der Prioritätswarteschlange mkpq :: (Ord a) => [a] -> PQueue a mkpq xs = foldr enpq emptypq xs hsort :: (Ord a) => [a] -> [a] hsort xs = hsort (mkpq xs) where hsort pq (pqempty pq) = [] otherwise = (frontpq pq):(hsort (depq pq)) D. Rösner AuD I 2009/

29 Tree sort Sortieren Vorgehen (vgl. [RL99], 6.4.2): aus einer unsortierten Liste wird ein binärer Suchbaum aufgebaut dieser liefert bei einer Inorder-Traversierung die Elemente dann in der korrekten Ordnung zurück D. Rösner AuD I 2009/

30 Tree sort Sortieren die Implementierung ist mit den bereits vorhandenen Sprachmitteln für binäre Suchbäume sehr einfach: tsort xs = (inorder. buildtree) xs Tree sort kann als Optimierung von Insertion sort angesehen werden denn im Mittel ist der Aufwand für das Einfügen eines Elements in einen binären Suchbaum nur O(log n) statt O(n) wie beim Einfügen in eine Liste D. Rösner AuD I 2009/

31 Literatur: I Sortieren Fethi Rabhi and Guy Lapalme. Algorithms A Functional Programming Approach. Pearson Education Ltd., Essex, nd edition, ISBN D. Rösner AuD I 2009/