Algorithmen und Datenstrukturen Kapitel 1 Algorithmen & Algorithmenanalyse

Transkript

1 Algorithmen und Datenstrukturen Kapitel 1 Algorithmen & Frank Heitmann [email protected] 14. Oktober 2015 Frank Heitmann [email protected] 1/48

2 Der Sprung ins Wasser... Worum geht es bei Algorithmen und Datenstrukturen? Frank Heitmann 2/48

3 Und warum brauch ich das?! Was nützt das? Spaß! Grob abschätzen, ob etwas überhaupt möglich ist. Grob abschätzen, wie teuer etwas wird/werden kann. Lösungsvorschläge und deren Kosten verstehen. Lösungen selbst erarbeiten können! Abstrahieren! Frank Heitmann 3/48

4 Organisatorisches 1 Zur Vorlesung: Immer Mittwochs in Hörsaal A Chemie Vorlesung mit Lecture2Go-Aufzeichnung Pause Wiederholung, Übung, Vertiefung,... Boxen für besonders Wichtiges / für Interessierte Das Buch zur Vorlesung: Cormen et al. Introduction to Algorithms, McGraw-Hill. Oder jedes andere Algorithmen-Buch (+Folien) Frank Heitmann [email protected] 4/48

5 Organisatorisches 2 Zu den Übungsgruppen und Übungszetteln: Beginn diesen Mittwoch. Einige Besonderheiten: Gruppe 01 und 04 am ZBH in Raum 16 Gruppe 03 startet erst um 1240 Uhr (bis 1410) Gruppe 04 startet um 1400 Uhr (bis 1530) Neuen Aufgabenzettel alle zwei Wochen i.a. Mo-Mi Bearbeiten in 2er- oder 3er-Gruppen. Abgabe ca. zwei Wochen später am Montag bis 16 Uhr in die Abgabebox im 1. Stock von Haus C (vor C-201). Besprechung in den Übungen in der Woche. Alle Gruppenmitglieder müssen den eigenen Lösungsvorschlag präsentieren können. 50% der Punkte aller Zettel sind nötig. Frank Heitmann [email protected] 5/48

6 Motivation Los... Frank Heitmann 6/48

7 Motivation Begriff: Datentyp & Datenstruktur Definition Ein Datentyp ist eine Menge von Werten (z.b. N) und Operationen darauf (z.b. +). Definition Bei einer Datenstruktur sind die Daten zusätzlich in bestimmter Weise angeordnet und in bestimmter Weise wird Zugriff und Verwaltung ermöglicht. (Beispiele: Array, Liste, Stack, Graph) Bemerkung Abstrakte Definition/Beschreibung/Darstellung erfolgt mittels Abstrakter Datentypen/Datenstrukturen (ADT). Dabei ist die Signatur die algebraische Spezifikation des Datentyps. Die Algebra wird als Datentyp zur Signatur bezeichnet. Frank Heitmann 7/48

8 Ein Problem... Motivation Folgendes Problem: Gegeben sei eine (lange) Liste mit Namen. Wir wollen herausfinden ob Max Mustermann auf der Liste steht. Wie machen wir das? Wie machen wir das algorithmisch? Und was ist noch mal ein Algorithmus? Frank Heitmann 8/48

9 Begriff: Algorithmus Motivation Definition Ein Algorithmus ist ein endlich und präsize beschriebenes Verfahren, das Eingabewerte in Ausgabewerte umwandelt. Es ist (i.a.) deterministisch und der Ausgang ist determiniert. Die einzelnen Schritte sind zudem elementar/atomar und effektiv ausführbar. Meist wird noch die Termination sowie die Korrektheit des Verfahrens verlangt (beides muss bewiesen werden!). I.A. soll ein Algorithmus ein Problem lösen. Eine Instanz ist dabei eine mögliche Eingabe (bspw. zwei Zahlen, die addiert werden sollen). Bemerkung Wir benutzen nachfolgend übliche Pseudocode-Bausteine und Konventionen. (for, while, Zuweisung, if-then, case,...) Frank Heitmann 9/48

10 ... eine Lösung Motivation Algorithmus 1 Lineare Suche 1: for i = 0 to n do 2: if a[i] == max mustermann then 3: return true 4: end if 5: end for 6: return false Ist diese Lösung gut? Geht das besser? Frank Heitmann [email protected] 10/48

11 und eine andere Lösung Motivation Algorithmus 2 Binäre Suche 1: while first last idx < 0 do 2: m = first + ((last first)/2) 3: if a[m] < p then 4: first = m + 1 5: else if a[m] > p then 6: last = m 1 7: else 8: idx = m 9: end if 10: end while 11: return idx Ist das besser? Welche Voraussetzungen haben wir hier? Frank Heitmann [email protected] 11/48

12 Sortieren Motivation Definition (Das Sortierproblem) Eingabe: Eine Sequenz < a 1, a 2,..., a n > von n Zahlen. Gesucht: Eine Permutation < a 1, a 2,..., a n > der Eingabesequenz mit a 1 a 2... a n. Anmerkung Ob die Reihenfolge zweier Elemente a i, a j (i < j) mit a i = a j beibehalten werden soll oder nicht, ist nicht gesagt. Bleibt sie erhalten, d.h. ist a p = a i, a q = a j und p < q, so nennt man das Verfahren stabil. Ferner heißt ein Sortierverfahren in-place (oder in situ), wenn der zusätzlich benötigte Speicherbedarf unabhängig von der gegebenen Sequenz ist. Frank Heitmann [email protected] 12/48

13 Bedeutung des Sortierens Motivation Daten zu Sortieren ist ein fundamentales Problem: Manchmal ist Sortieren das Wesen der Anwendung Sortieren als Vorstufe (z.b. für das Suchen) Sortieren als Unterroutine (z.b. Painter s Algorithm) Viele verschiedene (Algorithmen-)Techniken Beweisbarkeit einer nichttrivialen unteren Schranke Sortiert wird ständig: Musikliste nach Künstlern oder Titeln Ankommende Pakete über die Datenleitung... Frank Heitmann [email protected] 13/48

14 Pause to Ponder... Motivation Wem fällt ein Brute-Force-Algorithmus zum Sortieren ein? Frank Heitmann 14/48

15 Motivation Sortieren mit Maximumbestimmung (MaxSort) Algorithmus 3 Sortieren mit Max 1: for i = n downto 1 do 2: idx = max(a) 3: B[i] = A[idx] 4: A[idx] = 0 5: end for 6: return B Frank Heitmann [email protected] 15/48

16 Bestimmung des Maximums Motivation Algorithmus 4 Find Maximum 1: max = 1 2: for i = 2 to n do 3: if a[i] > a[max] then 4: max = i 5: end if 6: end for 7: return max; Frank Heitmann [email protected] 16/48

17 InsertionSort: Die Idee Motivation Beim Sortieren durch Einfügen (InsertionSort) wird ähnlich wie beim Spielkarten sortieren vorgegangen: Starte mit der leeren linken Hand Nimm ein Karte und füge sie an der richtigen Position in der linken Hand ein. Dazu Vergleiche diese neue Karte von rechts nach links mit den Karten, die schon auf der linken Hand sind. Sobald eine kleinere Karte erreicht wird, füge ein. Zu jedem Zeitpunkt sind die Karten auf der linken Hand sortiert. Die Karten auf der linken Hand sind jeweils die obersten Karten des Haufens. Frank Heitmann 17/48

18 InsertionSort: Der Algorithmus Motivation Algorithmus 5 InsertionSort(A[1... n]) 1: for j = 2 to n do 2: key = A[j] 3: i = j 1 4: while i > 0 und A[i] > key do 5: A[i + 1] = A[i] 6: i = i 1 7: end while 8: A[i + 1] = key 9: end for Frank Heitmann [email protected] 18/48

19 Zusammenfassung / Diskussion Motivation Wir kennen jetzt Lineares Suchen und binäres Suchen MaxSort und InsertionSort Aber: Ist ein Verfahren besser als ein anderes? Was messen wir? Frank Heitmann [email protected] 19/48

20 Motivation Wir behandeln nachfolgend Zeit- und Platzkomplexität. Eine (elementare) Anweisung zählt dabei als eine Zeiteinheit. Eine benutzte (elemantare) Variable als eine Platzeinheit. Zeit- und Platzbedarf wird abhängig von der Länge n der Eingabe gezählt. Wir arbeiten hierfür mit Funktionen f : N N bzw. f : N R. Frank Heitmann [email protected] 20/48

21 ... Algorithmus 6 Lineare Suche 1: for i = 0 to n do 2: if a[i] == max mustermann then 3: return true 4: end if 5: end for 6: return false Wir behandeln nachfolgend Zeit- und Platzkomplexität (im uniformen Maß). Eine (elementare) Anweisung zählt dabei als eine Zeiteinheit. Eine benutzte (elemantare) Variable als eine Platzeinheit. Zeit- und Platzbedarf wird abhängig von der Länge n der Eingabe gezählt. Wir arbeiten hierfür mit Funktionen f : N R. Frank Heitmann [email protected] 21/48

22 - Motivation Wir werden nachfolgend konstante Faktoren ignorieren. Diese verschwinden in der (auch Landau-Notation). Konzentration auf das wesentliche. Abstrahiert von verschiedenen Rechnerarchitekturen. Guter Vergleich von Algorithmen möglich (praxisbewährt). Ferner werden wir anfängliche Schwankungen ignorieren können. ABER: 5 n und 5000 n wird als im Prinzip gleich angesehen werden! Frank Heitmann [email protected] 22/48

23 Beware... Anmerkung Der Sinn der zur Analyse der Laufzeit und des Speicherbedarfs von Algorithmen wird später klarer. Gleich folgen erstmal Definitionen und Beispiele dazu, bevor die Anwendung auf Algorithmen folgt. Frank Heitmann 23/48

24 - Definition Definition ( (und Verwandte)) O(g(n)) = {f c R + n 0 N n n 0 : f (n) c g(n) } Ω(g(n)) = {f c R + n 0 N n n 0 : f (n) c g(n) } o(g(n)) = {f c R + n 0 N n n 0 : f (n) c g(n) } ω(g(n)) = {f c R + n 0 N n n 0 : f (n) c g(n) } Θ(g(n)) = {f c 1, c 2 R + n 0 N n n 0 : c 1 g(n) f (n) c 2 g(n) } Bemerkung f ist dabei stets eine Funktion von N nach R, also f : N R. (Daher überall die Betragsstriche!) In der Literatur gibt es hier Varianten. Bei der tatsächlichen machen diese aber kaum einen Unterschied. Frank Heitmann [email protected] 24/48

25 Wichtige Funktionen Bemerkung Wichtige Funktionen in der Algorithmik/: Konstante Funktionen Logarithmen (log, ln) Wurzelfunktionen ( n) Polynome (beachte: n = n 1/2 ) Exponentialfunktionen (2 n )... Kombinationen davon In welchem Zusammenhang stehen diese bzgl. der? ( Hausaufgabe!) Frank Heitmann [email protected] 25/48

26 Zum Logarithmus Bemerkung Mit log werden wir stets eine Variante des Logarithmus zur Basis 2 meinen, nämlich: { 1, falls n 1 log(n) := log 2 (n) + 1, sonst. Damit ist log(n) die Länge der Binärdarstellung einer natürlichen Zahl n. (Die Anzahl von Speicherstellen/Schritten ist stets eine natürliche Zahl!) Andere Logarithmen werden nur selten benötigt und sind bis auf einen konstanten Faktor ohnehin gleich. Die Rechengesetze wie z.b. log(x y) = log(x) + log(y) und log(x r ) = r log(x) sind oft hilfreich. Frank Heitmann [email protected] 26/48

27 - Beispiele I Definition (Θ - Wiederholung) Θ(g(n)) = {f c 1, c 2 R + n 0 N n n 0 : c 1 g(n) f (n) c 2 g(n)} Beispiel Wir wollen 1 2 n2 3n Θ(n 2 ) zeigen. Wir suchen also Konstanten c 1, c 2, n 0, so dass c 1 n n2 3n c 2 n 2 für alle n n 0 erfüllt ist. Teilen durch n 2 führt zu c n c 2. Dies kann man z.b. mit c 1 = 2 8, c 2 = 1, n 0 = 24 erfüllen. Frank Heitmann [email protected] 27/48

28 - Variante Satz 1 f (n) O(g(n)) lim n f (n) g(n) < 2 f (n) o(g(n)) lim n f (n) g(n) = 0 3 f (n) Ω(g(n)) lim n f (n) g(n) > 0 4 f (n) ω(g(n)) lim n f (n) g(n) = Bemerkung Mit obigen Äquivalenzen und mit Kenntnissen der Limesbildung sind einige der unten folgenden Sätze schnell zu zeigen (und evtl. schneller als mit der obigen, ursprünglichen Definition). Frank Heitmann [email protected] 28/48

29 - Beispiele II Satz / Definition f (n) O(g(n)) lim n f (n) g(n) < Beispiel Wir wollen 1 2 n2 3n O(n 2 ) zeigen. 1/2n 2 3n 1 lim n n 2 = lim n 2 3 n = 1 2 Ähnlich zeigt man 1 2 n2 3n Ω(n 2 ) woraus das gleiche Ergebnis wie oben folgt, wie wir gleich sehen werden. Frank Heitmann [email protected] 29/48

30 Merkhilfe Bemerkung Eine kleine Merkhilfe (nicht mehr!) f O(g) f g f Ω(g) f g f Θ(g) f = g f o(g) f < g f ω(g) f > g Wir sagen, dass f asymptotisch kleiner gleich, größer gleich, gleich, kleiner bzw. größer ist als g, wenn f O(g), f Ω(g), f Θ(g), f o(g) bzw. f ω(g) gilt. Frank Heitmann [email protected] 30/48

31 Wichtige Eigenschaften Satz 1 f X (g) und g X (h) impliziert f X (h) (X {O, Ω, Θ, o, ω}) 2 f X (f ) (X {O, Ω, Θ}) 3 f Θ(g) g Θ(f ) Beweis (für 1. und X = O) Sei f O(g) und g O(h), dann gibt es c, n 0, so dass f (n) c g(n) n n 0 und ebenso c, n 0, so dass g(n ) c h(n ) n n 0. Sei nun n 0 = max(n 0, n 0 ). Dann gelten n n 0 beide Ungleichungen und für diese n gilt dann f (n ) c g(n) c c h(n ) also f (n ) c c h(n ) und da c c eine Konstante ist, folgt f O(h). Frank Heitmann [email protected] 31/48

32 Weitere wichtige Eigenschaften Satz 1 g O(f ) f Ω(g) 2 g o(f ) f ω(g) 3 g Θ(f ) g O(f ) Ω(f ) 4 o(f ) O(f ) 5 ω(f ) Ω(f ) 6 ω(f ) o(f ) =? 7 Ω(f ) O(f ) =? Beweis (für 4.) f (n) Sei g o(f ), dann gilt lim n g(n) = 0. Um g O(f ) zu zeigen, f (n) muss lim n g(n) = c für eine Konstante c gezeigt werden. Mit c = 0 folgt dies sofort. Frank Heitmann [email protected] 32/48

33 Noch mehr wichtige Eigenschaften Satz 1 f, g O(h) f + g O(h) 2 f O(g), c R + c f O(g) 3 f O(h 1 ), g O(h 2 ) f g O(h 1 h 2 ) Beweis (für 3.) Sei f O(h 1 ) und g O(h 2 ), dann gibt es c, n 0, so dass f (n) c h 1 (n) n n 0 und ebenso c, n 0, so dass g(n ) c h 2 (n ) n n 0. Daraus folgt f (n ) g(n ) c c h 1 (n ) h 2 (n ) n max(n 0, n 0 ), also f g O(h 1 h 2 ). Frank Heitmann [email protected] 33/48

34 Zur Übung Zur Übung Formaler Nachweis der obigen Eigenschaften (übt das Formale). Sei g eine unserer üblichen Funktionen. Man überlege sich für jedes X {O, Ω, Θ, o, ω} ein f mit f X (g) (baut Intuition auf). Frank Heitmann [email protected] 34/48

35 Algorithmus 1: Lineare Suche Algorithmus 7 Algorithmus 1 1: for i = 0 to n do 2: if a[i] == max mustermann then 3: return true 4: end if 5: end for 6: return false Analyse Laufzeit ist linear in der Länge n des Arrays, d.h. in O(n) oder genauer sogar in Θ(n). (Korrektheit ist noch zu zeigen. Dazu später mehr...) Frank Heitmann [email protected] 35/48

36 Algorithmus 2: Fakultät Algorithmus 8 fac(n) 1: res = 1 2: for i = 1 to n do 3: res = res i 4: end for 5: return res Analyse Die Laufzeit ist in O(n). Aber Achtung! Dies ist exponentiell in der Größe der Eingabe! Diese ist nämlich nur in O(log n). Frank Heitmann [email protected] 36/48

37 Vorgehen Vorgehen, wenn wir einen Algorithmus analysieren: 1 Überlegen bzgl. welcher Kenngröße der Eingabe wir messen wollen. Diese kann sich von der Größe der Eingabe unterscheiden! (Beispiel: Anzahl Knoten eines Graphen). 2 Laufzeit/Speicherbedarf bzgl. dieser Kenngröße ausdrücken. 3 Nochmal überlegen, ob dies die Aussage des Ergebnisses verfälscht (so wie bei der Fakultätsberechnung eben). I.A. sollte sich die eigentliche Eingabegröße leicht durch die Kenngröße ausdrücken lassen und der Unterschied sollte nicht zu groß sein. + Beim Graphen mit n Knoten ist die Adjazenmatrix in O(n 2 ). Ist eine Zahl n die Eingabe, so ist die Eingabegröße in O(log n). Eine Laufzeit von O(n) wäre also exponentiell in der Eingabe! Frank Heitmann [email protected] 37/48

38 Algorithmus 3: Bestimmung des Maximums Algorithmus 9 Find Maximum 1: max = 1 2: for i = 2 to n do 3: if a[i] > a[max] then 4: max = i 5: end if 6: end for 7: return max; Analyse Laufzeit ist linear in der Länge n des Arrays, d.h. in O(n) oder genauer sogar in Θ(n). Frank Heitmann [email protected] 38/48

39 Algorithmus 4: MaxSort Algorithmus 10 Sortieren mit Max 1: for i = n downto 1 do 2: idx = max(a) 3: B[i] = A[idx] 4: A[idx] = 0 5: end for 6: return B Laufzeit ist in O(n 2 ). Frank Heitmann [email protected] 39/48

40 Algorithmus 5: InsertionSort Algorithmus 11 InsertionSort(A[1... n]) 1: for j = 2 to n do 2: key = A[j] 3: i = j 1 4: while i > 0 und A[i] > key do 5: A[i + 1] = A[i] 6: i = i 1 7: end while 8: A[i + 1] = key 9: end for Laufzeit ist ebenfalls in O(n 2 ). Frank Heitmann [email protected] 40/48

41 Algorithmus 6: Binäre Suche Algorithmus 12 Binäre Suche 1: while first last idx < 0 do 2: m = first + ((last first)/2) 3: if a[m] < p then 4: first = m + 1 5: else if a[m] > p then 6: last = m 1 7: else 8: idx = m 9: end if 10: end while 11: return idx Laufzeit ist in O(log n). Frank Heitmann [email protected] 41/48

42 Algorithmus 7: Brute-Force-Algorithmen Das Mengenpartitionsproblem Gegeben sei eine Menge S N. Gesucht ist eine Menge A S, so dass x A x = x A x gilt. Algorithmus 13 Suchraum durchsuchen 1: for all A S do 2: if x A x = x A x then 3: return true 4: end if 5: end for 6: return false Laufzeit ist in O(2 S ). Frank Heitmann [email protected] 42/48

43 Eine kleine Warnung zum Schluss Wichtige Anmerkung Die verschluckt Konstanten. Wenn die zu gross/klein sind, dann kann dies das Ergebnis verfälschen! In dem Fall ist dann eine genauere Analyse (ohne ) nötig. I.A. hat sich die aber bewährt, weil Extreme wie 10 6 n und n in der Praxis kaum vorkommen. Kurz: O(2 n ) ist nicht zwingend immer schlimmer als O(n) aber auf lange Sicht (d.h. bei wachsenden Eingabelängen) auf jeden Fall und im Allgemeinen (und bei allem, was einem so i.a. in der Praxis begegnet) ist O(2 n ) eben doch schlimmer als O(n). Frank Heitmann [email protected] 43/48

44 Sequentielle Algorithmen - Zusammenfassung Ein paar Merkregeln für die bisherigen Laufzeiten: Konstant - Selten. Es wird nicht mal die ganze Eingabe betrachtet! - Aber Grundoperationen kosten nur konstant viel! Logarithmisch - Bei wiederholten Halbierungen oder wenn man mit der Höhe eines Baumes arbeitet. Lineare Laufzeiten, wenn man sich jedes Element der Eingabe einmal (oder: eine konstante Anzahl von Malen) ansieht. Quadratisch - jedes Element mit jedem anderen vergleichen. Höhere Polynome -? Exponentiell - wenn man jede Möglichkeit durchprobiert. Frank Heitmann [email protected] 44/48

45 Zusammenfassung Begriffe: Datentyp, Datenstruktur, Algorithmus Zeit- und Platzkomplexität ( gute Algorithmen), wobei wir das uniforme Kostenmaß nutzen (jeder (elementare) Schritt eine Zeiteinheit, jede (elementare) Variable eine Platzeinheit) Zwei Definitionen für die (und Verwandte) Wichtige Eigenschaften der Wichtige Funktionen und ihre Klassifizierung bzgl. der Lineares Suchen und Binäres Suchen MaxSort und InsertionSort Frank Heitmann [email protected] 45/48

46 Themen der Vorlesung Thema 2 Wir untersuchen den Zeit- und Platzbedarf von Algorithmen, wobei wir das uniforme Kostenmaß nutzen (jeder (elementare) Schritt eine Zeiteinheit, jede (elementare) Variable eine Platzeinheit). Zeit- und Platzbedarf wird abhängig von der Länge n der Eingabe gezählt. Hierzu nutzen wir Funktionen f : N N, bzw. f : N R. Thema 1 & 3 Weitere (Ober-)Themen der Vorlesung sind bekannte Algorithmen für Probleme lesen, verstehen und anwenden zu können, sowie neue Algorithmen entwerfen, deren Korrektheit beweisen und ihre Laufzeit analysieren zu können. Frank Heitmann [email protected] 46/48

47 Ausblick: Eine andere Art von Algorithmen Algorithmus 14 fac(n) 1: if n == 0 then 2: return 1 3: else 4: return n fac(n 1) 5: end if Dies ist ein rekursiver Algorithmus... unsere bisherigen Techniken sind hier bei der Analyse wenig hilfreich. Frank Heitmann [email protected] 47/48

48 Ausblick Nächstes Mal: Rekurrenzgleichungen Korrektheit von Algorithmen Dabei: Weiteres zu Suchen und Sortieren Datenstrukturen Frank Heitmann 48/48