Algorithmen und Datenstrukturen 1 Sommersemester 2000 Prof. Dr. Gerhard Heyer Institut für Informatik Abt. Automatische Sprachverarbeitung Hauptgebäude, 1. Stock, Zi. 1-52 Vorlesung basierend u.a. auf: Ottmann/Wiedmayer, Algorithmen und Datenstrukturen, Spektrum Akademischer Verlag, Heidelberg: 21996 Foliensammlung Prof. Rahm und Prof. Brewka

Organisatorisches Übungen ab 10.4.2000 (1 SWS) Übungsblatt ab 5.4.2000 vierzehntägig nur im Netz (Lernserver) Abgabe der Lösungen jeweils 2 Wochen später, 5 Minuten vor der Vorlesung (erste Abgabe 19.4.2000) Regelmäßige Abgabe der Lösungen Zulassungsbedingung zur Übungsklausur! (50% der Punkte) Übungsklausur 12. Juli 2000 Bestehen der Übungsklausur Zulassungsbedingung zu Prüfungsklausur im Wintersemester! Vorlesungsfolien ... werden wöchentlich ins Netz gestellt (Lernserver)

Termine für Übungsgruppen: Dr. Gräbe Fr. A 9.15-10.45 Uhr SR 3-11 Organisatorisches Übungsleiter: Dr. Gräbe (Zi 2-51), Dr. Lange (Zi 1-08) Termine für Übungsgruppen: Dr. Gräbe Fr. A 9.15-10.45 Uhr SR 3-11 Fr. B 9.15-10.45 Uhr SR 3-11 Mi. A 11.15-12.45 Uhr SR 2-71 Mi. B 11.15-12.45 Uhr SR 2-71 Dr. Lange Di. A 9.15-10.45 Uhr SR 3-03 Di. B 9.15-10.45 Uhr SR 3-03 Do. A 11.15-12.45 Uhr SR 3-11 Do. B 11.15-12.45 Uhr SR 3-11 Programmiersprache: C

Inhalt der Vorlesung Komplexität von Algorithmen Listen und Listenorperationen Suche in Listen Sortieren Natürliche Bäume und Binärbäume Ausgeglichene Binärbäume Blattsuchbäume (Digitalbäume) Mehrwegbäume Hashing Aktueller Vorlesungs- und Übungsplan auf dem LERNSERVER!

Empfohlene Lehrbücher T. Ottman, P. Widmayer, Algorithmen und Datenstrukturen, Spektrum 21996 R. Sedgwick, Algorithmen in C, Addison Wesley 1993 U. Schöning, Algorithmen - kurz gefasst, Spektrum 1997 Denenberg, Data Structures and their Algorithms, Harper/Collins 1991 Engesser/Claus/Schwill, Informatik Duden, BI 1993 Louden, Mastering Algorithms with C, O’Reilly 1999 Richter/Sander/Stucky, Problem-Algorithmus-Programm, Teubner 1993 Aho, Hopcroft, Ullman, Data Structures and Algorithms (1983) Knuth, The Art of Computer Programming Vol.3 (1973)

Aufgabe: Maximum Subarray Problem gegeben: Folge X von ganzen Zahlen der Länge N gesucht: maximale Summe der Elemente einer zusammenhängenden Teilfolge maxtsumme := 0; for u := 1 to N do for o := u to N do begin {bestimme Summe der Elemente in Teilfolge X[u .. o]} summe := 0; for i := u to o do summe := summe + X[i]; maxtsumme := max(summe, maxtsumme) end

Anzahl der Additionen in innerster for-Schleife: 1 + 2 + 3 + 4 + 5 + 6 Anzahl der Additionen in innerster for-Schleife: 1 + 2 + 3 + 4 + 5 + 6 ... + N 1 + 2 + 3 + 4 + 5 ... + N-1 1 + 2 + 3 + 4 ... + N-2 ... 1 N + (N-1)2 + (N-2)3 + ... + 1N Dieser Algorithmus benötigt Q(N3) Schritte (Zuweisungen)

Bessere Lösung durch Divide and Conquer Methode: Allgemein: Divide and Conquer- Verfahren zur Lösung eines Problems der Größe N . Divide: Falls N > 1 teile Problem in annähernd gleich große Teilprobleme, sonst löse Problem direkt. . Conquer: Löse (rekursiv) Teilprobleme. . Merge: Kombiniere Teillösungen zu Gesamtlösung.

Anwendung auf Maximum Subarray Problem: Beobachtung: wenn man Folge in 2 Teile A und B teilt, so ist die gesuchte Teilfolge entweder in A, oder in B, oder in beiden. Im letzten Fall sind die Randelemente in der gesuchten Teilfolge, und diese besteht aus 2 maximalen Teilstücken, die beim jeweiligen Rand beginnen (rechtes Randmaximum von A + linkes Randmaximum von B) . Die Randmaxima von X[l], ..., X[r] kann man in linearer Zeit berechnen: lmax := 0; summe := 0; for i := l to r do begin summe := summe + X[i]; lmax := max(lmax, summe) end rmax analog.

Damit erhält man folgenden D&C-Algorithmus: Algorithmus maxtsum(X); {liefert maximale Teilsumme der Folge X ganzer Zahlen} begin if X enthält nur ein Element a then (if a > 0 then maxtsum := a else maxtsum := 0) else begin teile X in linke und rechte Teilfolgen A und B annähernd gleicher Größe; maxtinA := maxtsum(A); maxtinB := maxtsum(B); bestimme rechtes Randmaximum von A, rmax(A); bestimme linkes Randmaximum von B, lmax(B); maxtsum := max(maxtinA, maxtinB, rmax(A) + lmax(B)) end end

Sei T(N) Anzahl der Schritte des Algorithmus bei Eingabe einer Folge der Länge N. Es gilt: T(N) = 2 T(N/2) + C . N Da T(1) konstant (T(1) = C1) erhält man T(N) = Q(N log N). Beispiele: T(1) = C1 T(2) = 2C1+ 2C T(4) = 4C1 + 8C T(8) = 8C1 + 24 C T(16) = 16C1 + 64 C T(32) = 32C1 + 160 C Gleichungen wie die obige nennt man Rekursionsgleichungen. (Sie treten bei Komplexitätsanalysen oft auf.)

Noch besseres Verfahren: Scan-Line-Prinzip. wir durchlaufen Positionen 1,...,N, merken uns jeweils die maximale Summe bismax im bisher inspizierten Anfangsstück sowie rechtes Randmaximum scanmax. Bei Vorrücken um 1 Position ist neue maximale Teilfolge entweder gleich der alten, oder sie enthält neues Randelement und ist dann das neue rechte Randmaximum. Neues rechtes Randmaximum ist scanmax + a, a Wert der nächsten Position, falls diese Summe positiv, sonst 0. scanmax := 0; bismax := 0; for i := 1 to N do begin if scanmax + X[i] > 0 then scanmax := scanmax + X[i] else scanmax := 0; bismax := max(scanmax, bismax) end

Algorithmus führt nur N (linear viele) Schritte aus. Optimale Komplexität, da jede Position ja mindestens einmal überprüft werden muß. Beispiel: ___maximale Teilsequenz_____ 8 -17 -6 4 19 -5 -12 21 smax 8 0 0 4 23 18 6 27 bmax 8 8 8 8 23 23 23 27

Grundbegriffe: Komplexität einer Funktion ist untere Schranke für die Effizienz eines Algorithmus. Effizienz eines Algorithmus ist obere Schranke für die Komplexität der durch den Algorithmus realisierten Funktion. Ein A. heisst effizient, wenn er ein vorgegebenes Problem in möglichst kurzer Zeit und/oder möglichst geringem Aufwand an Betriebsmitteln (Laufzeit, Speicherplatz) löst. Unterschied zwischen Problemkomplexität und Algorithmuskomplexität.

Üblicherweise verwendete Funktionen zum Messen des Wachstums: 1) logarithmische: log n 2) linear: n 3) n log n: n log n 4) quadratisch, kubisch, ... n2, n3, ... 5) exponentiell: 2n, 3n, ... Unterschied handhabbar (tractable) - nicht handhabbar wird zwischen (4) und (5) gemacht.

Beispiel-Tabellen aus Garey/Johnson. Annahme: 1 Operation braucht 1 Nanosekunde (Millionstel Sekunde) s: Sekunden m: Minuten d: Tage (days) y: Jahre (years) c: Jahrhunderte (centuries) Größe / Wachstum 10 20 30 40 50 60 n .00001 s .00002 s .00003 s .00004 s .00005 s .00006 s n2 .0001 s .0004 s .0009 s .0016 s .0025 s .0036 s n3 .001 s .008 s .027 s .064 s .125 s .216 s n5 .1 s 3.2 s 24.3 s 1.7 m 5.2 m 13.0 m 2n .001 s 1.0 s 17.9 m 12.7 d 35.7 y 366c 3n .059 s 58 m 6.5 y 3855 c 2 á 108 c 1.3 á 1013 c

Wie wirken sich technologische Fortschritte (schnellere Computer) aus? Größe des größten Problems, das in 1 Stunde gelöst werden kann: größtes Problem/ genwärtige Rechner Rechner Wachstum Rechner 100 mal schneller 1000 mal schneller n N1 100 N1 1000 N1 n2 N2 10 N2 31.6 N2 n3 N3 4.64 N3 10 N3 n5 N4 2.5 N4 3.98 N4 2n N5 N5 + 6.64 N5 + 9.97 3n N6 N6 + 4.19 N6 + 6.29