Algorithmen und Datenstrukturen. 1 Effizienz von Algorithmen
|
|
- Jakob Koch
- vor 6 Jahren
- Abrufe
Transkript
1 Algorithmen und Datenstrukturen - Effizienz von Algorithmen - Alexander Sczyrba Technische Fakultät asczyrba@techfak.uni-bielefeld.de Vorlesung, Universität Bielefeld, Winter 2014/ / 177 Kapitel 5 - Effizienz von Algorithmen 1 Effizienz von Algorithmen 2 Asymptotische Effizienz-Analyse 3 Exkurs 4 Beispiel zur Effizienanalyse 5 Ausnutzen von erwarteten Daten-Eigenschaften 2 / 177
2 Kapitel 5: Effizienz von Algorithmen Ziele des Kapitels Einführung in asymptotische Notationen asymptotische Effizienzanalyse (worst/average case) Wie erfasst man die Problemkomplexität? Was sind sinnvolle Programmoptimierungen? asympt. Klasse versus konstante Faktoren Analyse diverser Sortierverfahren (insertion-sort, tree-sort, merge-sort, smooth-sort, counting-sort)) Einfluss der Laziness auf die Effizienz 3 / 177 Asymptotische Notationen Asymptotische Notationen Wir betrachten das Polynom p(x) = 2x x 2 5x + 12 Für große x gilt: der Beitrag 2x 3 dominiert die anderen Beiträge, irgendwann auch 1000x 2. Für das weitere Wachstum gilt: p(2 x) 8 p(x) dafür spielt der Faktor 2 bei x 3 keine Rolle. 4 / 177
3 Asymptotische Notationen Oft interessiert in der Mathematik nur das grobe Wachstumsverhalten einer Funktion z.b. bei der Abschätzung von Fehlern (Approximation, fehlerbehaftete Eingaben) z.b. bei der Effizienzanalyse von Algorithmen siehe Folien zu Strategien des Problemlösens. Das grobe Verhalten muss natürlich exakt definiert sein... 5 / 177 Asymptotische Notationen Dazu werden asymptotische Notationen O(n), Ω(n) (Omega), Θ(n) (Theta) eingeführt. Sie beschreiben asymptotische Effizienzklassen. (Sie haben aber nicht per se etwas mit Algorithmen zu tun, sondern sind mathematisch definierte Klassen von Funktionen mit ähnlichem Wachstum für n.) Die O-Notation wurde von Paul Bachmann 1892 eingeführt und später von Edmund Landau weiter bekannt gemacht. Daher wird sie auch manchmal als Landau-Notation bezeichnet. Seien f, g : N R +. 6 / 177
4 Asymptotische Notationen O(g) = {f C > 0, n 0 0, n n 0 : 0 f (n) Cg(n)} d.h. f gehört zur Klasse O(g), wenn es ab n 0 durch C g(n) nach oben beschränkt ist. g(n) soll dabei möglichst einfach beschrieben sein. Beispiel: f (n) = 3n 4 + 5n log 2 n f (n) O(n 4 ), denn 3n 4 + 5n log 2 n 3n 4 + 5n 4 + 7n 4 = 15n 4 für n 1 Wir können C = 15 und n 0 = 1 wählen. 7 / 177 Asymptotische Notationen Ebenso gilt: f (n) O(n 5 ), schon weil 15n 4 15n 5 gilt. Dagegen gilt: f (n) / O(n 3 ), denn es gibt keine Konstante C, so dass 3n 4 C n 3 für alle n ab irgendeinem n 0. Es müsste ja C 3n gelten. 8 / 177
5 Asymptotische Notationen Aus dem Obigen folgt: O(1) O(n) O(n 2 ) O(n 3 )... Die Aussage f O(n 3 ) ist möglicherweise ausreichend für den gegebenen Anlass, aber nicht unbedingt genau. Es könnte ja sein, dass auch f O(n 2 ) gilt, und das wäre dann genauer. 9 / 177 Asymptotische Notationen Die Theta-Klassen Die Θ-Klassen begrenzen das Wachstumsverhalten nach oben und nach unten. Θ(g) = { f ( n 0, c, C)( n n 0 ) cg(n) f (n) Cg(n) } Ist f Θ(g), so heißt g asymptotische Schranke von f. Wir finden für f (n) = 3n 4 + 5n log 2 n f (n) Θ(n 4 ) mit den Konstanten C = 15, c = 3 und n 0 = 1 3 * x^4 + 5 * x^3 + 7 * log(x, 2) x 10 / 177
6 Asymptotische Notationen Im Unterschied zu den O-Klassen gilt bei den Θ-Klassen keine Inklusion. f (n) / Θ(n 5 ), denn es gibt kein c, n 0 mit c n 5 3n 4 + 5n log 2 n für alle n n 0 11 / 177 Asymptotische Notationen Im Unterschied zu den O-Klassen gilt bei den Θ-Klassen keine Inklusion. f (n) / Θ(n 5 ), denn es gibt kein c, n 0 mit c n 5 3n 4 + 5n log 2 n für alle n n 0 Aufgepasst: Zu gegebenem n 0 lässt sich immer ein c finden mit c n 5 0 n4 0 (etwa c = 1 n 0 ), aber dies gilt eben nie für alle n n / 177
7 Asymptotische Notationen Asymptotisch gesehen, betrachten wir f (n) = 3n 4 + 5n log 2 n als gleichwertig mit n / 177 Asymptotische Notationen Asymptotisch gesehen, betrachten wir f (n) = 3n 4 + 5n log 2 n als gleichwertig mit n 4. Die asymptotischen Effizienzklassen haben ungeheuer praktische Eigenschaften. 14 / 177
8 Asymptotische Notationen Eigenschaften der asymptotischen Klassen f Θ(f ) (Reflexivität) (1) f Θ(g) g Θ(h) f Θ(h) (Transitivität) (2) f Θ(g) g Θ(f ) (Symmetrie) (3) cf Θ(f ) (4) n a + n b Θ(n a ) für a > b (5) log a n Θ(log b n) (6) 15 / 177 Asymptotische Notationen Zur Übung sollte man einiger dieser Eigenschaften beweisen. Später geht man ganz routinemäßig damit um man nutzt Rechenregeln der Form anstelle der Aussage O(f ) O(g) = O(f g) h 1 O(f ) h 2 O(g) h 1 h 2 O(f g) (Natürlich meint (f g)(n) = f (n) g(n)) 16 / 177
9 Asymptotische Notationen In vielen Büchern wird kaum Θ, sondern hauptsächlich O-Notation verwendet. Man sucht die kleinste mögliche O-Klasse anzugeben, das heißt f O(g) meint f Θ(g), verzichtet aber auf den expliziten Nachweis der unteren Schranke. 17 / 177 Asymptotische Notationen Untere und obere asymptotische Schranken Manchmal gibt man untere und obere Schranken getrennt an, d.h. die O-Notation wird ergänzt durch Ω: Ω(g) = { f ( n 0, c)( n n 0 ) cg(n) f (n) } (7) In f O(g) nennt man g obere asymptotische Schranke von f. Bei f Ω(g) heißt g untere asymptotische Schranke von f. Klar: Θ(g) = Ω(g) O(g). 18 / 177
10 Effizienzanalyse Vorüberlegungen zur Effizienzanalyse Nicht für jedes mathematische Problem gibt es einen Algorithmus. Wenn es einen gibt, gibt es in der Regel beliebig viele. Alle (korrekten) Algorithmen für das Problem sind mathematisch äquivalent. 19 / 177 Effizienzanalyse Vorüberlegungen zur Effizienzanalyse Nicht für jedes mathematische Problem gibt es einen Algorithmus. Wenn es einen gibt, gibt es in der Regel beliebig viele. Alle (korrekten) Algorithmen für das Problem sind mathematisch äquivalent. Aus der Sicht der Informatik unterscheiden sie sich erheblich. 20 / 177
11 Effizienzanalyse Algorithmen sind immaterielle Produkte. Wenn sie arbeiten, brauchen sie Rechenzeit und belegen Speicherplatz im Rechner. Effizienzanalyse Die Effizienzanalyse betrachtet den Zeit- und Platzbedarf von Algorithmen und liefert analytische Qualitätsurteile (im Unterschied zu Messungen). 21 / 177 Effizienzanalyse Was sind geeignete Maßeinheiten? für Speicherplatz: Bits, Bytes, MB, Datenblöcke fester Größe für Rechenzeit: Befehlszyklen, Sekunden, Tage,..., Rechenschritte fester Dauer Das Maß sollte auf den Algorithmus bezogen sein, nicht einen bestimmten Rechner voraussetzen. Daher: Platz in Datenblöcken Zeit in (abstrakten) Rechenschritten messen 22 / 177
12 Effizienzanalyse Datenblöcke und Rechenschritte sind jeweils vernünftig zu wählen: Länge einer Liste (z.b. beim Sortieren) Größe einer Zahl (z.b. beim Wurzel ziehen oder einer Primzahlzerlegung) Abhängigkeit von Größe der Eingabe: Es ist klar, dass der gleiche Algorithmus kleinere Eingaben schneller verarbeitet als große. Wir setzen n als Größe der Eingabe gemessen in Datenblöcken und berechnen Platz und Zeit in Abhängigkeit von n. 23 / 177 Average Case und Worst Case Average Case und Worst Case Die tatsächliche Laufzeit ist auch manchmal auch abhängig von den genauen Daten. Das haben wir z.b. bei manchen Sortierverfahren festgestellt. Auch bei gegebener Eingabe-Größe kann also ein Algorithmus unterschiedlich lange rechnen oder Platz brauchen. Worst case Analyse: längstmögliche Rechenzeit für Eingabe der Größe n Average case Analyse: durchschnittliche Rechenzeit über alle Eingaben der Größe n 24 / 177
13 Average Case und Worst Case Worst case garantiert, dass der Bedarf nie höher ist als angegeben. Average case nimmt an, dass alle Eingaben gegebener Größe gleich wahrscheinlich sind, und kann daher täuschen. 25 / 177 Formalisierung Zusammenfassung und Formalisierung Gegeben Problem P, Algorithmus A, der P löst. Sei x die Eingabe für A, und x die Größe der Eingabe. Sei time A (x) Anzahl der Rechenschritte, space A (x) Anzahl der Datenblöcke die A zur Berechnung x benötigt. Effizienzaussagen hängen statt von x von n = x ab. 26 / 177
14 Formalisierung Worst-case Zeitkomplexität von A wc-time A (n) = max {x n= x } time A (x) 27 / 177 Formalisierung Worst-case Zeitkomplexität von A wc-time A (n) = max {x n= x } time A (x) Average-case Zeitkomplexität von A av-time A (n) = 1 {x n = x } {x n= x } time A (x) 28 / 177
15 Formalisierung Worst-case Zeitkomplexität von A wc-time A (n) = max {x n= x } time A (x) Average-case Zeitkomplexität von A av-time A (n) = 1 {x n = x } {x n= x } time A (x) Expected-time Zeitkomplexität von A exp-time A (n) = time A (x) Prob(x) {x n= x } Dabei ist Prob(x) die Wahrscheinlichkeit der Eingabe x. 29 / 177 Formalisierung Analog dazu die Platz- oder Speicherkomplexität: Worst-case Platzkomplexität von A wc-space A (n) = max {x n= x } space A (x) 30 / 177
16 Formalisierung Analog dazu die Platz- oder Speicherkomplexität: Worst-case Platzkomplexität von A wc-space A (n) = max {x n= x } space A (x) Average-case Platzkomplexität von A av-space A (n) = 1 {x n = x } {x n= x } space A (x) 31 / 177 Beispiele Beispiel: Funktion insert insert a [ ] = [a] insert a (x : xs) = if a x then a : x : xs else x : insert a xs Wir bestimmen Zeitbedarf für in Abhängigkeit von n = length x. insert a x 32 / 177
17 Beispiele Nur der Aufruf von insert hängt von n ab, die Anzahl der sonstigen Rechenschritte ist konstant. Wir annotieren das Programm insert a [ ] = [a] {c 1 } insert a (x : xs) = if a x then a : x : xs {c 2 } else x : insert a xs {c 3 } 33 / 177 Beispiele wc-time insert (n) = c 1 für n = 0 wc-time insert (n) = c 3 + wc-time insert (n 1) da der else-fall hier der worst case ist. Daraus erhalten wir wc-time insert (n) = c 1 + nc 3 34 / 177
18 Beispiele Für den average case kommt es darauf an, an welcher Position eingefügt wird. Wir nehmen an, alle Positionen sind gleich wahrscheinlich. Für gegebene Position ist Aufwand exakt berechenbar. 35 / 177 Beispiele Wir bestimmen time(n i) = a wird in Liste der Länge n nach Position i eingefügt, i = 0,..., n i = 0 time(n, 0) = c 1 1 i < n time(n, i) = i c 3 + c 2 time(n, n) = n c 3 + c 1 36 / 177
19 Beispiele Für den Durchschnitt betrachten wir die n + 1 gleich wahrscheinlichen Fälle av-time insert (n) = = = = 1 ( n 1 time(n, 0) + time(n, i) + time(n, n) ) n + 1 i=1 1 ( n 1 ) c1 + (i c 3 + c 2 ) + n c 3 + c 1 n + 1 i=1 1 ( n ) 2c1 + (n 1) c 2 + i c 3 n + 1 i=1 2 n + 1 c 1 + n 1 n + 1 c 2 + n 2 c 3 37 / 177 Beispiele Betrachtung für große n: lim n wc-time insert(n) n c 3 lim n av-time insert(n) n 2 c 3 Hieran sieht man (besser als an der genauen Laufzeitformel): Aufwand wächst linear mit Größe der Eingabe. c 3 ist der wesentliche konstante Faktor, der die Laufzeit bestimmt. 38 / 177
20 Beispiele Worst-case für insertion-sort: isort [ ] = [ ] {k 1 } isort (a : x) = insert a (isort x) {k 2 } wc-time isort (0) = k 1 wc-time isort (n + 1) = k 2 + wc-time insert (n) + wc-time isort (n) = n k 2 + k 1 + = n k 2 + k 1 + n i=1 wc-time insert (i) n (c 1 + i c 3 ) i=1 = n k 2 + k 1 + n c 1 + n(n + 1) c / 177 Beispiele wc-time isort (n) = n2 2 c 3 + n(c c 3 + k 2 ) + k 1 Also gilt hier wc-time isort (n) n2 2 c 3 für n Beachte: c 3 aus insert ist die einzige zeitkritische Konstante. 40 / 177
21 Beispiele Die genauen Konstanten c 1, c 2,... hängen ab von der konkreten Rechenmaschine, der Programmiersprache, dem Übersetzer. Sie sind aber jeweils konstant und daher durch Proportionalitätsfaktoren verknüpft. Z.B. 1 Funktionsaufruf in Haskell 30 Maschinenbefehle im 1 GHz Takt c Aufruf ˆ= 30 c Maschine ˆ= sec 41 / 177 Beispiele Platzbedarf für insert Hier gibt es keinen Unterschied im worst/average case. Wir setzen den Platzbedarf für ein Listenelement gleich c. space insert (0) = c space insert (n + 1) = (n + 2) c also space insert (n) = (n + 1) c für n 0 42 / 177
22 Beispiele Platzbedarf für isort space isort (0) = 0 space isort (n + 1) = space insert (n) + space isort (n) wäre falsch, denn die Speicherblöcke für insert und isort werden nicht gleichzeitig benötigt. Daher: space isort (n + 1) = max{space insert (n), space isort (n)} Also: space isort (n) = space insert (n 1) = n c 43 / 177 Asymptotische Effizienz-Analyse Die Komplexität eines Algorithmus A wird häufig nur bis auf konstante Faktoren bestimmt. Es interessiert (nur), ob wc-time A (n) n n log n n 2 2 n und so weiter Ebenso bei av-time A (n), wc-space A (n), av-space A (n). 44 / 177
23 Rückblick Betrachten wir die bisherigen Ergebnisse asymptotisch, so erhalten wir: wc-time insert av-time insert space insert Θ(n) Θ(n) Θ(n) wc-time isort Θ(n 2 ) space isort Θ(n) 45 / 177 Exakte vs. asymptotische Analyse Exakte versus asymptotische Analyse Die bisherige Effizienzanalyse war exakt wir konnten genau die Rolle der Komponenten c 1, c 2, c 3, k 1, k 2 bestimmen. 46 / 177
24 Exakte vs. asymptotische Analyse Exakte versus asymptotische Analyse Die bisherige Effizienzanalyse war exakt wir konnten genau die Rolle der Komponenten c 1, c 2, c 3, k 1, k 2 bestimmen. Erst am Ende haben wir das asymptotische Verhalten von wc-time insert etc. betrachtet. 47 / 177 Exakte vs. asymptotische Analyse Exakte versus asymptotische Analyse Die bisherige Effizienzanalyse war exakt wir konnten genau die Rolle der Komponenten c 1, c 2, c 3, k 1, k 2 bestimmen. Erst am Ende haben wir das asymptotische Verhalten von wc-time insert etc. betrachtet. Die Analyse läßt sich aber auch von vornherein asymptotisch durchführen. 48 / 177
25 Exakte vs. asymptotische Analyse wc-time insert Θ(n) also setzen wir 49 / 177 Exakte vs. asymptotische Analyse wc-time insert Θ(n) also setzen wir wc-time insert (n) = n 50 / 177
26 Exakte vs. asymptotische Analyse wc-time insert Θ(n) also setzen wir wc-time insert (n) = n Wir setzen k 1 = 0 durch Wahl von n. Wir setzen k 2 = 1 durch Wahl von c und C. Damit vereinfacht sich die Gleichung zu wc-time isort (n + 1) = n k 2 + k 1 + n i=1 wc-time isort (n + 1) = n + wc-time isort (n + 1) = n + wc-time insert (i) n i i=1 n(n + 1) 2 Θ(n 2 ) 51 / 177 Exakte vs. asymptotische Analyse Überlegung Zu den gleichen asymptotischen Ergebnissen kommen wir, wenn wir in der Analyse nur die Vergleichsoperationen auf Listenelementen zählen. 52 / 177
27 Exakte vs. asymptotische Analyse Überlegung Zu den gleichen asymptotischen Ergebnissen kommen wir, wenn wir in der Analyse nur die Vergleichsoperationen auf Listenelementen zählen. Warum? 53 / 177 Charakteristische Operation Definition. Eine Operation p eines Algorithmus A ist charakteristisch für die asymptotische Laufzeit, wenn wc-time p_in_a (n) Θ(wc-time A (n)). (Beachte: dann gilt auch die Umkehrung.) Lemma. Eine Operation p in A ist charakteristisch, genau dann, wenn für alle anderen Operationen q gilt wc-time q_in_a (n) O(wc-time p_in_a (n)). 54 / 177
28 Charakteristische Operation Beispiel: In einem Sortierprogramm kommen (:)- und (<)-Operationen vor. Ab n > n 0 gilt: Anzahl(:) 10 Anzahl(<). Also genügt es, die Anzahl der (<)-Operationen zu analysieren. 55 / 177 Charakteristische Operation Zwischenfazit Die Effizienzanalyse wird durch die asymptotische Betrachtungsweise stark vereinfacht. Das wesentliche Problem ist das folgende: Wir müssen die Definition von f (x) in Rekurrenzgleichungen für wc-time( x ) übersetzen können: wc-time A (n) = Ausdruck, der wc-time A enthält. Diese müssen nach wc-time A aufgelöst werden, was nicht immer einfach ist. 56 / 177
29 Aufgabe Zahlenspiel Das Spiel wird paarweise gespielt. Suche Dir bitte einen Sitznachbarn, mit dem Du das Spiel spielen kannst. 57 / 177 Aufgabe Zahlenspiel Das Spiel wird paarweise gespielt. Suche Dir bitte einen Sitznachbarn, mit dem Du das Spiel spielen kannst. Einer von euch denkt sich jetzt eine Zahl zwischen 0 und / 177
30 Aufgabe Zahlenspiel Das Spiel wird paarweise gespielt. Suche Dir bitte einen Sitznachbarn, mit dem Du das Spiel spielen kannst. Einer von euch denkt sich jetzt eine Zahl zwischen 0 und 255. Der andere muss versuchen, die Zahl zu erraten. Er darf aber nur Ja/Nein-Fragen stellen. Versucht, so wenig Fragen wie möglich zu stellen. 59 / 177 Aufgabe Zahlenspiel Das Spiel wird paarweise gespielt. Suche Dir bitte einen Sitznachbarn, mit dem Du das Spiel spielen kannst. Einer von euch denkt sich jetzt eine Zahl zwischen 0 und 255. Der andere muss versuchen, die Zahl zu erraten. Er darf aber nur Ja/Nein-Fragen stellen. Versucht, so wenig Fragen wie möglich zu stellen. Wie viele Fragen musstet ihr stellen? 60 / 177
31 Effizienz von Algorithmen Asymptotische Effizienz-Analyse Exkurs Beispiel zur Effizienanalyse Ausn Binärer Baum Ja/Nein Fragen führen zu binären Entscheidungen <128 <32 00 <64 <96 < <192 < / 177 Effizienz von Algorithmen Asymptotische Effizienz-Analyse Exkurs Beispiel zur Effizienanalyse Ausn Binärer Baum Ja/Nein Fragen führen zu binären Entscheidungen <128 < <64 <96 <160 <192 <224 Für eine optimale Strategie, muss der Problemraum systematisch aufgeteilt werden / 177
32 Effizienz von Algorithmen Asymptotische Effizienz-Analyse Exkurs Beispiel zur Effizienanalyse Ausn Binärer Baum Ja/Nein Fragen führen zu binären Entscheidungen <128 <32 <64 <96 <160 <192 <224 Für eine optimale Strategie, muss der Problemraum systematisch aufgeteilt werden Die Fragen verästeln sich wie in einem Baum (hier auf dem Kopf) / 177 Effizienz von Algorithmen Asymptotische Effizienz-Analyse Exkurs Beispiel zur Effizienanalyse Ausn Binärer Baum Ja/Nein Fragen führen zu binären Entscheidungen <128 <32 <64 <96 <160 <192 <224 Für eine optimale Strategie, muss der Problemraum systematisch aufgeteilt werden Die Fragen verästeln sich wie in einem Baum (hier auf dem Kopf) Der Pfad im Baum kann binär kodiert werden (0 = links, 1 = rechts). Im Beispiel entspricht er der binären Repräsentation der Zahl 64 / 177
33 Überlegungen Die Länge des Pfades nennen wir Tiefe. 65 / 177 Überlegungen Die Länge des Pfades nennen wir Tiefe. Die Länge des längsten Pfades ist die maximale Tiefe des Baumes. 66 / 177
34 Überlegungen Die Länge des Pfades nennen wir Tiefe. Die Länge des längsten Pfades ist die maximale Tiefe des Baumes. Der Startpunkt (Kreis ohne Vorgänger) heißt Wurzel. 67 / 177 Überlegungen Die Länge des Pfades nennen wir Tiefe. Die Länge des längsten Pfades ist die maximale Tiefe des Baumes. Der Startpunkt (Kreis ohne Vorgänger) heißt Wurzel. Dass die Werte kontinuierlich sind, spielt eigentlich keine Rolle. 68 / 177
35 Überlegungen Die Länge des Pfades nennen wir Tiefe. Die Länge des längsten Pfades ist die maximale Tiefe des Baumes. Der Startpunkt (Kreis ohne Vorgänger) heißt Wurzel. Dass die Werte kontinuierlich sind, spielt eigentlich keine Rolle. Wichtig für die Entscheidungsfindung ist, dass wir eine totale Ordnung haben (siehe Kapitel zur Wohlfundierten Rekursion). 69 / 177 Überlegungen Die Länge des Pfades nennen wir Tiefe. Die Länge des längsten Pfades ist die maximale Tiefe des Baumes. Der Startpunkt (Kreis ohne Vorgänger) heißt Wurzel. Dass die Werte kontinuierlich sind, spielt eigentlich keine Rolle. Wichtig für die Entscheidungsfindung ist, dass wir eine totale Ordnung haben (siehe Kapitel zur Wohlfundierten Rekursion). Bäume könnten auch eine interessante Datenstruktur abgeben / 177
36 Effizienz von Algorithmen Asymptotische Effizienz-Analyse Exkurs Beispiel zur Effizienanalyse Ausn Eine Datenstruktur für binäre Bäume Die Fragen stellen wir uns an den Verzeigungen (hier Kreise) <128 <32 00 <64 <96 < <192 < / 177 Effizienz von Algorithmen Asymptotische Effizienz-Analyse Exkurs Beispiel zur Effizienanalyse Ausn Eine Datenstruktur für binäre Bäume Die Fragen stellen wir uns an den Verzeigungen (hier Kreise) <128 < <64 <96 <160 <192 <224 Die Zahlen, unsere Daten, stehen an den Blättern (hier Kästen) / 177
37 Effizienz von Algorithmen Asymptotische Effizienz-Analyse Exkurs Beispiel zur Effizienanalyse Ausn Eine Datenstruktur für binäre Bäume Die Fragen stellen wir uns an den Verzeigungen (hier Kreise) <128 <32 00 <64 <96 <160 <192 <224 Die Zahlen, unsere Daten, stehen an den Blättern (hier Kästen) Theoretisch sollte es auch unbeschriftete Blätter geben (kommt hier nicht vor). Warum? / 177 Effizienz von Algorithmen Asymptotische Effizienz-Analyse Exkurs Beispiel zur Effizienanalyse Ausn Eine Datenstruktur für binäre Bäume Die Fragen stellen wir uns an den Verzeigungen (hier Kreise) <128 < <64 <96 <160 <192 <224 Die Zahlen, unsere Daten, stehen an den Blättern (hier Kästen) Theoretisch sollte es auch unbeschriftete Blätter geben (kommt hier nicht vor). Warum? Antwort: man möchte z.b. auch ungerade Anzahlen an Blättern repräsentieren können. 74 / 177
38 Bäume in Haskell data Tree a = Nil Leaf a Br (Tree a) (Tree a) deriving Show Der Typ Tree umfasst binäre Bäume über dem Grundtyp a. Ein Baum ist entweder leer (unbeschriftetes Blatt Nil), enthält ein Blatt mit Daten (Leaf a), oder verzweigt sich in zwei Teilbäume (Br). 75 / 177 Fragen Wie viele Blätter n gibt es maximal bis Tiefe t? 76 / 177
39 Fragen Wie viele Blätter n gibt es maximal bis Tiefe t? Wenn ein Baum n Blätter hat, wie tief kann er dann maximal sein? 77 / 177 Fragen Wie viele Blätter n gibt es maximal bis Tiefe t? Wenn ein Baum n Blätter hat, wie tief kann er dann maximal sein? Wie ist das Verhältnis von Br zu Leaf Knoten? 78 / 177
40 Überlegungen Listen sind sehr kompakte Repräsentationen im Speicher und wir haben interessante Funktionen auf Listen bereits definiert. 79 / 177 Überlegungen Listen sind sehr kompakte Repräsentationen im Speicher und wir haben interessante Funktionen auf Listen bereits definiert. Für bestimmte Fragestellungen scheinen sich Bäume besonders gut zu eignen. 80 / 177
41 Überlegungen Listen sind sehr kompakte Repräsentationen im Speicher und wir haben interessante Funktionen auf Listen bereits definiert. Für bestimmte Fragestellungen scheinen sich Bäume besonders gut zu eignen. Kann man die beiden Datentypen ineinander überführen? 81 / 177 Tree and back again... Für die Überführung von Listen in Bäume brauchen wir eine Funktion build :: [a] -> Tree a 82 / 177
42 Tree and back again... Für die Überführung von Listen in Bäume brauchen wir eine Funktion build :: [a] -> Tree a Und für die Überführung von Bäumen in Listen etwa leaves :: Tree a -> [a] 83 / 177 Naiver Ansatz für leaves, ganz entlang einer Strukturellen Rekursion auf Bäumen: leaves :: Tree a -> [a] leaves Nil = [] leaves (Leaf a) = [a] leaves (Br l r) = leaves l ++ leaves r 84 / 177
43 Naiver Ansatz für leaves, ganz entlang einer Strukturellen Rekursion auf Bäumen: leaves :: Tree a -> [a] leaves Nil = [] leaves (Leaf a) = [a] leaves (Br l r) = leaves l ++ leaves r Betrachten wir einmal die Zahl der Rechenschritte unserer naiven Implementierung. 85 / 177 Naiver Ansatz für leaves, ganz entlang einer Strukturellen Rekursion auf Bäumen: leaves :: Tree a -> [a] leaves Nil = [] leaves (Leaf a) = [a] leaves (Br l r) = leaves l ++ leaves r Betrachten wir einmal die Zahl der Rechenschritte unserer naiven Implementierung. wc-time leaves (n) = n 2 86 / 177
44 Naiver Ansatz für leaves, ganz entlang einer Strukturellen Rekursion auf Bäumen: leaves :: Tree a -> [a] leaves Nil = [] leaves (Leaf a) = [a] leaves (Br l r) = leaves l ++ leaves r Betrachten wir einmal die Zahl der Rechenschritte unserer naiven Implementierung. wc-time leaves (n) = n 2 Diese Funktion leaves ist also sehr teuer bezüglich der Rechenzeit. 87 / 177 Ansatz unter Vermeidung der Listenkonkatenation: leaves :: Tree a -> [a] leaves Nil = [] leaves (Leaf a) = [a] leaves (Br Nil r) = leaves r leaves (Br (Leaf a) r) = a:leaves r 88 / 177
45 Ansatz unter Vermeidung der Listenkonkatenation: leaves :: Tree a -> [a] leaves Nil = [] leaves (Leaf a) = [a] leaves (Br Nil r) = leaves r leaves (Br (Leaf a) r) = a:leaves r Was machen wir, wenn links ebenfalls ein Branch hängt? Idee: wir wandeln den Branch um in ein einfacheres Problem! leaves (Br (Br l r ) r) = leaves (Br l (Br r r)) 89 / 177 Exkurs Bäume Ende... und nun zurück zum Thema 90 / 177
46 Als nächstes (interessanteres) Beispiel betrachten wir das Programm sorttree. Es berechnet die sortierte Liste der Blätter eines Baumes: sorttree :: Tree Integer -> [Integer] sorttree Nil = [] sorttree (Leaf a) = [a] sorttree (Br l r) = merge (sorttree l) (sorttree r) merge :: (Ord a) => OrdList a -> OrdList a -> OrdList a merge [] bs = bs merge as [] = as merge (a:as) (b:bs) a <= b = a:merge as (b:bs) otherwise = b:merge (a:as) bs 91 / 177 Seien m und n die Längen der Eingabelisten. Wir betrachten zuerst wc-time merge. ist die charakteristische Operation. Im worst case werden beide Listen wie ein Reißverschluss zusammengeführt. Also wc-time merge (m, n) = m + n 1 Θ(m + n) 92 / 177
47 Wie beschreibt man den worst-case genau? merge (as, bs) [, a m, b n ] oder [, b n, a m ] Alle Elemente (bis auf das letzte) werden vor dem Einbau verglichen. 93 / 177 Nun folgt die Analyse von sorttree. Wir betrachten nun Bäume mit n Blättern: 94 / 177
48 Die Aufrufe von merge ergeben sich aus der Baumstruktur 95 / 177 Zwischenbeobachtung: In der Tat kann man so rechnen, dass die merge-bäume als Zwischenergebnisse auftreten. Man wendet überall die Gleichungen von sorttree an und keine anderen. Damit ist auch der Aufwand bis zu diesem Punkt bekannt n 1 innere Knoten (Br) erfordern genau n 1 Gleichungsanwendungen, unabhängig von der Form des Baums. 96 / 177
49 Die gleiche Betrachtung an isort[4, 2, 3, 1] ergibt das Zwischenergebnis: insert 4 insert 2 insert 3 insert 1 [ ] Worin liegt noch der Unterschied zwischen isort und sorttree bei Listen-ähnlichem Baum? 97 / 177 Betrachtet man den Rechenaufwand für die merge-phase ergibt sich: bzw. Resultat: = = 5 98 / 177
50 Betrachtet man den Rechenaufwand für die merge-phase ergibt sich: bzw. Resultat: = = 5 Wir müssen also davon ausgehen, dass wc-time sorttree von der Form des Baumes abhängt. 99 / 177 Die Größe der Daten n für sorttree(t) können wir beschreiben durch die Anzahl size(t) der Blätter von t (Form unbeschränkt, aber die Tiefe muss dann zwischen log 2 n und size(t) liegen) die Tiefe depth(t) des Baumes t (die Anzahl der Blätter ist damit beschränkt durch 2 depth(t) ) Wir untersuchen beide Varianten. 100 / 177
51 Untersuchung basierend auf size Untersuchung ausgehend von size(t) Sei n = size (t) wc-time sorttree (1) = 0 wc-time sorttree (n) = n 1 + max { wc-time sorttree (i)+ wc-time sorttree (n i) 0 < i < n } Wie kommen wir weiter? 101 / 177 Untersuchung basierend auf size Wir programmieren wc-time sorttree in Haskell und tabellieren: n wc-time sorttree (n) / 177
52 Untersuchung basierend auf size Wir programmieren wc-time sorttree in Haskell und tabellieren: n wc-time sorttree (n) Das sieht aus wie 1 2n(n 1). 103 / 177 Untersuchung basierend auf size In der Tat der schlechteste Fall tritt auf für i = 1 und i = n 1 das sind entartete Baum, etwa wc-time sorttree (n) = 1 2 n(n 1) Θ(n2 ) 104 / 177
53 Untersuchung ausgehend von depth Untersuchung ausgehend von depth(t) Sei d = depth(t) wc-time sorttree (0) = 0 wc-time sorttree (d + 1) = 2 d wc-time sorttree (d) wc-time sorttree (d) = d i=1 2d i (2 i 1) = d i=1 (2d 2 d i ) = d2 d 2 d + 1 Θ(d2 d ) Schlechtester Fall: ausgeglichener Baum. Dieser hat n = 2 d Blätter, wir haben also wc-time sorttree (n) Θ(n log 2 n) das ist besser als Θ(n 2 ) wie zuvor ermittelt. 105 / 177 Untersuchung ausgehend von depth Sei n Anzahl der Blätter, d die Tiefe von t. Wir haben erhalten: wc-time sorttree (n) Θ(n 2 ) wc-time sorttree (d) Θ(2 d d) Im ersten Fall ist im worst-case d = n. Im zweiten Fall ist im worst-case n = 2 d. Beide Analysen zusammengenommen: wc-time sorttree (n, d) Θ(n d) 106 / 177
54 Untersuchung ausgehend von depth Konsequenz: sorttree ist asymptotisch schneller als insertion sort, sofern der Baum ausgeglichen ist: Dann ist d = log 2 n. 107 / 177 Untersuchung ausgehend von depth Konsequenz: sorttree ist asymptotisch schneller als insertion sort, sofern der Baum ausgeglichen ist: Dann ist d = log 2 n. Können wir aus einer (unsortierten) Liste l in Θ(n log n) Zeit oder schneller einen ausgeglichenen Baum aufbauen ( Funktion build)? 108 / 177
55 Untersuchung ausgehend von depth Konsequenz: sorttree ist asymptotisch schneller als insertion sort, sofern der Baum ausgeglichen ist: Dann ist d = log 2 n. Können wir aus einer (unsortierten) Liste l in Θ(n log n) Zeit oder schneller einen ausgeglichenen Baum aufbauen ( Funktion build)? Dann erhalten wir durch sorttree(build(l)) ein schnelleres Sortierverfahren in Θ(n log n). 109 / 177 build Aufbau eines ausgeglichenen Baums build :: [a] -> Tree a build [] = Nil build [a] = Leaf a build as = Br (build (take k as))(build (drop k as)) where k = length as div / 177
56 build Aufbau eines ausgeglichenen Baums build :: [a] -> Tree a build [] = Nil build [a] = Leaf a build as = Br (build (take k as))(build (drop k as)) where k = length as div 2 Auch dieser naive Ansatz (wie bei leaves) ist recht teuer... warum? 111 / 177 build Aufbau eines ausgeglichenen Baums build :: [a] -> Tree a build [] = Nil build [a] = Leaf a build as = Br (build (take k as))(build (drop k as)) where k = length as div 2 Auch dieser naive Ansatz (wie bei leaves) ist recht teuer... warum? In der letzten Definition werden die as mehrfach durchlaufen (length, take, drop). 112 / 177
57 build Asymptotische Effizienz von build Zählen wir (wie bisher) nur die Vergleichsoperationen, so gilt: wc-time build (m) = 0 Was stimmt hier nicht? 113 / 177 build Asymptotische Effizienz von build Zählen wir (wie bisher) nur die Vergleichsoperationen, so gilt: Was stimmt hier nicht? wc-time build (m) = 0 Der Vergleich ist nicht charakteristische Operation für build. Also zählen wir die Schritte für take, drop, length, build. 114 / 177
58 build wc-time take (k, n) = k Θ(n) wc-time drop (k, n) = k Θ(n) wc-time length (n) = n + 1 Θ(n) wc-time build (0) = 1 wc-time build (n) = n n + 2 wc-time build (n/2) = 3n (n/ n/2 +2 wc-time build (n/4)) 115 / 177 build Insgesamt kann (log 2 n)-mal halbiert werden, jedesmal kommt ein Beitrag in Θ(n) hinzu, also wc-time build (n) Θ(n log n) 116 / 177
59 build Ergebnis: Ein schnelles Sortierverfahren mergesort :: [a] OrdList a mergesort = sorttree.build wc-time mergesort (n) Θ(n log n) 117 / 177 build Vergleich des asymptotischen Wachstums: n n log 2 n n , , , , mergesort ist also wesentlich effizienter als insertionsort. 118 / 177
60 build Lässt sich mergesort weiter verbessern? 119 / 177 build Lässt sich mergesort weiter verbessern? Aber worauf sollen wir abzielen bessere konstante Faktoren bei Laufzeit Θ(n log n)? bessere asymptotische Laufzeit, etwa Θ(n) oder Θ(n log(log n))? 120 / 177
61 build Problemkomplexität Definition Die algorithmische Komplexität eines Problems P ist die Effizienzklasse des besten Algorithmus, der P löst. Beste meint hier: niedrigste asymptotische worst-case-laufzeit. Das ist in der Regel eine Klasse von Algorithmen mit unterschiedlichen konstanten Faktoren. 121 / 177 build Kochrezept zum Nachweis von: P hat Komplexität Θ(f ) 1 Angabe eines Algorithmus A für P mit wc-time A Θ(f ) 2 Zeigen, dass jeder Algorithmus für P mindestens Θ(f ) Schritte rechnen muss. 122 / 177
62 Beispiel Satz: Sortieren durch Vergleichen (wir hatten (<) als charakteristische Operation) hat Problemkomplexität Θ(n log n). Zu beweisen: Wir müssen zeigen: Jeder Algorithmus braucht mindestens Θ(n log n) Vergleiche. 123 / 177 Beispiel Was leistet eigentlich ein Vergleich, gegeben n ungeordnete Daten? 124 / 177
63 Beispiel Was leistet eigentlich ein Vergleich, gegeben n ungeordnete Daten? Entscheidungsbäume 125 / 177 Beispiel Was leistet eigentlich ein Vergleich, gegeben n ungeordnete Daten? Entscheidungsbäume a1<=a2 a1<=a2 [a1,a2] [a2,a1] a1<=a3 a2<=a3 a2<=a3 [a3,a1,a2] a1<=a3 [a3,a2,a1] [a1,a2,a3] [a1,a3,a2] [a2,a1,a3] [a2,a3,a1] Ein Vergleich scheidet die möglichen Permutationen der Eingabedaten in zwei Hälften. 126 / 177
64 Beispiel Eine Liste mit n Elementen hat n! Permutationen. Wir kennen daher die Mindest-Tiefe des Entscheidungsbaums. Also gilt: Time sort (n) log 2 (n!) 127 / 177 Beispiel Eine Liste mit n Elementen hat n! Permutationen. Wir kennen daher die Mindest-Tiefe des Entscheidungsbaums. Also gilt: Time sort (n) log 2 (n!) Die Fakultätsfunktion lässt sich mit der Stirlingschen Formel abschätzen: n! ( n ) n 2πn. e 128 / 177
65 Beispiel Insgesamt erhalten wir: ( ( Time sort (n) log 2 2πn n ) ) n e = log 2 2πn + log2 ( n e ) n = log 2 (2πn) 1/2 + log 2 ( n e ) n = 1 2 log 2 (2πn) + n log 2 n e = 1 2 log 2 (2π) log 2 n + n log 2 n n log 2 e Θ(n log n) 129 / 177 Zusammenfassung Der Weg zu einer guten Problemlösung 1 Man verschafft sich Klarheit über die Komplexität des zu lösenden Problems. 2 Man entwickelt einen Algorithmus, dessen Effizienz in der Klasse der Problemkomplexität liegt. Asymptotisch gesehen, ist dieser bereits optimal. 3 Man analysiert die konstanten Faktoren des Algorithmus und sucht diese zu verbessern. 130 / 177
66 Zusammenfassung Programmoptimierung am Beispiel mergesort Unter Optimierung von Programmen versteht man im Allgemeinen die Verbesserung der konstanten Faktoren. (Verbessert sich die asymptotische Effizienzklasse, spricht man eher von einem Redesign des Algorithmus.) Wir bilden Varianten von build und vergleichen die konstanten Faktoren. 131 / 177 Zusammenfassung build :: [a] -> Tree a build [] = Nil build [a] = Leaf a build (as) = Br (build (take k as)) (build (drop k as)) where k = length as div / 177
67 Zusammenfassung build :: [a] -> Tree a build [] = Nil build [a] = Leaf a build (as) = Br (build (take k as)) (build (drop k as)) where k = length as div 2 Die Neuberechnung der Listenlänge (length) kostet Θ(n log n) Schritte! 133 / 177 Zusammenfassung Eine Funktion mit zusätzlichem Parameter ( Einbettung) hilft, die Neuberechnung der Länge vermeiden: build :: [a] -> Tree a build as = buildn (length as) as where buildn :: Int -> [a] -> Tree a buildn 1 (a:as) = Leaf a buildn n as = Br (buildn k (take k as)) (buildn (n-k) (drop k as)) where k = n div 2 Jedoch: auch take und drop erzeugen Aufwand der Ordnung Θ(n log n). 134 / 177
68 Zusammenfassung Überlegung: Die n Elemente der Eingabe werden dauernd in immer kleinere Listen gepackt, um am Ende in den Baum gehängt zu werden. Können wir diese Listen vermeiden, und jedes Element der Eingabe nur einmal anfassen, wenn es in den Baum gehängt wird? 135 / 177 Zusammenfassung Idee: Jeder Aufruf von build nimmt von der Liste was er braucht, und reicht den Rest unbesehen weiter: build :: [a] -> Tree a build as = fst (buildsplit (length as) as) buildsplit 1 (a:as) = (Leaf a, as) buildsplit n as = (Br l r, as ) where k = n div 2 (l,as ) = buildsplit k as (r,as ) = buildsplit (n-k) as 136 / 177
69 Zusammenfassung Analyse: wc-time buildsplit (n) = 6 + wc-time buildsplit ( n/2 ) + wc-time buildsplit ( n/2 ) wc-time buildsplit (1) = 6 (Die zweite 6 ist etwas zu hoch, vereinfacht aber die Rechnung.) Für n = 2 k : wc-time buildsplit (2 k ) = 6(2 k+1 1) = 12n 6 Θ(n) 137 / 177 Zusammenfassung Ergebnis für mergesort: Wir haben die Effizienz der build-phase von Θ(n log n) nach Θ(n) verbessert. 138 / 177
70 Zusammenfassung Ergebnis für mergesort: Wir haben die Effizienz der build-phase von Θ(n log n) nach Θ(n) verbessert. An der asymptotischen Effizienz von mergesort ändert sich dadurch nichts, da die sorttree-phase in Θ(n log n) bleibt. Aber besser als Θ(n log n) geht ja auch nicht / 177 Zusammenfassung Weitere Vereinfachung: Wir brauchen build, um einen ausgeglichenen Baum aus der Eingabeliste zu machen. Der Baumstruktur entspricht genau die Aufrufstruktur von merge. Wir können den Baum ganz eliminieren (Stichwort Deforestation ). Wir nehmen die Definition von mergesort und rechnen den Baum weg: 140 / 177
71 Zusammenfassung mergesort [] = sorttree (build []) = sorttree Nil = [] mergesort [a] = sorttree (build [a]) = sorttree (Leaf a) = [a] mergesort (as) = sorttree (build as) = sorttree Br (build (take k as)) (build (drop k as))) where k = length as div 2 = merge (sorttree (build (take k as)) sorttree (build (drop k as))) where k = length as div 2 = merge (mergesort (take k as) mergesort (drop k as)) where k = length as div / 177 Zusammenfassung Übrig bleibt also mergesort [] = [] mergesort [a] = [a] mergesort (as) = merge (mergesort (take k as)) (mergesort (drop k as)) where k = length as div 2 Dieser mergesort baut keinen Baum auf. Die zuvor untersuchten Verbesserungen von build sollte man auch hier wieder untersuchen. 142 / 177
72 Zusammenfassung Vergleicht einmal den Effekt: mtest = mergesort [ ] für die alte und neue Version von mergesort. 143 / 177 Ausnutzen von erwarteten Daten-Eigenschaften In den obigen Testbeispielen ist die Eingabe-Liste bereits sortiert wovon unser Programm aber wenig mitkriegt. Wir suchen eine Variante von mergesort, die umso schneller wird, je mehr die Eingabe vorsortiert ist. 144 / 177
73 Idee: Ausnutzung von Läufen (Runs) von vorsortierten Elementen (aufsteigend oder absteigend). Problem: Top-Down Baumkonstruktion zerstört die Läufe. Lösung: Wir bestimmen erst die Läufe und bauen aus ihnen den Baum. 145 / 177 Läufe sind auf- oder absteigende Folgen. Über die Richtung entscheidet das zweite Element / 177
74 runs :: [a] -> [[a]] runs [] = [[]] runs [a] = [[a]] runs (a:b:x) = if a<=b then ascrun b [a] x else descrun b [a] x ascrun, descrun :: a -> [a] -> [a] -> [[a]] ascrun a as [] = [reverse (a:as)] ascrun a as (b:y) = if a<=b then ascrun b (a:as) y else reverse (a:as):runs (b:y) descrun a as [] = [a:as] descrun a as (b:y) = if a<=b then (a:as):runs (b:y) else descrun b (a:as) y 147 / 177 Nun wird ein ausgeglichener Baum aufgebaut, an dessen Blättern die Läufe stehen. Er hat also den Typ Tree[a] statt Tree a. Trotzdem können wir die schon bekannte Θ(n) build-funktion einsetzen für diese ist n nun die Anzahl der Läufe! 148 / 177
75 Das Programm smoothsort: smsort :: Ord a => [a] -> [a] smsort = mergeruns. build. runs mergeruns :: Ord a => Tree [a] -> [a] mergeruns (Leaf x) = x mergeruns (Br l r) = merge (mergeruns l) (mergeruns r) 149 / 177 Sortieren in Θ(n) Eine Funktion sort :: Ord(a) [a] OrdList a kann es nicht geben mit Effizienz Θ(n). Einzige vorausgesetzte Operationen auf dem Datentyp a sind ja die Vergleichsoperationen der Typklasse Ord. Wissen wir mehr über den Typ a, lässt sich dies vielleicht ausnutzen. 150 / 177
76 Dazu brauchen wir aus der Haskell-Vorlesung die Typklasse (Ix a) (Index-Typen) den Datentyp Array a b (mit Index-Typ a und Elementtyp b Das Besondere an Arrays: Elementzugriff Array t : t!i Θ(1) im Unterschied zu Liste l : l!!i Θ(i) 151 / 177 Idee des Counting-Sort: Alle Elemente liegen in einem begrenzten Intervall. Wir zählen, wie oft jeder Wert vorkommt. Wir reproduzieren alle Werte in aufsteigender Reihenfolge und korrekter Anzahl. 152 / 177
77 Beispiel: Eingabe bacaabfdfabaf Intervall: [a..f] Tabelle Ausgabe: aaaaabbbcdfff Anzahl a b c d e f 153 / 177 Effizienz Der Aufbau der Tabelle sowie die Erzeugung der sortierten Ausgabe lassen sich in Θ(n) bewerkstelligen. CountingSort ist ein lineares Sortierverfahren Haskell-Code: import Array countingsort :: Ix a => (a,a) -> [a] -> [a] countingsort bs x = [ a (a,n) <- assocs t, i <- [1..n]] where t = accumarray (+) 0 bs [(a,1) a <- x, inrange bs a] 154 / 177
78 In den Beispielen dieses Kapitels sehen wir ein typisches Vorgehen der Informatik: Der Informatiker analysiert die Komplexität seiner Probleme und der Problemlösungen. Dabei werden auch absolute oder quantitative Grenzen der Lösbarkeit nachgewiesen. Diese werden anschließend durch Modifikation der Problemstellung umgangen. 155 / 177 Effekte der Laziness Was wir bisher über Effizienzanalyse und Komplexität gelernt haben, gilt für alle Programmiersprachen. Schließlich gibt es immer eine geeignete abstrakte Einheit Rechenschritt, auf der die Analyse aufbaut. 156 / 177
79 Eine Besonderheit gilt für Haskell als eine Programmiersprache, in der das Prinzip der Lazy Evaluation (verzögerte Auswertung) realisiert ist. Die bisherige Analyse ging davon aus, dass es bei jedem Aufruf, z.b. isort x, stets das ganze Ergebnis berechnet wird. Laziness kann dazu führen, dass auch weniger gerechnet wird. 157 / 177 Grundbegriffe zu Auswertungs-Strategien: Rechnen = Anwenden von Gleichungen in Formeln Redex = reducible expression: Stelle in einer Formel, an der die linke Seite einer Gleichung passt passt = die auf der linken Seite verlangten Konstruktoren der Argumente liegen vor 158 / 177
80 Beispiel: head (x:xs) = x ist anwendbar auf die Formel und ergibt head (1:2:2:[]) => 1 head (1:([3,4]++[5,6])) => 1 head ((1+4):[5]) => (1+4) head (1:ones) where ones = 1:ones => 1 ist (noch) nicht anwendbar auf head ([1,3,4] ++ [5,6]) head (map (1+) [1,2,3]) head ones where ones = 1:ones Es muss erst eine Gleichung für (++), map oder ones angewandt werden. 159 / 177 Lage von Redexen in einer Formel Ein Redex ist innermost, wenn er keinen weiteren Redex enthält, outermost, wenn er in keinem weiteren Redex enthalten ist, zwischendrin, sonst. 160 / 177
81 Beispiel 161 / 177 Auswertungs-Strategien leftmost innermost: immer den Redex wählen, der am weitesten links steht und innermost ist. leftmost outermost: immer den Redex wählen, der am weitesten links steht und outermost ist. gemischt: man kann sich viele weitere Strategien vorstellen / 177
82 Besonderheit von if_then_else: Seine definierenden Gleichungen sind Ein Redex if True then x else y = x if False then x else y = y wird in jedem Fall leftmost outermost berechnet. Je nach Ergebnis für C wird A oder B nicht berechnet. 163 / 177 Diese Regel für if_then_else gilt in allen Programmiersprachen. Ohne sie könnte man keine terminierende Rekursion programmieren: f (x) = if_then_else(x 0, 42, 2 + f (x 1)) Innermost-Strategie führt zu endloser Berechnung des else-falles. Auch wenn die Bedingung gerne in mix-fix Schreibweise daherkommt: f (x) = if x 0 then 42 else 2 + f (x 1) sollte man nicht verkennen, dass es sich dabei um eine dreistellige Funktion handelt, die NICHT innermost berechnent wird. 164 / 177
83 Eigenschaften der Strategien 1 Ob eine Rechnung terminiert, hängt i.a. von der Strategie ab. 2 Wenn zwei verschiedene Strategien, angewandt auf die gleiche Formel, terminieren, liefern sie das gleiche Ergebnis. 3 Im Fall (2) kann sich der Rechenaufwand stark unterscheiden. 4 Wenn für eine Formel F irgendeine Strategie terminiert, dann terminiert für F auch leftmost outermost. 5 leftmost innermost terminiert seltener als leftmost outermost. 165 / 177 Anschauliche Bedeutung innermost: Alle Argumente einer Funktion werden ganz ausgerechnet, bevor die Funktion aufgerufen wird. outermost: Die Argumente einer Funktion werden immer nur so weit ausgerechnet, wie es die Funktion für ihren nächsten Schritt braucht. 166 / 177
84 Lazy Evaluation Haskell verwendet lazy evaluation (verzögerte Auswertung), das ist leftmost outermost + graph reduction graph reduction ist eine Zusatzregel, die die Duplikation unausgerechneter Formeln vermeidet. 167 / 177 Beispiel zur graph reduction twice x = x x twice (3 + 4) outermost innermost würde blindlings outermost reduziert zu (3 + 4) (3 + 4) wo nun der Ausdruck (3 + 4) zweimal berechnet werden müsste. 168 / 177
85 Stattdessen wird reduziert twice (3 + 4) x x where x = worin durch die Nebenrechnung nur einmal berechnet wird. 169 / 177 Einfluss von lazy evaluation auf Effizienz-Analyse Es wurde bisher angenommen, dass alle Funktionen ihre Ergebnisse ganz berechnen. Das muss nicht stimmen. Unter lazy evaluation kann es sein, dass eine Funktion in einem bestimmten Kontext nur einen Teil ihres Ergebnisses berechnet. Die Laufzeit kann dann besser sein als nach der Analyse ohne Berücksichtigung der Laziness. 170 / 177
86 Hier die naheliegende Implementierung von minimum: minimum (a:as) = min a as min a [] = a where min a (b:x) = if a<=b then min a x else min b x Offensichtlich ist wc-time minimum (n) Θ(n) 171 / 177 Hier eine alternative Implementierung, die bequemerweise den Insertion-Sort benutzt minimum (a:as) = head (isort (a:as)) Wegen wc-time isort (n) Θ(n 2 ) könnte man vermuten, dass wc-time minimum (n) Θ(n 2 ). Sehen wir genauer hin! 172 / 177
87 Die Definition von isort war: isort [] = [] isort (a:as) = insert a (isort as) insert a [] = [a] insert a (b:as) = if a<=b then a:b:as else b:(insert a as) 173 / 177 Lazy Evaluation berechnet in einer Formel immer an der äußersten Stelle, an der eine Gleichung anwendbar ist: Zunächst kann immer nur die Gleichung isort.2 angewandt werden, am Ende einmal isort.1 head head isort insert a1 : a 2 : : => a 1 insert a2 insert a n [ ] a n [ ] 174 / 177
88 Danach wird n-mal insert angewandt, beginnend bei a n. Nehmen wir an, a 5 ist das kleinste Element. Streng outermost entsteht nun head : => a 5 a 1 insert insert a2 insert innerhalb des Kastens könnte man weiterrechnen, aber das wäre nicht outermost. a n 1 [a n] 175 / 177 head braucht nicht mehr als den obersten Konstruktur (:), um sein Ergebnis zu liefern head : => a 5 a 5 Es werden 2 n Gleichungen angewandt. Der Rest der Θ(n 2 ) Operationen steckt im Kasten und wird nicht benötigt! 176 / 177
89 Fazit: Durch Lazy Evaluation gilt auch bei dieser Definition wc-time minimum (n) Θ(n). 177 / 177
Algorithmen und Datenstrukturen 1 Kapitel 4
Algorithmen und Datenstrukturen 1 Kapitel 4 Technische Fakultät stoye@techfak.uni-bielefeld.de 4.1 Asymptotische Notationen Wir betrachten das Polynom p(x) = 2x 3 + 1000x 2 5x + 12 Für große x gilt: der
MehrAlgorithmen und Datenstrukturen - Effizienz von Algorithmen -
Algorithmen und Datenstrukturen - Effizienz von Algorithmen - Alexander Sczyrba Technische Fakultät asczyrba@techfak.uni-bielefeld.de Vorlesung, Universität Bielefeld, Winter 2014/2015 1 / 179 Kapitel
MehrAlgorithmen und Datenstrukturen I. 1 Effizienz von Algorithmen
Algorithmen und Datenstrukturen I - Effizienz von Algorithmen - Alexander Sczyrba Technische Fakultät asczyrba@techfak.uni-bielefeld.de Vorlesung, Universität Bielefeld, Winter 2013/2014 1 / 130 Kapitel
MehrAlgorithmen und Datenstrukturen 1 Kapitel 5
Algorithmen und Datenstrukturen 1 Kapitel 5 Robert Giegerich Technische Fakultät Universität Bielefeld robert@techfak.uni-bielefeld.de Vorlesung, U. Bielefeld, Winter 2011/2012 1 / 121 Kapitel 5: Effizienz
MehrProgrammieren in Haskell Programmiermethodik
Programmieren in Haskell Programmiermethodik Peter Steffen Universität Bielefeld Technische Fakultät 12.01.2011 1 Programmieren in Haskell Bisherige Themen Was soll wiederholt werden? Bedienung von hugs
MehrProgrammieren in Haskell. Stefan Janssen. Strukturelle Rekursion. Universität Bielefeld AG Praktische Informatik. 10.
Universität Bielefeld AG Praktische Informatik 10. Dezember 2014 Wiederholung: Schema: f :: [σ] -> τ f [] = e 1 f (a : as) = e 2 where s = f as wobei e 1 und e 2 Ausdrücke vom Typ τ sind und e 2 die Variablen
MehrWS 2011/2012. RobertGiegerich. November 12, 2013
WS 2011/2012 Robert AG Praktische Informatik November 12, 2013 Haskell-Syntax: Ergänzungen Es gibt noch etwas bequeme Notation für Fallunterscheidungen, die wir bisher nicht benutzt haben. Bisher kennen
MehrAbgabe: (vor der Vorlesung) Aufgabe 2.1 (P) O-Notation Beweisen Sie die folgenden Aussagen für positive Funktionen f und g:
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen SS 2009 Grundlagen: Algorithmen und Datenstrukturen Übungsblatt 2 Prof. Dr. Helmut Seidl, S. Pott,
MehrV. Claus, Juli 2005 Einführung in die Informatik II 45
Um die Größenordnung einer reellwertigen oder ganzzahligen Funktion zu beschreiben, verwenden wir die so genannten Landau-Symbole (nach dem deutschen Mathematiker Edmund Landau, 1877-1938). Hierbei werden
MehrAlgorithmen und Datenstrukturen Effizienz und Funktionenklassen
Algorithmen und Datenstrukturen Effizienz und Funktionenklassen Matthias Teschner Graphische Datenverarbeitung Institut für Informatik Universität Freiburg SS 12 Lernziele der Vorlesung Algorithmen Sortieren,
MehrAlle bislang betrachteten Sortieralgorithmen hatten (worst-case) Laufzeit Ω(nlog(n)).
8. Untere Schranken für Sortieren Alle bislang betrachteten Sortieralgorithmen hatten (worst-case) Laufzeit Ω(nlog(n)). Werden nun gemeinsame Eigenschaften dieser Algorithmen untersuchen. Fassen gemeinsame
MehrOrdnen Sie die folgenden Funktionen nach ihrer asymptotischer Komplexität in aufsteigender Reihenfolge: i=1 4i + n = 4 n. i=1 i + 3n = 4 ( n(n+1)
für Informatik Prof. aa Dr. Ir. Joost-Pieter Katoen Christian Dehnert, Friedrich Gretz, Benjamin Kaminski, Thomas Ströder Tutoraufgabe (Asymptotische Komplexität): Ordnen Sie die folgenden Funktionen nach
Mehr8. A & D - Heapsort. Werden sehen, wie wir durch geschicktes Organsieren von Daten effiziente Algorithmen entwerfen können.
8. A & D - Heapsort Werden sehen, wie wir durch geschicktes Organsieren von Daten effiziente Algorithmen entwerfen können. Genauer werden wir immer wieder benötigte Operationen durch Datenstrukturen unterstützen.
MehrProgrammierung 1 (Wintersemester 2012/13) Lösungsblatt 10 (Kapitel 11)
Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2012/13) Lösungsblatt 10 (Kapitel 11) Hinweis: Dieses Übungsblatt enthält
MehrÜbung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 2016 Patrick Schäfer, Humboldt-Universität zu Berlin Organisation Vorlesung: Montag 11 13 Uhr Marius Kloft RUD 26, 0 115 Mittwoch 11 13 Uhr Marius Kloft
MehrAlgorithmen und Datenstrukturen (ESE) Entwurf, Analyse und Umsetzung von Algorithmen (IEMS) WS 2014 / 2015 Vorlesung 3, Donnerstag 6.
Algorithmen und Datenstrukturen (ESE) Entwurf, Analyse und Umsetzung von Algorithmen (IEMS) WS 2014 / 2015 Vorlesung 3, Donnerstag 6. November 2014 (O-Notation, Theta, Omega) Junior-Prof. Dr. Olaf Ronneberger
MehrUntere Schranke für allgemeine Sortierverfahren
Untere Schranke für allgemeine Sortierverfahren Prinzipielle Frage: wie schnell kann ein Algorithmus (im worst case) überhaupt sein? Satz: Zum einer Folge von n Keys mit einem allgemeinen Sortierverfahren
MehrWS 2009/10. Diskrete Strukturen
WS 2009/10 Diskrete Strukturen Prof. Dr. J. Esparza Lehrstuhl für Grundlagen der Softwarezuverlässigkeit und theoretische Informatik Fakultät für Informatik Technische Universität München http://www7.in.tum.de/um/courses/ds/ws0910
Mehrf 1 (n) = log(n) + n 2 n 5 f 2 (n) = n 3 + n 2 f 3 (n) = log(n 2 ) f 4 (n) = n n f 5 (n) = (log(n)) 2
Prof. aa Dr. E. Ábrahám Datenstrukturen und Algorithmen SS Lösung - Präsenzübung.05.0 F. Corzilius, S. Schupp, T. Ströder Aufgabe (Asymptotische Komplexität): (6 + 0 + 6 = Punkte) a) Geben Sie eine formale
MehrLazy Pattern Matching. 10. Dezember 2014
Lazy Lazy s Universität Bielefeld AG Praktische Informatik 10. Dezember 2014 Themen-Vorschau : as-s und lazy s Client-Server-Programmierung Lazy s matching (alias Mustervergleich) kennen wir bereits aus
Mehrlim log 2n n = > 0 Da es einen Limes gibt, gibt es auch einen Limes inferior, der gleich diesem Limes ist.
Prof. aa Dr. Ir. Joost-Pieter Katoen Christian Dehnert, Jonathan Heinen, Thomas Ströder, Sabrina von Styp Aufgabe 1 (O-Notation): Beweisen oder widerlegen Sie die folgenden Aussagen: (3 + 3 + 4 = 10 Punkte)
MehrProgrammieren in Haskell
Programmieren in Haskell Programmiermethodik Programmieren in Haskell 1 Was wir heute machen Spezifikation Strukturelle Rekursion Strukturelle Induktion Programmieren in Haskell 2 Spezifikation sort [8,
MehrAlgorithmen und Datenstrukturen
1 Algorithmen und Datenstrukturen Wintersemester 01/13 6. Vorlesung Prioritäten setzen Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I Guten Morgen! Tipps für unseren ersten Test am 0. November: Lesen
MehrÜbung: Algorithmen und Datenstrukturen SS 2007
Übung: Algorithmen und Datenstrukturen SS 2007 Prof. Lengauer Sven Apel, Michael Claÿen, Christoph Zengler, Christof König Blatt 5 Votierung in der Woche vom 04.06.0708.06.07 Aufgabe 12 Manuelle Sortierung
MehrKostenmodell. Daniel Graf, Tobias Pröger. 22. September 2016 (aktualisierte Fassung 5 vom 9. Oktober 2016)
Kostenmodell Daniel Graf, Tobias Pröger 22. September 2016 (aktualisierte Fassung 5 vom 9. Oktober 2016) Erklärung: Diese Mitschrift ist als Ergänzung zur Vorlesung gedacht. Wir erheben keinen Anspruch
MehrMaster-Veranstaltung Funktionale Programmierung. Effizienz. Wintersemester 2007/2008 Kim Kirchbach (Inf6310) Mirco Schenkel (Inf6311)
Master-Veranstaltung Funktionale Programmierung Effizienz Wintersemester 2007/2008 Kim Kirchbach (Inf6310) Mirco Schenkel (Inf6311) Inhalt Lazy Evaluation Komplexität Parameterakkumulation Tupling Speicherplatz
Mehr7. Sortieren Lernziele. 7. Sortieren
7. Sortieren Lernziele 7. Sortieren Lernziele: Die wichtigsten Sortierverfahren kennen und einsetzen können, Aufwand und weitere Eigenschaften der Sortierverfahren kennen, das Problemlösungsparadigma Teile-und-herrsche
MehrGrundlagen: Algorithmen und Datenstrukturen
Technische Universität München Fakultät für Informatik Lehrstuhl für Effiziente Algorithmen Dr. Hanjo Täubig Tobias Lieber Sommersemester 2011 Übungsblatt 1 16. September 2011 Grundlagen: Algorithmen und
Mehr2.2 Allgemeine (vergleichsbasierte) Sortierverfahren
. Allgemeine (vergleichsbasierte) Sortierverfahren Vergleichsbaum: Der Aufbau des Verbleichsbaum ist für jeden Algorithmus und jede Eingabelänge n gleich. Jede Permutation der Eingabe, muss zu einem anderen
MehrKapitel 9. Komplexität von Algorithmen und Sortieralgorithmen
1 Kapitel 9 Komplexität von Algorithmen und Sortieralgorithmen Ziele 2 Komplexität von Algorithmen bestimmen können (in Bezug auf Laufzeit und auf Speicherplatzbedarf) Sortieralgorithmen kennenlernen:
MehrKomplexität von Algorithmen:
Komplexität von Algorithmen: Ansatz: Beschreiben/erfassen der Komplexität über eine Funktion, zur Abschätzung des Rechenaufwandes abhängig von der Größe der Eingabe n Uns interessiert: (1) Wie sieht eine
MehrKomplexität von Algorithmen SS 2011
Komplexität von Algorithmen SS 2011 Volker Strehl Informatik 8 4. Mai 2011 Organisatorisches Vorlesungstermine Mittwoch, 08:30 10:00 im H4 Freitag, 10:15 11:45 Uhr im H14 (Werkstoffwissenschaften) Organisatorisches
MehrAlgorithmen und Datenstrukturen
1 Algorithmen und Datenstrukturen Wintersemester 2014/15 3. Vorlesung Laufzeitanalyse Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I 2 Recap: Diskutieren Sie mit Ihrer NachbarIn! 1. 2. 3. Was sind
MehrProf. Dr. Margarita Esponda
Algorithmen und Programmieren II Sortieralgorithmen imperativ Teil I Prof. Dr. Margarita Esponda Freie Universität Berlin Sortieralgorithmen Bubble-Sort Insert-Sort Selection-Sort Vergleichsalgorithmen
Mehr2. Effizienz von Algorithmen
Effizienz von Algorithmen 2. Effizienz von Algorithmen Effizienz von Algorithmen, Random Access Machine Modell, Funktionenwachstum, Asymptotik [Cormen et al, Kap. 2.2,3,4.2-4.4 Ottman/Widmayer, Kap. 1.1]
MehrInformatik II, SS 2014
Informatik II SS 2014 (Algorithmen & Datenstrukturen) Vorlesung 11 (4.6.2014) Binäre Suchbäume II Algorithmen und Komplexität Binäre Suchbäume Binäre Suchbäume müssen nicht immer so schön symmetrisch sein
Mehr13 (2-4)-Bäume Implementierbare Funktionen. (2-4)-Bäume sind durch folgende Eigenschaften deniert: 1. Alle Äste sind gleich lang
13 (2-4)-Bäume (2-4)-Bäume sind durch folgende Eigenschaften deniert: 1. Alle Äste sind gleich lang 2. Die Ordnung (maximale Anzahl der Söhne eines Knotens) ist gleich 4 3. Innere Knoten haben 2 Söhne
Mehr4.1 Bäume, Datenstrukturen und Algorithmen. Zunächst führen wir Graphen ein. Die einfachste Vorstellung ist, dass ein Graph gegeben ist als
Kapitel 4 Bäume 4.1 Bäume, Datenstrukturen und Algorithmen Zunächst führen wir Graphen ein. Die einfachste Vorstellung ist, dass ein Graph gegeben ist als eine Menge von Knoten und eine Menge von zugehörigen
MehrRandomisierte Algorithmen 2. Erste Beispiele
Randomisierte Algorithmen Randomisierte Algorithmen 2. Erste Beispiele Thomas Worsch Fakultät für Informatik Karlsruher Institut für Technologie Wintersemester 2016/2017 1 / 35 Randomisierter Identitätstest
MehrHeapsort / 1 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]
Heapsort / 1 Heap: Ein Array heißt Heap, falls A [i] A [2i] und A[i] A [2i + 1] (für 2i n bzw. 2i + 1 n) gilt. Beispiel: A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] Heapsort / 2 Darstellung eines Heaps als
MehrAlgorithmen und Datenstrukturen Heapsort
Algorithmen und Datenstrukturen 2 5 Heapsort In diesem Kapitel wird Heapsort, ein weiterer Sortieralgorithmus, vorgestellt. Dieser besitzt wie MERGE-SORT eine Laufzeit von O(n log n), sortiert jedoch das
MehrObjektorientierte Programmierung VL: Prof. Dr. Marco Block-Berlitz - Freie Universität Berlin Proinformatik III
Objektorientierte Programmierung VL: Prof. Dr. Marco Block-Berlitz - Freie Universität Berlin Proinformatik III Text: Hinnerk van Bruinehsen - Grafiken: Jens Fischer powered by SDS.mint SoSe 2011 1 Teil
MehrTheoretische Informatik. Exkurs: Komplexität von Optimierungsproblemen. Optimierungsprobleme. Optimierungsprobleme. Exkurs Optimierungsprobleme
Theoretische Informatik Exkurs Rainer Schrader Exkurs: Komplexität von n Institut für Informatik 13. Mai 2009 1 / 34 2 / 34 Gliederung Entscheidungs- und Approximationen und Gütegarantien zwei Greedy-Strategien
MehrKomplexität von Algorithmen OOPM, Ralf Lämmel
Ganz schön komplex! Komplexität von Algorithmen OOPM, Ralf Lämmel 885 Motivierendes Beispiel Algorithmus Eingabe: ein Zahlen-Feld a der Länge n Ausgabe: Durchschnitt Fragen: sum = 0; i = 0; while (i
MehrKapitel 3: Eine einfache Programmiersprache. Programmieren in Haskell 1
Kapitel 3: Eine einfache Programmiersprache Programmieren in Haskell 1 Datentypen, Datentypdefinitionen data Instrument = Oboe HonkyTonkPiano Cello VoiceAahs data Musik = Note Ton Dauer Pause Dauer Musik
MehrÜbung zur Vorlesung Berechenbarkeit und Komplexität
RWTH Aachen Lehrgebiet Theoretische Informatik Reidl Ries Rossmanith Sanchez Tönnis WS 2012/13 Übungsblatt 7 26.11.2012 Übung zur Vorlesung Berechenbarkeit und Komplexität Aufgabe T15 Entwickeln Sie ein
Mehr2 Sortieren durch Vergleichen Eingabefolge a 1, a 2,..., a n 2, 1, 3 Sortieralg. Für festes n ist ein vergleichsbasierter Sortieralg. charakterisiert
1 Algorithmen und Datenstrukturen Wintersemester 2014/15 9. Vorlesung Sortieren in Linearzeit Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I 2 Sortieren durch Vergleichen Eingabefolge a 1, a 2,...,
MehrKapitel 9. Komplexität von Algorithmen und Sortieralgorithmen
Kapitel 9 Komplexität von Algorithmen und Sortieralgorithmen Arrays 1 Ziele Komplexität von Algorithmen bestimmen können (in Bezug auf Laufzeit und auf Speicherplatzbedarf) Sortieralgorithmen kennenlernen:
Mehr8.1.3 Operation Build-Max-Heap Operation zur Konstruktion eines Heaps Eingabe: Feld A[1..n], n = länge(a) BUILD-MAX-HEAP (A)
Stand der Vorlesung: Datenstruktur Heap: fast vollständiger Binärbaum MaxHeap: sortierter Heap, größtes Element an Wurzel Sortierverfahren: HeapSort: Sortieren eines Feldes A[1.. n] Idee: in place: Feld
Mehr( )= c+t(n-1) n>1. Stand der Vorlesung Komplexität von Algorithmen (Kapitel 3)
Stand der Vorlesung Komplexität von Algorithmen (Kapitel 3) Motivation: IT gestützte Steuerung, Überwachung, Fertigung, Produktion,. : erfordert effiziente Berechnungsvorschriften Ziel: Methoden kennen
MehrTechnische Universität München
Stand der Vorlesung: Datenstruktur Heap: fast vollständiger Binärbaum MaxHeap: sortierter Heap, größtes Element an Wurzel Sortierverfahren: HeapSort: Sortieren eines Feldes A[1.. n] Idee: in place: Feld
MehrAlgorithmen und Datenstrukturen SS09. Foliensatz 15. Michael Brinkmeier. Technische Universität Ilmenau Institut für Theoretische Informatik
Foliensatz 15 Michael Brinkmeier Technische Universität Ilmenau Institut für Theoretische Informatik Sommersemester 2009 TU Ilmenau Seite 1 / 16 Untere Schranken für das Vergleichsbasierte Sortieren TU
MehrAlgorithmen und Datenstrukturen 1-1. Seminar -
Algorithmen und Datenstrukturen 1-1. Seminar - Dominic Rose Bioinformatics Group, University of Leipzig Wintersemester 2009/10 Inhalt der ersten beiden Vorlesungen Algorithmenbegriff Komplexität, Asymptotik
MehrAlgorithmen und Datenstrukturen 1 Kapitel 3
Algorithmen und Datenstrukturen 1 Kapitel 3 Technische Fakultät robert@techfak.uni-bielefeld.de Vorlesung, U. Bielefeld, Winter 2005/2006 Kapitel 3: Strategien der algorithmischen Problemlösung Vorbemerkungen
MehrALP I. Funktionale Programmierung
ALP I Funktionale Programmierung Sortieren und Suchen (Teil 1) WS 2012/2013 Suchen 8 False unsortiert 21 4 16 7 19 11 12 7 1 5 27 3 8 False sortiert 2 4 6 7 9 11 12 18 21 24 27 36 Suchen in unsortierten
MehrVorlesung Informatik 2 Algorithmen und Datenstrukturen. (25 Sortieren vorsortierter Daten)
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (25 Sortieren vorsortierter Daten) 1 Untere Schranke für allgemeine Sortierverfahren Satz Zum Sortieren einer Folge von n Schlüsseln mit einem allgemeinen
MehrSuchen und Sortieren
Suchen und Sortieren Suchen Sortieren Mischen Zeitmessungen Bewertung von Sortier-Verfahren Seite 1 Suchverfahren Begriffe Suchen = Bestimmen der Position (Adresse) eines Wertes in einer Datenfolge Sequentielles
MehrGrundlagen: Algorithmen und Datenstrukturen
Technische Universität München Fakultät für Informatik Lehrstuhl für Effiziente Algorithmen Dr. Hanjo Täubig Tobias Lieber Sommersemester 011 Übungsblatt 30. Mai 011 Grundlagen: Algorithmen und Datenstrukturen
MehrStand der Vorlesung Komplexität von Algorithmen (Kapitel 3)
Stand der Vorlesung Komplexität von Algorithmen (Kapitel 3) Technische Universität München Motivation: IT gestützte Steuerung, Überwachung, Fertigung, Produktion,. : erfordert effiziente Berechnungsvorschriften
MehrINFORMATIK FÜR BIOLOGEN
Technische Universität Dresden 15012015 Institut für Theoretische Informatik Professur für Automatentheorie INFORMATIK FÜR BIOLOGEN Musterklausur WS 2014/15 Studiengang Biologie und Molekulare Biotechnologie
Mehr3. Übungsblatt zu Algorithmen I im SoSe 2017
Karlsruher Institut für Technologie Prof. Dr. Jörn Müller-Quade Institut für Theoretische Informatik Björn Kaidel, Sebastian Schlag, Sascha Witt 3. Übungsblatt zu Algorithmen I im SoSe 2017 http://crypto.iti.kit.edu/index.php?id=799
MehrTutoraufgabe 1 (Sortieralgorithmus):
Prof. aa Dr. Ir. Joost-Pieter Katoen Datenstrukturen und Algorithmen SS Tutoriumslösung - Übung 4 (Abgabe 2..2) Christian Dehnert, Friedrich Gretz, Benjamin Kaminski, Thomas Ströder Tutoraufgabe (Sortieralgorithmus):
MehrWorkshop Einführung in die Sprache Haskell
Workshop Einführung in die Sprache Haskell Nils Rexin, Marcellus Siegburg und Alexander Bau Fakultät für Informatik, Mathematik und Naturwissenschaften Hochschule für Technik, Wirtschaft und Kultur Leipzig
MehrWas bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell):
Was bisher geschah deklarative Programmierung funktional: Programm: Menge von Termgleichungen, Term Auswertung: Pattern matsching, Termumformungen logisch: Programm: Menge von Regeln (Horn-Formeln), Formel
MehrKapitel 12: Induktive
Kapitel 12: Induktive Datenstrukturen Felix Freiling Lehrstuhl für Praktische Informatik 1 Universität Mannheim Vorlesung Praktische Informatik I im Herbstsemester 2009 Folien nach einer Vorlage von H.-Peter
MehrAlgorithmen und Datenstrukturen
1 Algorithmen und Datenstrukturen Wintersemester 2016/17 13. Vorlesung Binäre Suchbäume Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I 2 Dynamische Menge verwaltet Elemente einer sich ändernden Menge
MehrZeitkomplexität (1) Proseminar Theoretische Informatik. Proseminar Theoretische Informatik: Lisa Dohrmann 1
Zeitkomplexität (1) Proseminar Theoretische Informatik Proseminar Theoretische Informatik: Lisa Dohrmann 1 Warum Komplexitätsbetrachtung? Ein im Prinzip entscheidbares und berechenbares Problem kann in
MehrAlgorithmen und Datenstrukturen
Universität Innsbruck Institut für Informatik Zweite Prüfung 16. Oktober 2008 Algorithmen und Datenstrukturen Name: Matrikelnr: Die Prüfung besteht aus 8 Aufgaben. Die verfügbaren Punkte für jede Aufgabe
MehrÜbersicht. Datenstrukturen und Algorithmen. Übersicht. Heaps. Vorlesung 8: Heapsort (K6) Joost-Pieter Katoen. 7. Mai 2015
Datenstrukturen und Algorithmen Vorlesung 8: (K6) 1 Joost-Pieter Katoen Lehrstuhl für Informatik Software Modeling and Verification Group http://moves.rwth-aachen.de/teaching/ss-15/dsal/ 7. Mai 015 3 Joost-Pieter
MehrEinführung in die Informatik 2
Einführung in die Informatik 2 Mathematische Grundbegriffe Sven Kosub AG Algorithmik/Theorie komplexer Systeme Universität Konstanz E 202 Sven.Kosub@uni-konstanz.de Sprechstunde: Freitag, 12:30-14:00 Uhr,
MehrP, NP und NP -Vollständigkeit
P, NP und NP -Vollständigkeit Mit der Turing-Maschine haben wir einen Formalismus kennengelernt, um über das Berechenbare nachdenken und argumentieren zu können. Wie unsere bisherigen Automatenmodelle
Mehres gibt Probleme, die nicht berechenbar sind (z.b. Menge aller Funktionen N N und die Menge aller Sprachen sind überabzählbar)
Komplexitätstheorie es gibt Probleme, die nicht berechenbar sind (z.b. Menge aller Funktionen N N und die Menge aller Sprachen sind überabzählbar) andere Probleme sind im Prinzip berechenbar, möglicherweise
MehrGrundlagen der Informatik
Jörn Fischer j.fischer@hs-mannheim.de Willkommen zur Vorlesung Grundlagen der Informatik ADS-Teil Page 2 Überblick Inhalt 1 Eigenschaften von Algorithmen Algorithmenbegriff O-Notation Entwurfstechniken
MehrFelder. November 5, 2014
Felder Universität Bielefeld AG Praktische Informatik November 5, 2014 Felder: Datenstrukturen mit konstantem Zugriff Felder nennt man auch, Vektoren, Matrizen,... Konstanter Zugriff heisst: Zugriff auf
MehrKapitel 3: Untere Schranken für algorithmische Probleme Gliederung
Gliederung 1. Grundlagen 2. Analyse der Laufzeit von Algorithmen 3. Untere Schranken für algorithmische Probleme 4. Sortier- und Selektionsverfahren 5. Paradigmen des Algorithmenentwurfs 6. Ausgewählte
MehrKapitel 2: Sortier- und Selektionsverfahren Gliederung
Gliederung 1. Laufzeit von Algorithmen 2. Sortier- und Selektionsverfahren 3. Paradigmen des Algorithmenentwurfs 4. Ausgewählte Datenstrukturen 5. Algorithmische Geometrie 6. Randomisierte Algorithmen
MehrGrundlagen der Programmierung 2. Sortierverfahren
Grundlagen der Programmierung 2 Sortierverfahren Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 30. Mai 2006 Sortieren Ziel: Bringe Folge von Objekten in eine Reihenfolge
MehrKapitel 12: Schnelles Bestimmen der Frequent Itemsets
Einleitung In welchen Situationen ist Apriori teuer, und warum? Kapitel 12: Schnelles Bestimmen der Frequent Itemsets Data Warehousing und Mining 1 Data Warehousing und Mining 2 Schnelles Identifizieren
MehrCounting - Sort [ [ ] [ [ ] 1. SS 2008 Datenstrukturen und Algorithmen Sortieren in linearer Zeit
Counting-Sort Counting - Sort ( A,B,k ). for i to k. do C[ i]. for j to length[ A]. do C[ A[ j ] C[ A[ j ] +. > C[ i] enthält Anzahl der Elemente in 6. for i to k. do C[ i] C[ i] + C[ i ]. > C[ i] enthält
MehrSchleifeninvarianten. Dezimal zu Binär
Schleifeninvarianten Mit vollstandiger Induktion lasst sich auch die Korrektheit von Algorithmen nachweisen. Will man die Werte verfolgen, die die Variablen beim Ablauf eines Algorithmus annehmen, dann
MehrKomplexität. G. Zachmann Clausthal University, Germany Leistungsverhalten von Algorithmen
lausthal Informatik II Komplexität von Algorithmen. Zachmann lausthal University, ermany zach@in.tu-clausthal.de Leistungsverhalten von Algorithmen Speicherplatzkomplexität: Wird primärer & sekundärer
MehrNAME, VORNAME: Studiennummer: Matrikel:
TU Ilmenau, Fakultat IA Institut für Theoretische Informatik FG Komplexitätstheorie und Effiziente Algorithmen Prof. Dr. (USA) M. Dietzfelbinger Klausur Algorithmen und Datenstrukturen SS08, Ing.-Inf.
MehrWiederholung ADT Menge Ziel: Verwaltung (Finden, Einfügen, Entfernen) einer Menge von Elementen
Was bisher geschah abstrakter Datentyp : Signatur Σ und Axiome Φ z.b. ADT Menge zur Verwaltung (Finden, Einfügen, Entfernen) mehrerer Elemente desselben Typs Spezifikation einer Schnittstelle Konkreter
MehrWas bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen:
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen: Peano-Zahlen, Listen, Bäume Rekursive Funktionen strukturelle
MehrÜbung Algorithmen I
Übung Algorithmen I 10.5.17 Sascha Witt sascha.witt@kit.edu (Mit Folien von Lukas Barth, Julian Arz, Timo Bingmann, Sebastian Schlag und Christoph Striecks) Roadmap Listen Skip List Hotlist Amortisierte
MehrDatenstrukturen & Algorithmen
Datenstrukturen & Algorithmen Matthias Zwicker Universität Bern Frühling 2010 Übersicht Dynamische Programmierung Einführung Ablaufkoordination von Montagebändern Längste gemeinsame Teilsequenz Optimale
MehrAlgorithmenbegriff: Berechenbarkeit. Algorithmenanalyse. (Berechnung der Komplexität)
Über-/Rückblick Algorithmenbegriff: Berechenbarkeit Turing-Maschine RAM µ-rekursive Funktionen Zeit Platz Komplexität Algorithmentechniken Algorithmenanalyse (Berechnung der Komplexität) Rekursion Iteration
MehrGrundlagen: Algorithmen und Datenstrukturen
Technische Universität München Fakultät für Informatik Lehrstuhl für Effiziente Algorithmen Dr. Hanjo Täubig Tobias Lieber Sommersemester 2011 Übungsblatt 5 14. Juni 2011 Grundlagen: Algorithmen und Datenstrukturen
MehrProgrammiertechnik II
Analyse von Algorithmen Algorithmenentwurf Algorithmen sind oft Teil einer größeren Anwendung operieren auf Daten der Anwendung, sollen aber unabhängig von konkreten Typen sein Darstellung der Algorithmen
MehrVorlesung Datenstrukturen
Vorlesung Datenstrukturen Binärbaum Suchbaum Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 356 Datenstruktur Binärbaum Strukturrepräsentation des mathematischen Konzepts Binärbaum
MehrInformatik II, SS 2014
Informatik II SS 2014 (Algorithmen & Datenstrukturen) Vorlesung 4 (7.5.2014) Asymptotische Analyse, Sortieren IV Algorithmen und Komplexität Erfahrungen 1. Übung C++ / Java sind komplett ungewohnt Struktur
Mehr5. Übungsblatt zu Algorithmen I im SoSe 2016
Karlsruher Institut für Technologie Institut für Theoretische Informatik Prof. Dr. Dennis Hofheinz Lukas Barth, Lisa Kohl 5. Übungsblatt zu Algorithmen I im SoSe 2016 https://crypto.iti.kit.edu/index.php?id=algo-sose16
MehrÜbungsblatt 1. f(n) = f(n) = O(g(n)) g(n) = O(f(n)) Zeigen oder widerlegen Sie: 3 n = Θ(2 n ) Aufgabe 1.2 Gegeben sei die folgende Funktion:
Übungsblatt 1 Aufgabe 1.1 Beweisen oder widerlegen Sie, dass für die im Folgenden definierte Funktion f(n) die Beziehung f(n) = Θ(n 4 ) gilt. Beachten Sie, dass zu einem vollständigen Beweis gegebenenfalls
MehrInformatik-Seminar Thema 6: Bäume
Informatik-Seminar 2003 - Thema 6: Bäume Robin Brandt 14. November 2003 1 Robin Brandt Informatik-Seminar 2003 - Thema 6: Bäume Übersicht Definition Eigenschaften Operationen Idee Beispiel Datendefinition
Mehr12 (2-4)-Bäume Implementierbare Funktionen. (2-4)-Bäume sind durch folgende Eigenschaften deniert: 1. Alle Äste sind gleich lang
12 (2-4)-Bäume (2-4)-Bäume sind durch folgende Eigenschaften deniert: 1. Alle Äste sind gleich lang 2. Die Ordnung (maximale Anzahl der Söhne eines Knotens) ist gleich 4 3. Innere Knoten haben 2 Söhne
MehrÜbung Algorithmen I
Übung Algorithmen I 20.5.15 Christoph Striecks Christoph.Striecks@kit.edu (Mit Folien von Julian Arz, Timo Bingmann und Sebastian Schlag.) Roadmap Organisation Mergesort, Quicksort Dual Pivot Quicksort
MehrAlgorithmen I. Tutorium 1-3. Sitzung. Dennis Felsing
Algorithmen I Tutorium 1-3. Sitzung Dennis Felsing dennis.felsing@student.kit.edu www.stud.uni-karlsruhe.de/~ubcqr/algo 2011-05-02 Überblick 1 Sortieren und Suchen 2 Mastertheorem 3 Datenstrukturen 4 Kreativaufgabe
MehrKomplexität von Algorithmen Musterlösungen zu ausgewählten Übungsaufgaben
Dieses Dokument soll mehr dazu dienen, Beispiele für die formal korrekte mathematische Bearbeitung von Aufgaben zu liefern, als konkrete Hinweise auf typische Klausuraufgaben zu liefern. Die hier gezeigten
Mehr4. Sortieren 4.1 Vorbemerkungen
. Seite 1/21 4. Sortieren 4.1 Vorbemerkungen allgemeines Sortierproblem spezielle Sortierprobleme Ordne a 1,..., a n so um, dass Elemente in aufsteigender Reihenfolge stehen. Die a i stammen aus vollständig
Mehr