ALP I. Funktionale Programmierung

Transkript

1 ALP I Funktionale Programmierung Sortieren und Suchen (Teil 1) WS 2012/2013

2 Suchen 8 False unsortiert False sortiert

3 Suchen in unsortierten Listen search :: Integer -> [Integer] -> Bool search b [] = False search b (a:xs) (a/=b) = search b xs otherwise = True >>> search3 2 (take [1,3..]) False (1.51 secs, bytes) search :: Integer -> [Integer] -> Bool search b [] = False Probleme: >>> search 2 (take [1,3..]) False (2.24 secs, bytes) search b (a:xs) = (a==b) search b xs search 'a' "bla blue..." geht nicht! search :: a -> [a] -> Bool Probleme: search b [] = False search b (a:xs) = (a==b) search b xs No instance for (Eq a)... Probable fix: add (Eq a) to the type signature(s) for `search'...

4 Suchen in sortierten Listen Für alle Typen a, für denen eine Gleichheit-Operation definiert ist. search :: Eq a => a -> [a] -> Bool search b [] = False search b (a:x) = (a==b) search b x search :: Ord a => a -> [a] -> Bool search b [] = False search b (a:x) a<b = search b x a==b = True otherwise = False Für alle Typen a, für denen Vergleichsoperationen definiert sind. >>> search 2 (take [1,3..]) False (0.01 secs, bytes)

5 Suchen in sortierten Listen Binärsuche sortiert 8 8 < 7? 8 < 18? n n n 4 2 False nur 4 Schritte Gut für imperative Programmiersprachen!

6 Maximale Schrittanzahl mit Arrays n = 128 = = log 2 ( 128 ) = 2 6 = 2 5 = 2 4 Im schlimmsten Fall log 2 (n) Schritte 8 = = = = 2 0 Anzahl der Elemente , ,073,741,824 Lineare Suche Binäre Suche , ,073,741,824 30

7 Binärsuche binsearch :: (Ord a) => a -> [a] -> Bool binsearch b [] = False binsearch b [x] = b==x binsearch b xs b<mitte = binsearch b links b>mitte = binsearch b rechts b==mitte = True where half = (length xs) `div` 2 links = take half xs rechts = drop half xs mitte = head rechts

8

9

10

11

12

13

14

15 Sortierte Bereich

16 Sortierte Bereich

17 Sortierte Bereich

18 Sortierte Bereich

19

20 Größer als alle Elemente auf der linken Seite Es ist kein weiterer Vergleich notwendig

21 Kleiner als alle Elemente der linken Seite Schlimmster Fall

22 Alle Elemente müssen verschoben werden

23

24 isort :: (Ord a) => [ a ] -> [ a ] isort [] = [] isort (a:x) = ins a (isort x) where ins :: (Ord a) => a -> [a] -> [a] ins a [] = [a] ins a (b:y) a<= b = a:(b:y) otherwise = b: (ins a y)

25 Quick-Sort-Algorithmus Der Quicksort-Algorithmus (1962 von Hoare entwickelt) ist einer der beliebtesten Sortieralgorithmen, weil er sehr effizient und einfach zu implementieren ist. Grundidee: 1) Ein Element (Pivot) aus dem Array wird gewählt 2) Alle Zahlen des Arrays werden mit dem Pivot-Element verglichen und während des Vergleichsdurchlaufs in zwei Bereiche umorganisiert (Partitionierung). Der erste Bereich beinhaltet die Zahlen, die kleiner als das Pivot-Element sind und der zweite alle, die größer oder gleich sind. Am Ende des Durchlaufs wird das Pivot-Element in der Mitte beider Bereiche positioniert. 3) Nach jeder Partitionierung wird der Quicksort-Algorithmus rekursiv mit beiden Teilbereichen ausgeführt (solange die Teilbereiche mehr als ein Element beinhalten).

26 Quick-Sort-Algorithmus < < < < < < <

27 Quick-Sort-Algorithmus < < < < < < < Der Quicksort-Algorithmus funktioniert am besten, wenn die Teilbereiche fast gleich gross sind.

28 Quick-Sort-Algorithmus Im schlimmsten Fall! sind alle Elemente bereits sortiert

29 Quick-Sort-Algorithmus quicksort :: [Integer] -> [Integer] quicksort [] = [] quicksort (x:xs) = quicksort [ y y <- xs, y <= x ] ++ [x] ++ quicksort [ y y <- xs, y > x ] Das Problem in Haskell ist der Speicherverbrauch und die Komplexität der Verkettungsfunktion (++).

30 Quick-Sort-Algorithmus Quicksort-Algorithmus mit Hilfe der filter-funktion qsort :: (Ord a) => (a -> a -> Bool) -> [a] -> [a] qsort p [] = [] qsort p [x] = [x] qsort p (x:xs) = qsort p (filter (p x) xs) ++ [x] ++ qsort p (filter (np x) xs) where np x y = not (p x y)