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 Suchverfahren (in Listen)
Wiederholung: Asymptotik Grundsätzlich worst case Betrachtungen, Abschätzung oberer Schranken: Groß-Oh-Notation
Wiederholung: Asymptotik Grundsätzlich worst case Betrachtungen, Abschätzung oberer Schranken: Groß-Oh-Notation Zeitkomplexität T(n) eines Algorithmus ist von der Größenordnung n, wenn es Konstanten n 0 und c > 0 gibt, so daß für alle Werte von n > n 0 gilt: T(n) c n T(n) ist in O(n) (T(n) O(n) oder T(n) = O(n))
Wiederholung: Asymptotik Grundsätzlich worst case Betrachtungen, Abschätzung oberer Schranken: Groß-Oh-Notation Zeitkomplexität T(n) eines Algorithmus ist von der Größenordnung n, wenn es Konstanten n 0 und c > 0 gibt, so daß für alle Werte von n > n 0 gilt: T(n) c n T(n) ist in O(n) (T(n) O(n) oder T(n) = O(n)) große n, Komplexitätsklassen 5x groß ist immer noch groß vernachlässige Konstanten
Wiederholung: Asymptotik Klasse O(f ), alle Funktionen der Größenordnung f : O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)}
Wiederholung: Asymptotik Klasse O(f ), alle Funktionen der Größenordnung f : O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)}
Wiederholung: Asymptotik Klasse O(f ), alle Funktionen der Größenordnung f : O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)} O(f + g) = O(f ) + O(g) = O(max(f, g))
Wiederholung: Asymptotik Klasse O(f ), alle Funktionen der Größenordnung f : O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)} O(f + g) = O(f ) + O(g) = O(max(f, g)) Analog: Untere Schranken Ω(f ), exakte Schranken Θ(f )
Wiederholung: Asymptotik O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)}
Wiederholung: Asymptotik O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)} Beispiel: f (n) = 7n + 3, ges: O(f (n))?
Wiederholung: Asymptotik O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)} Beispiel: f (n) = 7n + 3, ges: O(f (n))? n n 0 : 7n + 3 cn
Wiederholung: Asymptotik O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)} Beispiel: f (n) = 7n + 3, ges: O(f (n))? n n 0 : 7n + 3 cn 7 + 3 n c
Wiederholung: Asymptotik O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)} Beispiel: f (n) = 7n + 3, ges: O(f (n))? n n 0 : 7n + 3 cn 7 + 3 n c n 0 = 3, c = 8
Wiederholung: Asymptotik O(f ) = {g c > 0 n 0 > 0 : n n 0 : g(n) cf (n)} Beispiel: f (n) = 7n + 3, ges: O(f (n))? n n 0 : 7n + 3 cn 7 + 3 n c n 0 = 3, c = 8 f (n) O(n)
Wichtige Wachstumsfunktionen O(1) konstante Kosten billig O(logn) logarithmisches Wachstum O(n) lineares Wachstum O(n log n) n log n-wachstum O(n 2 ) quadratisches Wachstum O(n 3 ) kubisches Wachstum O(2 n ) exponentielles Wachstum teuer
Wichtige Wachstumsfunktionen Problemgröße 100, verschied. Algo. verfüg., Laufzeit?
Wichtige Wachstumsfunktionen Problemgröße 100, verschied. Algo. verfüg., Laufzeit? x * log(x) 0 100 200 300 400 2^x x^3 x^2 x*log(x) x log(x)*log(x) log(x) 0 20 40 60 80 100 x
Das Master-Theorem Hauptsatz der Laufzeitfunktionen In welcher Laufzeitklasse liegt eine gegebene Rekursion.
Das Master-Theorem Hauptsatz der Laufzeitfunktionen In welcher Laufzeitklasse liegt eine gegebene Rekursion. T(n) = at ( n b) + g(n), mit a 1, b 2, c > 0.
Das Master-Theorem Hauptsatz der Laufzeitfunktionen In welcher Laufzeitklasse liegt eine gegebene Rekursion. T(n) = at ( n b) + g(n), mit a 1, b 2, c > 0. Zerlege Problem der Größe n in b Teilprobleme.
Das Master-Theorem Hauptsatz der Laufzeitfunktionen In welcher Laufzeitklasse liegt eine gegebene Rekursion. T(n) = at ( n b) + g(n), mit a 1, b 2, c > 0. Zerlege Problem der Größe n in b Teilprobleme. Lösung des Gesamtproblems koste das a-fache der Lösung eines Teilproblems, Overhead Kosten g(n)
Das Master-Theorem Betrachte g(n), 2 Fälle: polynomial vs allgemein
Das Master-Theorem Betrachte g(n), 2 Fälle: polynomial vs allgemein Polynomial: d.h. g(n) = Θ(n k ), a 1, b 2: T(n) = at ( n b) + Θ(n k )
Das Master-Theorem Betrachte g(n), 2 Fälle: polynomial vs allgemein Polynomial: d.h. g(n) = Θ(n k ), a 1, b 2: ( n Θ(n T(n) = at + Θ(n b) k ) falls a < b k k ) = Θ(n k log n) falls a = b k Θ(n log b (a) ) falls a > b k
Das Master-Theorem Betrachte g(n), 2 Fälle: polynomial vs allgemein Polynomial: d.h. g(n) = Θ(n k ), a 1, b 2: ( n Θ(n T(n) = at + Θ(n b) k ) falls a < b k k ) = Θ(n k log n) falls a = b k Θ(n log b (a) ) falls a > b k Das Master-Theorem sind im Prinzip Regeln, die aussagen, welches Laufzeitverhalten der Algorithmus hat. Die Laufzeit wird abhänging von der Größe der einzelnen Teilprobleme, der Anzahl der entstandenen Teilprobleme und der Rechenzeit für die Erstellung bzw. Zusammenführung dieser Teilprobleme bestimmt. Es gilt: Wenn die Teilprobleme summiert kleiner sind als das Orignialproblem und die Erstellung der Teilprobleme auch nur linare Zeit beansprucht, so kann der ganze Algorithmus in linearer Zeit ausgeführt werden. Wenn die Größe der Teilprobeme der Größe des Orignialproblems entspricht und der Aufwand, diese Teilprobleme zu erstellen, linear bleibt, so ist der Gesamtaufwand Θ(n log n). Werden die einzelnen Teilprobleme in der Summe größer, als das Orignalproblem, so ist klar, dass wir noch mehr Laufzeit benötigen.
Das Master-Theorem Allgemein: sei u = log b (a)
Das Master-Theorem Allgemein: sei u = log b (a) falls g(n) = O(n u ǫ ), ǫ > 0, dann ist T(n) = Θ(n u ). falls g(n) = Θ(n u ), dann ist T(n) = Θ(n u log n) falls g(n) = Ω(n u+ǫ ) für ein ǫ > 0 und ag( n b ) cg(n), dann ist T(n) = Θ(g(n))
Das Mastertheorem Achtung: Das Master-Theorem kann nicht immer angewandt werden, beispielsweise dann nicht, wenn
Das Mastertheorem Achtung: Das Master-Theorem kann nicht immer angewandt werden, beispielsweise dann nicht, wenn T(n) nicht monoton steigend ist, z.b.: T(n) = sin(n)
Das Mastertheorem Achtung: Das Master-Theorem kann nicht immer angewandt werden, beispielsweise dann nicht, wenn T(n) nicht monoton steigend ist, z.b.: T(n) = sin(n) g(n) kein Polynom ist, z.b.: T(n) = 2T( n 2 ) + 2n
Das Mastertheorem Achtung: Das Master-Theorem kann nicht immer angewandt werden, beispielsweise dann nicht, wenn T(n) nicht monoton steigend ist, z.b.: T(n) = sin(n) g(n) kein Polynom ist, z.b.: T(n) = 2T( n 2 ) + 2n b keine Konstante ist, z.b.: T(n) = T( n)
Suche in sortierten, linearen Listen Problem: Gegeben Folge F = (a 1 ;...;a n ). Finde das Element mit Schlüssel k.
Suche in sortierten, linearen Listen Problem: Gegeben Folge F = (a 1 ;...;a n ). Finde das Element mit Schlüssel k. Lineare Liste Sequentielle Suche Binäre Suche Sprungsuche Exponentielle Suche Interpolationssuche
Array vs verkette Liste Lineare Liste
Lineare Liste Array vs verkette Liste Eigenschaft Array Liste Art statisch dynamisch Größenänderung nicht möglich problemlos möglich Einfügen / Löschen langsam schnell Zugriff auf n-tes Element schnell langsam binäre Suche möglich nicht möglich Element-Typen alle gleich kann unterschiedlich sein
Einfügen in verkettete Liste: Lineare Liste
Lineare Liste Einfügen in verkettete Liste: Löschen in verketteter Liste:
Sequenzielle Suche Hilft wenn Liste unsortiert, naiver Ansatz, Liste durchlaufen jedes Element ansehen.
Sequenzielle Suche Hilft wenn Liste unsortiert, naiver Ansatz, Liste durchlaufen jedes Element ansehen. Mittlere Anzahl von Schlüsselvergleichen bei erfolgreicher Suche C avg (n) = 1 n n i = n + 1 2 i=1
Binäre Suche Effizient: Verbesserung von O(n) (Seq. Suche) auf O(log n) (Bin. Suche)
Binäre Suche Effizient: Verbesserung von O(n) (Seq. Suche) auf O(log n) (Bin. Suche)
Sprungsuche
n-ebenen Sprungsuche Beispiel: 2-Ebenen Sprungsuche Wende Sprungsuche auch im lokalisierten Abschnitt an.
n-ebenen Sprungsuche Beispiel: 2-Ebenen Sprungsuche Wende Sprungsuche auch im lokalisierten Abschnitt an. Warum nicht gleich Binärsuche?
n-ebenen Sprungsuche Beispiel: 2-Ebenen Sprungsuche Wende Sprungsuche auch im lokalisierten Abschnitt an. Warum nicht gleich Binärsuche? Binärsuche nicht immer anwendbar, z.b. bei blockweisem Einlesen der Daten von Externspeicher, für Binärsuche müssen alle Daten verfügbar sein.
Exponentielle Suche
Interpolationssuche Idee: Schätze Abstand zum nächsten Suchschlüssel.
Interpolationssuche Idee: Schätze Abstand zum nächsten Suchschlüssel. Position = Anzahl der Elemente Anzahl verschiedene Elemente gesuchter Wert
1. Übungsserie 4 Aufgaben, insgesamt 35 Punkte A1, Groß-Oh-Notation, 10 Punkte A2, Master-Theorem, 10 Punkte A3, Durchführung Binärsuche, 10 Punkte A4, Modifikation Binärsuche, 5 Punkte
Aufgabe 1 Gegeben sind die folgenden 6 Funktionen a) n n n + 2 b) n 3 n/2 c) n n3 log(n+19) d) n 19n 2 + n cos(πn) e) n 5 4 n + 2 log(3/(n+1)) f) n 10 7 n n+19 Bringen Sie die Funktionen in eine Reihenfolge f 1, f 2, f 3, f 4, f 5, f 6, so dass f 1 O(f 2 ), f 2 O(f 3 ), f 3 O(f 4 ) usw. Begründen sie kurz jede dieser 5 Beziehungen anhand der Definition des O-Symbols.
Aufgabe 1 - Lösung f 1 (n) = 10 7 n O(1) n+19 f 2 (n) = 5 4 n + 2 log(3/(n+1)) O(n 1 4) f 3 (n) = n n + 2 O(n 1.5 ) f 4 (n) = 19n 2 + n cos(πn) O(n 2 ) f 5 (n) = n 3 log(n+19) O(n3 ) f 6 (n) = 3 n/2 O(3 n )
Aufgabe 2 Gegeben seien die folgenden Rekursionsgleichungen jeweils für eine Funktion T. (a) T(n) = 9T(n/3) + 2n 2 + n (b) T(n) = T(n/2) + n 5 + 1 (c) T(n) = 27T(n/3) + 100n 2 + n (d) T(n) = nt(n 1) (e) T(n) = T(n/2) + log 2 n Bestimmen Sie jeweils eine exakte Schranke für das Verhalten von T. Finden Sie also eine Funktion f, so daß T Θ(f ). In den Fällen, wo die polynomiale Version des Master-Theorems anwendbar ist, benutzen Sie dieses zum Finden von f und geben a, b und k an.
Aufgabe 2 - Lösung (a) a = 9, b = 3, k = 2, also a = b k ( mittlerer Fall im pol. MT.) T(n) Θ(n k log n) = Θ(n 2 log n)
Aufgabe 2 - Lösung (a) a = 9, b = 3, k = 2, also a = b k ( mittlerer Fall im pol. MT.) T(n) Θ(n k log n) = Θ(n 2 log n) (b) a = 1, b = 2, k = 5, also a < b k ( oberer Fall im pol. MT.) T(n) Θ(n k ) = Θ(n 5 )
Aufgabe 2 - Lösung (a) a = 9, b = 3, k = 2, also a = b k ( mittlerer Fall im pol. MT.) T(n) Θ(n k log n) = Θ(n 2 log n) (b) a = 1, b = 2, k = 5, also a < b k ( oberer Fall im pol. MT.) T(n) Θ(n k ) = Θ(n 5 ) (c) a = 27, b = 3, k = 2, also a > b k ( unterer Fall im pol. MT.) T(n) Θ(n log b a ) = Θ(n 3 )
Aufgabe 2 - Lösung (d) T(n) = nt(n 1) Master-Theorem nicht anwendbar, aber da steht implizit die Definition der Fakultät, also T(n) Θ(n!) Mit Anfangsb. T(1) = 1 bekommt man genau T(n) = n!
(e) T(n) = T(n/2) + log 2 n Aufgabe 2 - Lösung
Aufgabe 2 - Lösung (e) T(n) = T(n/2) + log 2 n Wieder nichts für das polynomiale MT, seufz. (g(n) ist kein Polynom)
Aufgabe 2 - Lösung (e) T(n) = T(n/2) + log 2 n Wieder nichts für das polynomiale MT, seufz. (g(n) ist kein Polynom) Betrachte transformierte Funktion U mit U(n) = T(2 n ), also U(log 2 n) = T(n).
Aufgabe 2 - Lösung (e) T(n) = T(n/2) + log 2 n Wieder nichts für das polynomiale MT, seufz. (g(n) ist kein Polynom) Betrachte transformierte Funktion U mit U(n) = T(2 n ), also U(log 2 n) = T(n). Rekursionsgleichung für U: U(l) = U(l 1) + l
Aufgabe 2 - Lösung (e) T(n) = T(n/2) + log 2 n Wieder nichts für das polynomiale MT, seufz. (g(n) ist kein Polynom) Betrachte transformierte Funktion U mit U(n) = T(2 n ), also U(log 2 n) = T(n). Rekursionsgleichung für U: U(l) = U(l 1) + l Mit Anfangsbedingung U(1) = 1 ist U(l) = l(l + 1)/2.
Aufgabe 2 - Lösung (e) T(n) = T(n/2) + log 2 n Wieder nichts für das polynomiale MT, seufz. (g(n) ist kein Polynom) Betrachte transformierte Funktion U mit U(n) = T(2 n ), also U(log 2 n) = T(n). Rekursionsgleichung für U: U(l) = U(l 1) + l Mit Anfangsbedingung U(1) = 1 ist U(l) = l(l + 1)/2. Rücktransformation T(n) = U(log 2 n) = log 2 n(1 + log 2 n)/2, also
Aufgabe 2 - Lösung (e) T(n) = T(n/2) + log 2 n Wieder nichts für das polynomiale MT, seufz. (g(n) ist kein Polynom) Betrachte transformierte Funktion U mit U(n) = T(2 n ), also U(log 2 n) = T(n). Rekursionsgleichung für U: U(l) = U(l 1) + l Mit Anfangsbedingung U(1) = 1 ist U(l) = l(l + 1)/2. Rücktransformation T(n) = U(log 2 n) = log 2 n(1 + log 2 n)/2, also T(n) Θ((log 2 n) 2 )
T(n) = 2T(n/4) + n + 42 Weiteres Beispiel MT
T(n) = 2T(n/4) + n + 42 a = 2, b = 4, k = 1/2 Weiteres Beispiel MT
Weiteres Beispiel MT T(n) = 2T(n/4) + n + 42 a = 2, b = 4, k = 1/2 2 = 4 1/2, also a = b k mittlerer Fall im pol. MT T(n) Θ(n k logn) T(n) = Θ( nlogn)
Aufgabe 3 Binärsuche auf f[] = [1, 2, 4, 5, 8, 11, 14, 17, 19, 23, 25, 31, 37, 41, 43, 47] gesucht: (a) x=14 (b) x=45 Geben Sie für beide Teilaufgaben, die initialen Funktionsaufrufe von binsearch an, d.h. überlegen Sie sich wie l und r anfangs zu belegen sind und protokollieren Sie für jeden Rekursionsaufruf die Werte der Variablen l, r und p, sowie den Rückgabe Wert von binsearch.
Aufgabe 3 public class Search { public static int binsearch (int[] f, int x, int l, int r) { int p=(l+r)/2; int c=(f[p]<=x? f[p]==x? 0 : 1 : -1); if (c==0) return(p); if (l==r) return(-1); if (c<0) { if (p>l) return(binsearch(f,x,l,p-1)); else return(-1); } else { if (p<r) return(binsearch(f,x,p+1,r)); else return(-1); } } }
Aufgabe 3 - Lösung Aufgabe (3a) Gesucht: 14 mit Aufruf von binsearch(f, x=14, l=0, r=15 ), p
Aufgabe 3 - Lösung Aufgabe (3a) Gesucht: 14 mit Aufruf von binsearch(f, x=14, l=0, r=15 ), p index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 behaviour 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 searchspace 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47
Aufgabe 3 - Lösung Aufgabe (3a) Gesucht: 14 mit Aufruf von binsearch(f, x=14, l=0, r=15 ), p index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 behaviour 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 searchspace 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 Ausgabe: 6 (f gibt bei erfolgreicher Suche die jeweilige Array Position zurück, sonst -1.)
Aufgabe 3 - Lösung Aufgabe (3b) Gesucht: 45 mit Aufruf von binsearch(f, x=45, l=0, r=15 ), p
Aufgabe 3 - Lösung Aufgabe (3b) Gesucht: 45 mit Aufruf von binsearch(f, x=45, l=0, r=15 ), p index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 behaviour 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 searchspace 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47
Aufgabe 3 - Lösung Aufgabe (3b) Gesucht: 45 mit Aufruf von binsearch(f, x=45, l=0, r=15 ), p index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 behaviour 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 searchspace 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 1 2 4 5 8 11 14 17 19 23 25 31 37 41 43 47 Ausgabe: -1
Aufgabe 4 Eine lineare Liste L[] der Länge n sei wie folgt teilsortiert: Für alle Indizes k, l {1,..., n} gilt a[k] > a[l] k l 1 Wenn also zwei Elemente in der falschen Reihenfolge stehen, dann steht das Größere direkt vor dem Kleineren. Geben Sie eine möglichst einfache Modifikation der Binärsuche aus der Vorlesung an, die L[] auf das Vorhandensein eines gegebenen Schlüssels überprüft. Die maximalen Kosten (Laufzeit) sollen in O(log n) liegen.
Was heißt das eigentlich? Aufgabe 4 - Lösung
Aufgabe 4 - Lösung Was heißt das eigentlich? 1 2 3 4 5 6 7 8 9 erlaubt 1 2 4 3 5 6 7 8 9 erlaubt 9 2 3 4 5 6 7 8 1 verboten
Aufgabe 4 - Lösung Was heißt das eigentlich? 1 2 3 4 5 6 7 8 9 erlaubt 1 2 4 3 5 6 7 8 9 erlaubt 9 2 3 4 5 6 7 8 1 verboten Nur lokale Vertauschungen sind erlaubt!
Aufgabe 4 - Lösung Zusammen mit der Nummerierung der Listenelemente von 1 bis n ist die Formel m = n/2 zu benutzen. if Liste == <> then exit( erfolglos ) n = length(liste); m = ceiling(n/2) if (x==l[m]) exit( erfolgreich ) if (x<l[m]) { if (m<n && x==l[m+1]) exit( erfolgreich ) else search(x, SubList(L,1..m-1)) } if (x>l[m]) { if (m>1 && x==l[m-1]) exit( erfolgreich ) else search(x, SubList(L,m+1..n)) } Die Anzahl der rekursiven Aufrufe ist identisch zur binären Suche O(log n). Nur die Anzahl der Vergleiche pro Aufruf erhöht sich (im schlimmsten Fall) um einen Faktor 2.