Datenstrukturen und Algorithmen VO 708.031 27.10.2011 stefan.klampfl@tugraz.at 1
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)) 27.10.2011 stefan.klampfl@tugraz.at 2
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) 27.10.2011 stefan.klampfl@tugraz.at 3 p
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) 27.10.2011 stefan.klampfl@tugraz.at 4 p
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) 27.10.2011 stefan.klampfl@tugraz.at 5
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]: 27.10.2011 stefan.klampfl@tugraz.at 6
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 27.10.2011 stefan.klampfl@tugraz.at 7
Stapel Anwendung Umwandeln von Infix-Ausdrücken in Postfix-Notation und deren anschließende Auswertung Beispiel: Infix: (3+7)*(5-1)+2 Postfix: 37 + 51 -* 2 + Auswertung: 42 27.10.2011 stefan.klampfl@tugraz.at 8
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 27.10.2011 stefan.klampfl@tugraz.at 9
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 27.10.2011 stefan.klampfl@tugraz.at 10
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]: 27.10.2011 stefan.klampfl@tugraz.at 11
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 27.10.2011 stefan.klampfl@tugraz.at 12
Elementare Datenstrukturen Schlange(queue): Q PUT(Q,17), PUT(Q,3), PUT(Q,5): 15 6 9 8 4 a e anz= 5 Q 3 5 15 6 9 8 4 17 e a anz= 8 GET(Q): (=15) Q 3 5 6 9 8 4 17 e a anz= 7 27.10.2011 stefan.klampfl@tugraz.at 13
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) 27.10.2011 stefan.klampfl@tugraz.at 14
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! 27.10.2011 stefan.klampfl@tugraz.at 15
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=7 27.10.2011 stefan.klampfl@tugraz.at 16
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) 27.10.2011 stefan.klampfl@tugraz.at 17
Türme von Hanoi Anzahl der Schritte: 2 n -1 Laufzeit optimal! Annahme: 1 Spielzug/Sekunde Anzahl der Scheiben Zeit 5 31 Sekunden 10 17 Minuten 20 12 Tage 30 34 Jahre 64 584 Milliarden Jahre Geschätztes Alter des Universums: 13.7 Milliarden Jahre 27.10.2011 stefan.klampfl@tugraz.at 18
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 27.10.2011 stefan.klampfl@tugraz.at 19
Merge-Sort Sortieren durch Verschmelzen (Merge-Sort): Aufruf mit MERGESORT(A,1,n) 27.10.2011 stefan.klampfl@tugraz.at 20
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) 27.10.2011 stefan.klampfl@tugraz.at 21
Merge-Sort Beispiel mit Zahlenfolge <5, 2, 4, 6, 1, 3>: 27.10.2011 stefan.klampfl@tugraz.at 22
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) 27.10.2011 stefan.klampfl@tugraz.at 23
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 27.10.2011 stefan.klampfl@tugraz.at 24
Danke für Ihre Aufmerksamkeit! Bis zum nächsten Mal. (Donnerstag, 3. Nov. 2011, 11:15, i13) 27.10.2011 stefan.klampfl@tugraz.at 25