Übung Algorithmen und Datenstrukturen

Transkript

1 Übung Algorithmen und Datenstrukturen Sommersemester 017 Marc Bux, Humboldt-Universität zu Berlin

2 Agenda 1. Vorrechnen von Aufgabenblatt 1. Wohlgeformte Klammerausdrücke 3. Teile und Herrsche

3 Agenda 1. Vorrechnen von Aufgabenblatt 1. Wohlgeformte Klammerausdrücke 3. Teile und Herrsche 3

4 Zusammenhänge, Grenzwerte (Wiederholung) Zusammenhänge zwischen Ο, Ω, Θ, ο und ω Satz: f Ο g Satz: f ο g Satz: f ο g Satz: f ω g g Ω(f) g ω f f Ω(g) f Ο g Grenzwert als hinreichendes Kriterium f(n) Satz: lim n g(n) f(n) Satz: lim n g(n) f(n) Satz: lim n g(n) f(n) Satz: lim n g(n) < f Ο(g) > 0 f Ω(g) = 0 f ο(g) = f ω g Satz von L Hôpital: Seien f und g zwei differenzierbare Funktionen, deren Grenzwerte entweder beide gegen 0 oder f n beide gegen gehen. Dann gilt lim = lim f n (falls n g(n) n g (n) der Grenzwert existiert). 4

5 Weitere Landau-Terme (Wiederholung) Definitionen: Ο g = f: N R 0 c R + n 0 N n n 0 : f n c g(n) Ω g = f: N R 0 c R + n 0 N n n 0 : f n c g(n) Θ g = f: N R 0 f Ο g f Ω g ο g = f: N R 0 c R + n 0 N n n 0 : f n < c g(n) ω g = f: N R 0 c R + n 0 N n n 0 : f n > c g(n) Bedeutung: g wächst... mindestens so schnell wie f (ist obere Schranke für f) höchstens so schnell wie f (ist untere Schranke für f) ungefähr genauso schnell wie f schneller als f langsamer als f 5

6 Beispiel Definitionen (kurz): f Ο g c n 0 n n 0 : f n c g(n) f Ω g c n 0 n n 0 : f n c g(n) f Θ g f Ο g f Ω g Funktionen f n = 3n 5 + 4n g n = n 5 wähle c = =, n 0 = 1 n n 0 : f n c g n da 3n 5 + 4n n 5 für n 1 f Ο g = Ο(n 5 ) 6

7 Agenda 1. Vorrechnen von Aufgabenblatt 1. Wohlgeformte Klammerausdrücke 3. Teile und Herrsche 7

8 Wohlgeformte Klammerausdrücke Wie findet man heraus, ob ein gegebener String aus öffnenden und schließenden Klammern ein wohlgeformter Klammerausdruck ist? Ausdruck wohlgeformt? ( [ ] ) Ja ( ( [ ] [ ] ) ) Ja ( ] ) [ Nein ) ( Nein (( ) Nein 8

9 Lösung mit Stacks Algorithmus wohlgeformt(c) Input: Character-Array c der Länge c = n Output: true, falls der Ausdruck wohlgeformt ist. (1) Character-Stack s; () for i := 1 to n do (3) switch (c[i]) (4) case '(': (5) s.push( ')' ); (6) break; (7) case '[ : (8) s.push( ']' ); (9) break; (10) default: (11) if s.isempty() or s.pop() c[i] then (1) return false; (13) end if (14) end switch (15) end for (16) return s.isempty(); Alternative: Öffnende & schließende Klammern zählen 9

10 Agenda 1. Vorrechnen von Aufgabenblatt 1. Wohlgeformte Klammerausdrücke 3. Teile und Herrsche 10

11 Teile und Herrsche Paradigma für den Entwurf von effizienten Algorithmen. Problem Problem wird in kleinere, einfachere Teilprobleme zerlegt, bis man die Lösung (be-)herrscht. decrease Teilproblem divide Teilprobleme Anschließend wird aus den Teillösungen die Gesamtlösung zusammengesetzt. Lösung des Teilproblems conquer Lösung aller Teilprobleme 1) Decrease and Conquer: Es wird genau ein Teilproblem gelöst (z.b. Binäre Suche). ) Divide and Conquer: Es werden mindestens zwei Teilprobleme gelöst (z.b. MergeSort, QuickSort). merge Lösung des Problems 11

12 Decrease & Conquer: Finden des k-kleinsten Elements Gegeben: unsortiertes Array von n Elementen Aufgabe: finde das k-kleinste Element. Beispiel, k=4: Triviale Lösungen: Sortieren und k-tes Element zurückgeben: Θ(n log n) (MergeSort) k-mal das Minimum bestimmen / entfernen: Θ k n Bessere Lösung? 1

13 Decrease & Conquer: Idee Wähle ein Pivot-Element und partitioniere die Liste in zwei Teile L und R (kleiner und größer als Pivot-Element): <6 6 >6 Sei s die Position des Pivot Elements: Falls s = k, gib das Pivot-Element zurück. Falls s > k, suche das k-kleinste Element in L Falls s < k, suche das (k-s)-kleinste Element in R L s R 13

14 Decrease & Conquer: Beispiel < 6 > 6 10 k = 4 s = s > k < 1 > 1 s = 0 s < k s = k s = 5 14

15 Decrease & Conquer: Lösung Algorithmus ksmallest(a, k) Input: Int-Array A mit n > 1 Objekten, Position k Output: k-kleinstes Element von A (1) if k > A then () return null; (3) end if (4) p = A ; // Index des Pivot-Elements (5) A L, AR partition(a, p, k); // Teile A anhand des Pivot- Elements (6) s A L + 1 (7) if s = k then (8) return A[s]; (9) else if s < k then (10) return ksmallest(a L, k); (11) else (1) return ksmallest(a R, k s); (13) end if 15

16 Decrease & Conquer: Laufzeit Best Case: Eine Iteration : Ο 1 Worst Case: Ο n Wann tritt der ein? Average Case: Ο(n) (Ohne Beweis) Intuition: jeweils ungefähr halbieren der Elemente n = n log n (Geometrische Reihe) n i=0 n 1 1 = n ε Ο(n) 16

17 Divide & Conquer: Finden des Majority-Elements Gegeben: Array A mit n Objekten Objekte können auf Gleichheit überprüft werden Objekte können nicht geordnet oder sortiert werden, d.h. es existiert keine Ordnungsrelation wie Aufgabe: Prüfe, ob beliebiges Element x A mehr als n mal vorkommt (d.h. H x A > n ) Beispiel: H A 1 = 8 kein Majority-Element H A = 9 ist Majority-Element H A 3 = 8 H 3 A 3 = 8 kein Majority-Element 17

18 Majority-Element: Naive Lösung Algorithmus Major(A) Input: Array A mit n > 1 Objekten Output: Majority-Element von A, falls ein solches existiert; ansonsten null (1) if A = 1 () return A[0]; (3) else (4) for i 1 to n (5) c 1; (6) for j i + 1 to n (7) if A i = A[j] (8) c c + 1; (9) endif (10) endfor (11) if c > n (1) return A i ; (13) endif (14) endif (15) return null; Laufzeit: Ο(n ) 18

19 Divide & Conquer: Grundprinzip Idee: Teile Problem in Teilprobleme auf (divide) Löse diese rekursiv (conquer) Setze aus den Lösungen der Teilprobleme die Lösung für das Gesamtproblem zusammen (merge) Darstellung als Rekursionsbaum T(n) = Anzahl Operationen für Eingabe der Größe n divide merge T(n) Kosten pro innerer Knoten: divide + merge T(m) T(m) T(m) wichtig: m < n divide merge Kosten pro Blatt: conquer Abbruch, wenn Eingabe klein genug T(1) T(1) T(1) T(1) T(1) T(1) 19

20 Divide & Conquer: Beispiel null null null null 7 null null null null

21 Divide & Conquer: Lösung Algorithmus MajorDC(A) Input: Array A mit n > 1 Objekten Output: Majority-Element von A, falls ein solches existiert; ansonsten null (1) if A > 1 then () halbiere A in A 1 und A // divide (3) m 1 MajorDC A 1 ; // divide (4) m MajorDC A ; // divide (5) if m 1 = m then // merge (6) return m 1 ; (7) endif (8) if m 1 null then (9) c Anzahl Vorkommen von m 1 in A; // merge (10) if c > n then (11) return m 1 ; (1) endif (13) endif (14) if m null then (15) c Anzahl Vorkommen von m in A; // merge (16) if c > n then (17) return m ; (18) endif (19) endif (0) return null; (1) endif () return A[1]; // conquer 1

22 Divide & Conquer: Korrektheit, Laufzeit Korrektheit (informell): Majority-Element von A muss immer auch Majority-Element von A 1 oder A sein Laufzeit (informell): Alle Zeilen bis auf divide, merge und conquer in Ο(1) Die Tiefe des Rekursionsbaums ist also in Ο(log n) divide in Ο(n) merge in Ο(n) conquer in Ο(1) Insgesamt Ο log n Ο n = Ο(n log n)

23 Ausblick zu nächster Woche: Aufgabenblatt bearbeiten und abgeben nächste Woche: Vorbereitung Aufgabenblatt 3 Suchen Sortieren 3