Datenstrukturen und Algorithmen

Transkript

1 Datenstrukturen und Algorithmen VO

2 Wiederholung Wir vergleichen Algorithmen anhand des ordnungsmäßigen Wachstums von T(n), S(n), Asymptotische Schranken: O-Notation: f(n) = O(g(n)) g(n) ist eine asymptotisch obere Schranke von f(n) Ω-Notation: f(n) = Ω(g(n)) g(n) ist eine asymptotisch untere Schranke von f(n) Θ-Notation: f(n) = Θ(g(n)) g(n) ist eine asymptotisch exakte Schranke für f(n) f(n) = Θ(g(n)) f(n) = O(g(n)) f(n) = Ω(g(n)) [email protected] 2

3 Elementare Datenstrukturen Lineares Feld(array): A[1..n]; benachbarte Elemente stehen im Speicher nebeneinander; Zugriff auf i-tes Element A[i] in O(1) Zeit Lineare Liste (linked list): Benachbarte Elemente sind verkettet Varianten: einfach verkettet, doppelt verkettet, zirkulär verkettet WERT(p) NACH(p) HEAD(L) VOR(p) p

4 Elementare Datenstrukturen Lineare Liste (linked list): Suchen eines Wertes benötigt O(n) Zeit Einfügen eines Elementes benötigt O(1) Zeit Löschen eines Elementes benötigt O(1) Zeit (wenn Suchen erforderlich O(n) Zeit) WERT(p) NACH(p) HEAD(L) VOR(p) p

5 Elementare Datenstrukturen Hauptoperationen auf linearen Feldern und Listen Lineares Feld Lineare Liste Zugriff auf i-tes Element O(1) O(i) Suchen O(n) O(n) Einfügen O(n) O(1) Entfernen O(n) O(1) * * wenn Element gegeben, sonst O(n) (zuerst suchen) [email protected] 5

6 Elementare Datenstrukturen Stapel(stack): Erlaubt nur das Entfernen des zuletzteingefügten Elementes (LIFO-Strategie: last-in first-out ) Implementation mit einem linearen Feld S[1..n]: [email protected] 6

7 Elementare Datenstrukturen Stapel(stack): Einfügen: PUSH(S,x) 1: IF t==n THEN overflow 2: ELSE t=t+1 3: S[t]=x Entfernen: POP(S) 1: IF t==0 THEN underflow 2: ELSE x=s[t] 3: t=t-1 4: RETURN x Alle Operationen benötigen O(1) Zeit [email protected] 7

8 Stapel Anwendung Umwandeln von Infix-Ausdrücken in Postfix-Notation und deren anschließende Auswertung Beispiel: Infix: (3+7)*(5-1)+2 Postfix: * 2 + Auswertung: [email protected] 8

9 Stapel Anwendung Algorithmus zur Umwandlung Infix -> Postfix: Stapel anfangs leer (enthält während des Arbeitens nur Klammern und Operatoren) Durchlaufe die Eingabeelemente von links nach rechts: ( : Klammer auf Stapel legen Zahl: Zahl ausgeben Operator o: Alle Operatoren mit gleicher oder höherer Priorität vom Stapel ausgeben, bis ( erreicht oder Stapel leer ist. Operator oauf Stapel legen ) : Alle Operatoren vom Stapel bis zur ersten ( ausgeben und diese löschen Am Ende alle verbleibenden Operatoren vom Stapel ausgeben [email protected] 9

10 Stapel Anwendung Algorithmus zur Auswertung eines Postfix- Ausdruckes: Stapel anfangs leer, enthält während des Arbeitens nur Zahlen Durchlaufe die Eingabeelemente von links nach rechts: Zahl: Lege die Zahl auf den Stapel Operator o: Wende den Operator oauf die beiden obersten Elemente des Stapels an; ersetze diese beiden Zahlen durch das Ergebnis Am Ende steht der Wert des Ergebnisses als einziger Wert auf dem Stapel

11 Elementare Datenstrukturen Schlange(queue): Erlaubt nur das Entfernen des zuersteingefügten Elementes (FIFO-Strategie: first-in first-out ) Implementation mit einem linearen Feld Q[1..n]: [email protected] 11

12 Elementare Datenstrukturen Schlange(queue): Einfügen: PUT(Q,x) 1: IF anz==n THEN overflow 2: ELSE anz=anz+1 3: IF e<n THEN e=e+1 4: ELSE e=1 5: Q[e]=x Entfernen: GET(Q) 1: IF anz==0 THEN underflow 2: ELSE anz=anz-1 3: x=q[a] 4: IF a<n THEN a=a+1 5: ELSE a=1 6: RETURN x Alle Operationen benötigen O(1) Zeit [email protected] 12

13 Elementare Datenstrukturen Schlange(queue): Q PUT(Q,17), PUT(Q,3), PUT(Q,5): a e anz= 5 Q e a anz= 8 GET(Q): (=15) Q e a anz= [email protected] 13

14 Rekursionen Rekursion: Algorithmus ruft sich selbst auf Viele Algorithmen können sowohl iterativ als auch rekursiv implementiert werden Beispiel: Fakultät f ( n) = n! = n ( n 1) ( n 2) K 2 1 T(n) = O(n) S(n) = O(1) T(n) = O(n) S(n) = O(n) (entspricht Rekursionstiefe) [email protected] 14

15 Rekursionen Beispiel: Fibonacci-Zahlen f n = fn 1 + fn 2, n 3; f1 = f2 = 1 1, 1, 2, 3, 5, 8, 13, 21, T(n) = O(n) S(n) = O(1) T(n) = Θ(c n ) (exponentiell!) S(n) = O(n) (entspricht Rekursionstiefe) Rekursive Varianten sind oft einfacher zu implementieren, besitzen aber oft den größeren Laufzeit- und Speicherbedarf! [email protected] 15

16 Türme von Hanoi Regeln: 3 Stäbe: A, B, C Am Stab A liegen zu Beginn n unterschiedlich große Scheiben Diese sollen am Ende auf Stab Bliegen Es darf jeweils nur eine Scheibe bewegt werden Es darf nie eine größere auf einer kleineren Scheibe liegen Bsp.: n= [email protected] 16

17 Türme von Hanoi Rekursiver Algorithmus zur Lösung: Legt die obersten n Scheiben von x nach y unter Verwendung von z Aufruf mit HANOI(7, A, B, C) Laufzeit: T(n) = O(2 n ) Speicher: T(n) = O(n) [email protected] 17

18 Türme von Hanoi Anzahl der Schritte: 2 n -1 Laufzeit optimal! Annahme: 1 Spielzug/Sekunde Anzahl der Scheiben Zeit 5 31 Sekunden Minuten Tage Jahre Milliarden Jahre Geschätztes Alter des Universums: 13.7 Milliarden Jahre [email protected] 18

19 Divide-and-Conquer Mittels Rekursionen kann man Probleme in kleinere Teilprobleme zerlegen: Teile das Problem in mehrere Teilprobleme Löse die Teilprobleme rekursiv Kombiniere die Teillösungen zu einer Gesamtlösung Beispiel: Sortieren durch Verschmelzen (Merge-Sort): Teiledie Zahlenfolge in 2 Hälften Sortiere beide Teilfolgen rekursiv Verschmelze die sortierten Teilfolgen zu einer Gesamtfolge [email protected] 19

20 Merge-Sort Sortieren durch Verschmelzen (Merge-Sort): Aufruf mit MERGESORT(A,1,n)

21 Merge-Sort Sortieren durch Verschmelzen (Merge-Sort): O(n/2) O(n/2) O(1) O(n) Laufzeit: T(n) = O(n) Speicher: S(n) = O(n) [email protected] 21

22 Merge-Sort Beispiel mit Zahlenfolge <5, 2, 4, 6, 1, 3>:

23 Merge-Sort Laufzeit von Merge-Sort: Teile: Berechnen des mittleren Index k: O(1) Lösen der Teilprobleme: 2T(n/2) Verschmelzen der Teillösungen: O(n) T(n) = 2T(n/2) + O(n) T(1) = O(1) T(n) = O(n*log n) S(n) = O(n) Aufruf mit MERGESORT(A,1,n) [email protected] 23

24 Merge-SortvsInsertion-Sort Laufzeit T(n): Insertion-Sort Merge-Sort best case Ω(n) Ω(n*log n) average case O(n 2 ) O(n*log n) worst case O(n 2 ) O(n*log n) Speicher S(n): adaptiv Insertion-Sort Merge-Sort all cases Θ(1) Θ (n) in-place [email protected] 24

25 Danke für Ihre Aufmerksamkeit! Bis zum nächsten Mal. (Donnerstag, 3. Nov. 2011, 11:15, i13)