Algorithmen und Datenstrukturen SS 2005

Präsentation zum Thema: "Algorithmen und Datenstrukturen SS 2005"—  Präsentation transkript:

1 Algorithmen und Datenstrukturen SS 2005
Mag.Th. Hilpold u. Dr. A.Stritzinger Institut für Wirtschaftsinformatik- Software Engineering JKU Linz

2 Inhalt Lösung Übung 7 Komplexität von Algorithmen Vorbesprechung Übung 9

3 Komplexität - Allgemeines
Speicherkomplexität Laufzeitkomplexität Laufzeit = f(Problemgröße) typ. Größe der Datenmenge O-Notation gibt Obergrenze für Laufzeit an. Konstanten werden weggelassen (zb. f(2,43N+1) = O(N))

4 Laufzeitkomplexitäts-Klassen
Bezeichnung O Wertung Beispiel konstante Komp. O(1) optimal, selten Hashing, Prepend Logarithmische K. O( log n ) Sehr günstig Binäres Suchen Lineare Komp. O( n ) Günstig Lineares Suchen Leicht überlinear O(n log n) Noch gut Gutes Sortierverfahren Quadratische K. O( n2 ) Ungünstig Schlechtes Sortierverfahren Kubische K. O( n3 ) Matrizenmultiplikation Exponentielle K. O( an ) Katastrophal Rundreiseproblem

5 Mathem. Aussagen wenn P(n) ein Polynom m-ten Grades ist, so gilt: P(n) = O(nm) an wächst stärker als jedes Polynom -> kein polynomialer Algorithmus log n wächst schwächer als n, egal welche Basis

6 Laufzeitkomplexität n O(n) O(n2) O(2^n) 1 1 sec 10 10 sec 100 sec
ca. 1 msec 100 10 msec 4*106 Jahre 1000 1 msec 1 sec 3,4*10286 Jahre

7 Laufzeitkomplexität (relativ kleine Werte)

8 Laufzeitkomplexität (relativ große Werte)

9 Laufzeit für einfache FOR-Schleifen
for (i=1; i<n; i++) { A } Unter der Annahme, dass A konstante Laufzeit aufweist, ist die Laufzeitkomplexität O(n), also linear.

10 Laufzeitkomplexität für geschachtelte For-Schleifen
for (int i = 1..n) { for (int j = 1..n) { A } Laufzeitkomplexität O(n*n), also quadratisch

11 Geschachtelte FOR-Schleife mit variabler Obergrenze
for (int i = 1..n) { for (int j = 1..i) { A } Laufzeitkomplexität O(n*n/2), also quadratisch

12 Schleife mit Teilung der Laufweite
while (i < n) { n = n/2 i = i + 1; } Laufzeitkomplexität O(log2n), also logarithmisch

13 Rekursiver Algorithmus
int fact(int n) { if (n == 0) return 1 else return n * fact(n-1) } Anzahl der Aufrufe n * Aufwand jeder Aktivierung k

14 int doSomething(int a, int b) { // a < b if (a == b) return 0;
Rekursion 2 int doSomething(int a, int b) { // a < b if (a == b) return 0; else return (doSomething (a+1, b) – doSomething(a, b-1)) } Durch den zweifachen rekursiven Abstieg ergibt sich ein binärer Aufrufbaum ! Die Laufzeitkomplexität kann dabei exponentiell werden (2N). Dies hängt jedoch immer vom Ausmaß der Problemverkleinerung mit jedem zusätzlichen Rekursionsschritt ab. Für doSomething(0,3) ergeben sich (23+1 – 1) Aufrufe, da ein Binärbaum mit Höhe 4 entsteht. Laufzeitkomplexität O(2N)