Rekurrenzen T(n) = T(n 1) + N beschreibt Laufzeitverhalten eines rekursiven Algorithmus

Transkript

1 Algorithmen und Datenstrukturen Übung Rekurrenzen T(n) = T(n ) + N beschreibt Laufzeitverhalten eines rekursiven Algorithmus Bsp. Fibunacci F(n) = F(n ) + F(n ) N F(0) = F() = F(N) rekursive Aufrufe,8 N ~ N ) Enfaltung: immer wieder einsetzen, bis man eine Regelmäßigkeit entdeckt T(N) = T( N ) + N N T() = T(N) = T N = T N = T N = T N 8 = 8T N 8 + N = + N + N = + N + N = + N = + N = = i T N i + in N = i i = ldn ildn setzt man in T ein: T(N) = ld N N T N ld N + T(N) = N + NldN O(N + NldN) ldn N= N ld N --

2 Algorithmen und Datenstrukturen Übung ) Raten und Beweisen: T(N) = T( N ) + N N T() = Guess: T(N) = N + NldN Beweisen durch Induktion: Basis: T() = + ld = Schritt: T(N) = T N + N = = N + N ld N + N = = N + N(ldN ) + N = = N + NldN N + N = = N + NldN NR : ld N = ldn ld = ldn ) Master Theorem: für Rekurrenzen der folgenden Art: T(n) = at( n b ) + f(n) mit a, b und f(n) asymptotisch positiv und n b kann entweder n oder n bedeuten Bsp. T(N) = T( N ) + N. a = b = f(n) = N. N log b a = N log = N jetzt die Fälle betrachten: ε=0. (ist positiv, daher Fall ) immer machen (f(n) = N +0. ε=0.) hier Fall : af( N ) = ( N b ). = N. = N. = N.. 0. c = T(N) = O(N. ) = f(n) --

3 Algorithmen und Datenstrukturen Übung Abstrakte Datentypen ) abstrakte Datenstrukturen (ADS) = Menge von Daten und den zugehörigen Operationen A B C D Operationen Daten nur über diese Operationen auf die Daten Zugriff nur Exemplar ) Abstrakter Datentyp A B C D beliebig viele Exemplare ) Klasse Operationen sind bei den Daten eingebaut A B C D A B C D wieder: beliebig viele Exemplare zur Übung: head cur Einfügen: public class LinkedList implements List{ private Node head; public void add(object o){ Node cur; if (head==null) head=new Node(o); else { cur=head; while (cur.next!=null) cur=cur.next; --

4 Algorithmen und Datenstrukturen Übung } } cur.next = new Node(o); } Dummy-Element: immer ein Element da, d.h. Sonderfälle, wenn Liste leer, fallen weg Löschen (mit Dummy-Element): (erstes Vorkommen des Elements wird gelöscht) public boolean remove(object o){ Node cur=head; while ((cur.next!=null) && (!cur.next.elem.equals(o))) cur=cur.next; if (cur.next!=null) return false; cur.next=cur.next.next; return true; } Bäume Binärbäume 8 if kleiner dann links else rechts 8 inorder-durchlauf:. linker Teilbaum. Knoteninhalt diese Folge bei jedem Knoten von vorne anfangen. rechter Teilbaum imbsp: 8 preorder-durchlauf:. Knoteninhalt. linker Teilbaum diese Folge bei jedem Knoten von vorne anfangen. rechter Teilbaum x = ( + ) (0 + ) --

5 Algorithmen und Datenstrukturen Übung - * * + +0 =Präfix-Notation postorder-durchlauf: Sinn: Stack: x = ( + ) (0 + ) Addition ausführen Multiplikation ausführen 0 Addition ausführen Subtraktion ausführen also. linker Teilbaum. rechter Teilbaum. Knoteninhalt diese Folge bei jedem Knoten von vorne anfangen - *

6 Algorithmen und Datenstrukturen Übung + * =Postfix-Notation zur Übung: zu b) public void inorder(){ myinorder(root); } private void myinorder(node n){... myinorder(n.left); // Ausgabe von Knoteninhalt von n myinorder(n.right); } NumberOfNodes: wirklich durchzählen --

7 Algorithmen und Datenstrukturen Übung Heap Key (Parent) Key(Children) = Ordnungsrelation Einfügen: 0 : : : : upheap: : upheap: 0 0 0: *upheap: 0 : --

8 Algorithmen und Datenstrukturen Übung Löschen: 0 0: downheap: downheap: -8-

9 Algorithmen und Datenstrukturen Übung Einfügen mit Bottom-Up-Verfahren: 0 n+ Blätter 0 downheap in beiden Bäumen 0 0 downheap 0 downheap 0 Beim Einfügen in eine Datenstruktur: Baum ineinem Array abspeichern (zeilenweise) 8 linker Sohn: i (i ist Index des Knotens) rechter Sohn: i + Parent: i Einfügen immer an der letzten Position Suchen im Heap: im Array: --

10 Algorithmen und Datenstrukturen Übung Wegen der Ordnungsrelation kann man im Heap z.b. sofort sagen, daß 8 nicht enthalten ist. 0 0 = wieder a rekursive gesucht Change Priority: wenn man oben im Beispiel z.b. er durch einen er ersetzt Binärer Suchbaum 8 8 rechter Teilbaum < linker Teilbaum 8 8 Suchen im Binärbaum: rekursiv: Node find(int key, Node n){ if (n==null) return null; if (key==n.key) return n; if (key<n.key) return find(key, n.left); return find(key, n.right); } iterativ: Node find(int key, Node n){ while ((n!=null)&&(key!=n.key)){ if (key<n.key) n=n.left; -0-

11 Algorithmen und Datenstrukturen Übung } } else n=n.right; Löschen:.) Löschen eines Blattes (trivial).) Löschen eines Knotens mit nur einem Sohn: z.b. löschen von Knoten ) Löschen eines Knotens mit Söhnen: a) einer der Söhne hat keine Söhne b) rechter Sohn hat keinen linken Sohn oder linker Sohn hat keinen rechten Sohn den jeweiligen Knoten nach oben ziehen c) beide Söhne haben zwei Söhne oder wiedersprechen Punkt b) z.b. Löschen von Knoten (im ursprünglichen Baum): man bestimme den Nachfolgerknoten: dieser ist im rechten Teilbaum und innerhalb von dem, im linken Teilbaum suchen, bis irgendwo der Links-Zeiger null ist. Im Bsp. ist 8 der Nachfolger also:.) Suche Nachfolgeknoten.) Linkszeiger vom Vaterknoten (NF) zeigt auf rechten Sohn von NF.) Links- und Rechts-Zeiger von NF korrigieren.) Vaterknoten (Wurzel) muß auf NF zeigen --

12 Algorithmen und Datenstrukturen Übung AVL-Bäume = Balancierte Binärbäume für jeden Knoten gilt: die Höhen seiner Teilbäume sind um maximal verschieden der Knoten, wo die AVL-Eigenschaft verletzt ist c) z Höhe = Ordnen der Größe nach b) y Höhe = b) a) x Höhe = a) c) wenn noch Teilbäume daran hängen verschiedene Fälle: ) z/a y/b b T 0 x/c a c T T T T 0 T T T ) c/z b/y b T a/x a c T T 0 T T 0 T T T ) z/a y/c b T 0 x/b a c T T T T 0 T T T --

13 Algorithmen und Datenstrukturen Übung ) c/z a/y b T b/x a c T 0 T T T 0 T T T Beispiel: 0 z/a y/b x/c T 0 8 T T T 0 neu eingefügter Knoten b 0 a c 8 T 0 T 0 T T Löschen: zuerst ganz normal löschen, dann Knoten z suchen, der unbalanciert ist -y= Sohn von z mit größerer Höhe -x = Sohn von y mit größerer Höhe --

14 Algorithmen und Datenstrukturen Übung Beispiel: 8 löschen: c/z 8 b/y T a/x T T 0 T b a c 8 T 0 T T T Hashing Hashfunktion: meist Divisionsrestmethode 0 Elem mit Key einsetzen: mod = z.b. mod = mod = 0 8 mod = ist schon besetzt mod =... Listenlänge Lineare Kollisionsstrategie man geht immer ein Feld weiter, bis man ein freies findet dort einfügen. Stößt man dabei auf das Ende der Liste, dann beginnt man wieder am Anfang zu schauen; d.h. immer (Feld+) mod. Wenn man was sucht: wenn man auf ein leeres Feld trifft, weiß man, daß das gesuchte Element nicht enthalten ist. 0 8 Löschen von 8: 0 --

15 Algorithmen und Datenstrukturen Übung Suche von stößt auf leeres Feld, obwohl enthalten ist Lösung: Flags setzen die sagen, ob ein Feld leer, voll oder ggelöscht wurde 0 E E E E E E E E... EMPTY 0 8 O O E E O O O O... OCCUPIED 0 O O E E O D O D... DELETED Beim Suchen schaut man dann auch den Inhalt der DELETED-Flags an In einer Hash-Table können keine zwei Einträge mit gleichem Schlüssel sein. Quadratische Kollisionsstrategie d.h. bei Kollisionen geht man in quadratischen Abständen nach rechts bzw. nach links 0 x also: +,,+,,... am Bsp einfügen: + einfügen: + besetzt - Größe einer Hashliste sollte eine Primzahl sein. Hashliste sollte zu max. 80% ausgelastet werden Graphen G=(V,E) V... Menge der Knoten (Vertex) E... Menge der Kanten (Edge) V={a,b,c,d} E={[a,b], [b,d], [c,d]} --

16 Algorithmen und Datenstrukturen Übung a b c d Adjazenz: Knoten durch eine Kante verbunden Grad: Anzahl der Kanten, die von diesem Knoten ausgehen Pfad: Folge von adjazenten Knoten Verbundener Graph: kein Knoten im Graph, der nicht ereichbar ist Komponente: maximal verbundener Subgraph Baum: verbundener Graph ohne Zyklen Wald: Menge von Bäumen (d.h. jede Komponente ist ein Baum) Spannender Baum: (ST, spanning tree) kein ST STs d.h. alle Knoten erreichbar, keine Kante redundant also: ST ist ein Baum ST enthält alle Knoten Adjazenzmatrix: --

17 Algorithmen und Datenstrukturen Übung Depth-First-Search Algorithmus(DFS) Hilfsarray: x markieren, prüfen: (weil dieser als einziger von aus erreichbar ist) x x markieren, prüfen:, x x x markieren, prüfen:,, x x x x markieren, prüfen:,, x x x x x markieren, prüfen:, x x x x x x markieren, prüfen: also: Rekursion immer zuerst in die Tiefe (Depth-First) Statt eines Hilfsarrays könnte man auch die Hauptdiagonale der Matrix verwenden, da diese ohnehin nicht gebraucht wird Bsp. eines nicht zusammenhängenden: zuerst: --

18 Algorithmen und Datenstrukturen Übung x x x nrc= (nrc... number of components) dann DFS beginnend bei : x x x x x nrc= dann noch DFS beginnend bei : nrc= x x x x x x Breadth-First Search (Breitensuche) Besuchte Knoten Queue,,,, - Minimale Wege (Dijkstra) -8-

19 Algorithmen und Datenstrukturen Übung BK NK S() S() S() S() S() S() min. Weg {} {,,,,} (0) {,} {,,,} (0) () + {,,} {,,} (0) () + + () {,,,} {,} (0) () + (+) + () + {,,,,} {} (0) () (+) (+) 0+ () 0+ [,,,,,} {} Kruskal (minimal spannender Baum) 0 8 ausgehend vom leeren Graphen; Kante mit geringstem Gewicht eintragen; dann immer mit dem nächst größten Gewicht; wenn eine Kante nicht paßt (wegen Zyklus) auslassen --

20 Algorithmen und Datenstrukturen Übung -0-