Abgabe: (vor der Vorlesung) Aufgabe 3.1 (P) Master-Theorem

Größe: px

Ab Seite anzeigen:

Download "Abgabe: (vor der Vorlesung) Aufgabe 3.1 (P) Master-Theorem"

Pia Lorentz
vor 5 Jahren
Abrufe

1 TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen SS 2009 Grundlagen: Algorithmen und Datenstrukturen Übungsblatt 3 Prof. Dr. Helmut Seidl, S. Pott, V. Prinz Abgabe: (vor der Vorlesung) Aufgabe 3.1 (P) Master-Theorem Das Master-Theorem bietet eine schnelle Lösung für die Frage, in welcher Laufzeitklasse eine rekursiv definierte Funktion liegt. Eine vereinfachte Form des Master-Theorems lautet wie folgt: Für positive Konstanten a, b, c, d mit n = b k und eine natürliche Zahl k sei Dann gilt: r(n) = a falls n = 1 r(n) = c n + d r( n b ) falls n > 1 r(n) θ(n) falls d < b r(n) θ(n log n) falls d = b r(n) θ(n log b d ) falls d > b Geben Sie für folgende Rekurrenzen an, ob sie sich für ein b R mit n = b k (k N 0 ) mit dem vorgestellten Master-Theorem (ohne aufwändige Umformungen) lösen lassen. Wenn ja, geben Sie die entsprechende Laufzeitabschätzung an. Wenn nein, begründen Sie Ihre Antwort. Sei jeweils T (1) = 3. a) T (n) = T (n/10) + n für n > 1 b) T (n) = 2T (n/2) + n 3 für n > 1 c) T (n) = 16T (n/4) + 2n für n > 1 d) T (n) = 7T (log n) + 2 n für n > 1 e) T (n) = 8T (n/8) + 8n für n > 1 f) T (n) = 2T (n/3) + 4n für n > 1

2 2 Aufgabe 3.2 (P) Amortisierte Analyse Auf der folgenden Seite sind zwei Datenstrukturen (Queue1 und Queue2) angegeben. Beide stellen die Operationen pushfirst und poplast auf einer Sequenz von Elementen s = e 0,..., e n zur Verfügung. Begonnen wird mit einer leeren Sequenz s 0 =. Für eine Sequenz s = e 0,..., e n gilt: s pushf irst(e) s mit s = e, e 0,..., e n s poplast s mit s = e 0,..., e n 1 In Queue1 wird die Sequenz durch eine (einfach verkettete) Liste, in Queue2 durch zwei (einfach verkettete) Listen repräsentiert. Begründen Sie jeweils Ihre Antwort. a) Geben Sie für die Operationen pushfirst1, poplast1, pushfirst2, poplast2 und reverse an, ob sie im schlechtesten Fall konstante, logarithmische, lineare oder quadratische Laufzeit haben. (Dabei dürfen Sie für die verwendeten Listenoperationen (addfirst(e), getfirst, hasnext, next, remove, isempty, removefirst und den Konstruktor des Iterators, listiterator ()) konstante Laufzeit voraussetzen.) b) Geben Sie zur ersten Datenstruktur Queue1 eine Folge von m Operationen (pushfirst1 und poplast1) an, sodass die Laufzeit in Θ(m 2 ) liegt. c) Geben Sie den Aufwand in Θ-Notation für Ihre Folge von m Operationen aus Aufgabenteil b) zur zweiten Datenstruktur Queue2 an (wobei pushfirst1 durch pushfirst2 und poplast1 durch poplast2 ersetzt wird). d) Zeigen Sie, dass der amortisierte Aufwand von poplast2 (in Queue2) konstant ist.

3 3 Zusatz zu Aufgabe 3.2 class Queue1<E>{ l = new S i n g l e L i n k e d L i s t <E>(); pushfirst1 (E e ){ l. addfirst ( e ) ; poplast1 (){ e = l. g e t F i r s t ( ) ; i = l. l i s t I t e r a t o r ( ) ; // Durchlaeuft d i e L i s t e while ( i. hasnext ( ) ) { e = i. next ( ) ; i. remove ( ) ; // Entfernt das a k t u e l l e Element e aus der L i s t e l class Queue2<E>{ l 1 = new S i n g l e L i n k e d L i s t <E>(); l 2 = new S i n g l e L i n k e d L i s t <E>(); pushfirst2 (E e ){ l 1. addfirst ( e ) ; poplast2 (){ i f ( l 2. isempty ( ) ) { r e v e r s e ( ) ; l 2. removefirst ( ) ; else l 2. removefirst ( ) ; r e v e r s e ( ) { while (! l 1. isempty ( ) ) { e=l 1. g e t F i r s t ( ) ; l 2. addfirst ( e ) ; l 1. removefirst ( ) ; Dabei sei SingleLinkedList eine Klasse für einfach verkettete Listen, die eine Klasse ListItr eines Iterator enthält. Im Folgenden ist ein Ausschnitt der Klasse ListItr angegeben. Diese verwendet header und size aus der Klasse SingleLinkedList. (Für ausführlichere Informationen betrachten Sie die Klasse java.util.linkedlist für doppelt verkettete Listen.) class L i s t I t r implements L i s t I t e r a t o r <E> { Entry<E> lastreturned = header ; Entry<E> next ; int nextindex ;

4 4 L i s t I t r ( ) { i f (0 < ( s i z e >> 1 ) ) { next = header. next ; else { next = header ; public boolean hasnext ( ) { return nextindex!= s i z e ; public E next ( ) { i f ( nextindex == s i z e ) throw new NoSuchElementException ( ) ; lastreturned = next ; next = next. next ; nextindex++; return lastreturned. element ; public void remove ( ) { Entry<E> lastnext = lastreturned. next ; try { S i n g l e L i n k e d L i s t. this. remove ( lastreturned ) ; catch ( NoSuchElementException e ) { throw new I l l e g a l S t a t e E x c e p t i o n ( ) ; i f ( next==lastreturned ) next = lastnext ; else nextindex ; lastreturned = header ;

5 5 Aufgabe 3.3 [5 Punkte] (H) Mergesort Mergesort ist ein rekursiver Sortieralgorithmus. Er ist ein typisches Beispiel für das Entwurfsprinzip Divide-and-Conquer für rekursive Algorithmen. Ein Problem wird zunächst in kleinere, gleichartige Teilprobleme zerlegt. Es folgt eine rekursive Lösung der Teilprobleme. Schließlich werden die Teillösungen zu einer Lösung des ganzen Problems kombiniert: Zerlege Folge der Länge n in zwei Folgen der Länge n 2. Sortiere die beiden Teilfolgen rekursiv (eine einelementige Teilfolge ist sortiert). Füge die sortierten Teilfolgen nach dem Reißverschlussverfahren zusammen: Betrachte stets das kleinste Element beider Teilfolgen. Füge das kleinere der beiden Elemente in die neue Folge ein und entnimm es aus der alten Folge. a) Laden Sie sich die Klasse MergeSortTemplate.java von der Übungsseite. Machen Sie sich mit dem Mergesort-Algorithmus vertraut, indem Sie die Methode mergesort implementieren. Eventuell notwendige Hilfsmethoden ergänzen Sie entsprechend. Falls die Anzahl der Elemente eines Arrays beim Split ungerade ist, soll das linke Teilarray kleiner sein als das Rechte. Beispielsweise soll bei 13 Elementen das linke Teilarray 6, das Rechte 7 Elemente enthalten. Das Zusammenfügen (merge) soll eine lineare Laufzeit aufweisen. Erläutern Sie insbesondere den Ablauf des Reißverschlussverfahrens durch Kommentare. Das von dem Template ausgegebene sorted array sollte jetzt sortiert sein. b) Stellen Sie eine Rekurrenz T (n) zur Laufzeitanalyse des Mergesort-Algorithmus (in Abhängigkeit von der Länge n der Eingabefolge) auf. Für die folgenden Schritte des Mergesort-Algorithmus können Sie den angegebenen Zeitaufwand annehmen (c, c N + ): (Zeitaufwand) m = n/2 ( c n ) b = a 0,..., a m 1 ( c m ) b = a m,..., a n 1 ( c (n m) ) merge(mergesort(b), mergesort(b )) Vernachlässigen Sie den Zeitaufwand für die Überprüfung, ob die Eingabefolge bereits einelementig ist. Nehmen Sie zudem an, dass der Zeitaufwand von merge durch c n (c N + ) begrenzt ist. c) Lösen Sie die Rekurrenz mit Hilfe des in Aufgabe 3.1 vorgestellten Master-Theorems für n = 2 k (k N 0 ). Geben Sie also eine Funktion f(n) an, so dass T (n) Θ(f(n)) gilt.

6 6 Aufgabe 3.4 [5 Punkte] (H) Sortiertes Feld mit Lazy Update In dieser Aufgabe betrachten wir Operationen auf einem sortierten Feld F = [0,..., n 1]. Wir nehmen an, dass dieses Feld zu jedem Zeitpunkt maximal n Elemente hat, und zu Beginn bereits sortiert ist. Die Elemente sind nach einem Schlüssel Key() sortiert. Auf F sollen nun folgende Operationen ausgeführt werden: insert(), remove() und f ind(). [e 0, e m ].insert(e) = [e 0,..., e i, e, e i+1,..., e m ] mit Key(e i ) < Key(e) < Key(e i+1 ) [e 0, e m ].remove(k) = [e 0,..., e i 1, e i+1,..., e m ] mit Key(e i ) = k [e 0, e m ].find(k) = e i mit Key(e i ) = k Nehmen Sie an, es gibt ein weiteres Feld Op = [0,..., n 1] der Grösse n. Operationen insert() und remove() auf F werden lazy bearbeitet: solange es noch Platz gibt im Feld Op werden sie einfach hinten in Op eingefügt statt das Feld F direkt zu bearbeiten das Feld F bleibt also unverändert. Wir nehmen an, dass eine solche Einfügeoperation auf Op konstante Kosten O(1) hat. Sobald das Op-Feld aber voll ist, muss ein update() ausgeführt werden, bei welchem alle in Op gespeicherten Operationen auf das Feld F übertragen werden und Op geleert wird. Natürlich soll das Feld danach wieder sortiert sein. Wir nehmen an, eine solche update() Funktion habe Kosten in O(n). Die f ind() Operation sucht immer zuerst in F nach einem Element; danach wird in Op geschaut, ob das Element bereits gelöscht oder noch nicht in F eingefügt wurde. Zeigen Sie mit Hilfe der Kontomethode, dass der amortisierte Aufwand für die Operationen insert(), remove() und find() durch diese lazy Bearbeitung durch O( n) beschränkt ist.

Ähnliche Dokumente

s(x, i) = i h 2 (x), i N 0

s(x, i) = i h 2 (x), i N 0 TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen SS 2009 Grundlagen: Algorithmen und Datenstrukturen Übungsblatt 5 Prof. Dr. Helmut Seidl, S. Pott,