(a, b)-bäume / 1. Datenmenge ist so groß, dass sie auf der Festplatte abgespeichert werden muss.

Transkript

1 (a, b)-bäume / 1. Szenario: Datenmenge ist so groß, dass sie auf der Festplatte abgespeichert werden muss. Konsequenz: Kommunikation zwischen Hauptspeicher und Festplatte - geschieht nicht Byte für Byte, sondern Seite für Seite (1 Seite = 2048 oder 4096 Bytes, Paging) ist etwas effizienter, falls auf aufeinander folgende Seiten zugegriffen wird, - ist um Faktor langsamer als interne Zugriffe auf Hauptspeicher. Aufgabe: Organisiere Daten auf Platte, so dass möglichst wenig Paging notwendig wird. (I/O-effiziente Datenstrukturen)

2 (a, b)-bäume / 2 Definition Seien a, b N, a 2, 2a - 1 b. Ein Baum T heißt (a, b)-baum, falls gilt: (i) (ii) (iii) Alle Blätter von T haben gleiche Tiefe. Alle Knoten haben höchstens b Kinder. Die Wurzel hat mindestens 2 Kinder, alle anderen Knoten haben mindestens a Kinder.

3 (a, b)-bäume / 3 T ist Suchbaum für die Menge S = {x 1,..., x n }, x 1 < x 2 <... < x n, falls gilt: (iv) (v) (vi) In einem Blatt sind eine Anzahl von Schlüsseln gespeichert mit a b. In einem inneren Knoten mit Kindern sind - 1 Schlüssel in aufsteigend geordneter Reihenfolge gespeichert. Falls in v die Schlüssel x 1 < x 2 <... < x -1 gespeichert sind, sind im i-ten Teilbaum nur Schlüssel aus - i = 1 : (-, x 1 ) - 1 < i < -1 (x i-1, x i ) - i = - 1 (x, ) gespeichert.

4 (a, b)-bäume / 4 Beispiel: Ein (2,3) Baum I G O,T A H L, M R,S U

5 (a, b)-bäume / 5 Bemerkung: T sei (a, b)-baum mit n Knoten. Dann gilt: n +1 log b (n + 1) Tiefe (T) log a +1 2 Satz Die Operationen Insert, Delete, Search können in (a, b)-bäumen so implementiert werden, dass nur auf O (log a (n)) viele Seiten, je konstant oft zugegriffen werden muss. Die Bearbeitungszeit pro Seite ist O (log(a)) bei Search, O (a) sonst.

6 (a, b)-bäume / 6 Search (x): Starte bei der Wurzel. Angekommen in v mit Schlüsseln x 1,..., x gehe in den i-ten Ast, falls x (x i-1, x i ) ist (bzw. (-, x 1 ) für i = 1, (x, ) für i = l). Falls x = x i gefunden STOP. Falls Nil-Zeiger erreicht wird Suche erfolglos STOP. # Seiten: O (Tiefe (T)) = O (log a (n)). Zeit pro Seite: O (log (a)).

7 (a, b)-bäume / 7 Insert (x): (nach erfolgloser Suche, Ende der Suche im i-ten Nilzeiger von Blatt v.) 1. Hänge x als i-ten Sohn an v. x hängt auf zu tiefem Level. 2. Füge x in die Schüssel x 1 <... < x in v ein. x 1 <... < x i-1 < x < x i <... < x Fall a) < b - 1 Füge neuen i-ten Zeiger ein, alter i-ter Zeiger neuer i + 1-ter Zeiger alter + 1-ter Zeiger neuer + 2-ter Zeiger v hat + 1 b - 1 Schlüssel und + 2 b Zeiger. fertig, STOP.

8 (a, b)-bäume / 8 Fall b) = b-1 Splitte v in 2 Knoten wie folgt: (sei (x 1,..., x i-1, x, x i,...,< x b-1 ) = (y 1,..., y b )) Und füge y 2 in Vater von v rekursiv, nach gleichem Verfahren ein. Falls v Wurzel ist, wird sie gesplittet, y b 2 b wird neue Wurzel. (Beachte: Wurzel darf Grad 2 haben!) Zeit: Pro Schritt entlang des Weges zur Wurzel Zeit O (a). # Schritte = Tiefe des Baumes = O (log a (n)).

9 (a, b)-bäume / 9 Delete (x): (nach erfolgreicher Suche, x = y i von (y i,..., y) in Knoten v.) Falls v kein Blatt ist, vertausche x mit x = max {z, S, z < y i }. Wir müssen nun x aus v streichen. Fall a)v hat a viele Schlüssel Streiche x, STOP. Fall b)v hat a - 1 Schlüssel. Streiche x. Dann verletzt das Streichen die Regel. Fall b1) Ein direkter Bruder v von v (obda der rechte) hat a Schlüssel.

10 (a, b)-bäume / 9.1 Fall b2) Beide direkten Brüder haben a-1 Schlüssel. Verändere v und den rechten Bruder v wie folgt: v v Streiche (rekursiv) z i aus (= Vater von v, v ). Falls die Wurzel ist, und durch das Streichen in Fall b2) leer wird, wird die Wurzel gestrichen, und der (dann einzige) Sohn der Wurzel wird neue Wurzel. Zeit: Pro Schritt O (a) # Schritte: O (log a (n)).

11 Skip - Listen /1 X = (x 1 < x 2 <.. < x n ) soll verwaltet werden Benutze Lineare Listen L o,...,l h, x i wird in L o, L 1,..., L h (x i ) - 1 verwaltet, jedes L i ist aufsteigend sortiert. X i : Menge der Elemente in L i, es gilt : X = X ο X 1... X h h (x) = Höhe von x "

12 Skip-Listen / 2 Insbesondere gilt also: X 0 = X, X ο X 1... X h Beispiel: L 3 L 2 21 L L Eine Skipliste für X = {5, 8, 10, 14, 16, 21, 25} mit h = 4, h(5) = 2, h(8) = 3, h (10) = 1, h(14) = 3, h(16) = 1, h(21) = 4, h(25) = 2.

13 Skip-Listen / 3 Search (x): i h - 1, Left, gefunden = false Solange I 0 und nicht gefunden : Suche in L i, startend in Left, bis zuerst ein y x gefunden ist. Falls x = y, dann gefunden = true; gebe x aus. Sonst: Left Prev (y); i i - 1. /* Falls x X gilt, ist x Left. */ Falls gefunden = false, gebe Fehlermeldung aus.

14 Skip-Listen / 4 Insert (x) : (i) Erzeuge h (x): Werfe eine Münze (Wahrscheinlichkeit für Kopf = ½) so oft, bis das erste mal Kopf erscheint. h (x) : = # Würfe (ii) Füge x in den sortierten Listen L o,...l h (x) - 1) ein: Falls h (x) > h, erzeuge Listen L h,...,l h (x)-1 Search (x) (liefert Positionen in L o,...h h (x) - 1 ) wo x hingehört) Füge an gefundenen Positionen x ein (Zeit pro Einfügung: O (1) )

15 Delete (x): Skip-Listen / 5 (i) Search (x) (liefert Position von x in L o,..., L h (x) ) (ii) Streiche (x) aus L o,..., L h (x) (Zeit pro Streichung: O (1) ) Zeit für Delete (x) = = O (Zeit für Search (z) ) für ein (x i, x i+1 ), x = x i Dieses ist die teuerste Operation!

16 Skip-Listen / 6 Somit reicht es, die Laufzeitanalyse für Search (z) für ein z X durchzuführen a) Die erwartete Höhe H (n) einer Skip-Liste für n Elemente ist O (log(n)) b) Die erwartete Zahl von Zeigern in einer Skip-Liste mit n Elementen ist höchstens 2n + O (log(n)) Eine Skip-Liste für n Elemente hat erwartete Größe O (n) und erwartete Zeit pro Operation O (log (n))

17 Bäume + Graphen / 1 Definitionen: gerichtet Graph, ungerichtet Graph, Nachher, Vorgänger, Nachfolger, Grad, Ingrad, Outgrad, Weg, einfach Weg, Kreis Zusammenhang, starker Zusammenhang, Zusammenhangskomponenten, starke Zusammenhangskomponenten Baum, Wurzelbaum

18 Bäume + Graphen / 2 Implementationen von Graphen 1 : Adjazenzmatrix: S = (V,E), V = {1,..., n} n x n - Matrix A mit 1 ( i, j) E A[ i, j] = 0 sonst Friedelm Meyer auf der Heide heisst Adjazenzmatrix. Operationen: (i, j) E? Zeit 0(1) Berechnung von Grad, Ingrad, Outgrad: 0 (n) Platz: 0 ( n 2 ) gut für dichte Graphen

19 Bäume + Graphen / 3 Implementationen von Graphen 2 : Adjazenzlisten Array A von n linearen Listen, A [ i ] enthält alle Nachbarn / Nachfolger von i Operationen : (i, j) E? Zeit 0 (Grad (i) ) Berechnung von Grad (j), Outgrad (i) 0 ( Grad (i) / Outgrad (i) ) Berechnung von Ingrad (i) : 0 (IEI) Platz: 0 ( n + IEI ) gut für dünne Graphen

20 Bäume + Graphen / 4 Wurzelbäume: Die Menge W aller Wurzelbäume ist die kleinste Menge, für die gilt: 1. Der Graph, der aus einem Knoten v besteht, ist ein Wurzelbaum, v ist seine Wurzel 2. Falls T 1...,T l W sind, mit Wurzeln v 1,...,v l und v ein neuer Knoten, so ist auch der Graph aus W, der aus T 1,...,T l und v entsteht, wenn wir v als Wurzel wählen, und Kanten (v,v i ), i - 1,...,l sowie alle weiteren Knoten und Kanten aus T 1,...,T l hinzufügen. Als Grad eines Wurzelbaums bezeichnen wir den maximalen Outgrad seiner Knoten. Ein binärer Baum ist ein Wurzelbaum von Grad 2. Ein d-ärer Baum ist ein Wurzelbaum vom Grad d. Die Tiefe eines Wurzelbaums ist die Länge eines längsten Weges von der Wurzel bis zu einem Blatt.

21 Bäume + Graphen / 5 Eigenschaften von Wurzelbäumen: Ein d-ärer Baum der Tiefe t hat höchstens t+ 1 2 t d 1 1+ d + d d = d 1 viele Knoten. Diese Knotenzahl wird erreicht, falls T ein vollständiger, balancierter d-ärer Baum íst, d.h., wenn jeder Knoten bis auf die Blätter Grad d haben, und der Weg von der Wurzel zu jedem Blatt Länge t hat. Ein zusammenhängender Graph mit n Knoten ist genau dann ein Baum, wenn er n - 1 Kanten hat.

22 Bäume + Graphen / 6 Systematisches Durchsuchen von Bäumen Seit T ein Wurzelbaum mit Wurzel v, die Kinder v 1,...,v d von v seien Wurzeln der Teilbäume T 1,...T d. Wir definieren folgende drei Reihenfolgen (Orders) der Knoten von T (rekursive Definitionen): Postorder: Post(T) := Post(T 1 ),..., Post(T d ), v Preorder: Pre(T) := v, Pre(T 1 ),...,Pre(T d ) Inorder: In(T) := In(T 1 ), v, In(T 2 ),...In(T d )

23 Bäume + Graphen / 7 Satz a) Preorder und Inorder zusammen beschreiben Wurzelbäume nicht eindeutig. b) Preorder und Inorder beschreiben binäre Wurzelbäume eindeutig. c) Preorder und Postorder beschreiben Wurzelbäume eindeutig.

24 Tiefensuche / 1 G = (V,E) Graph, V = {1,...,n}, M [1 : n ] zu Beginn: M [ i ] = o für alle i, m = o Away, m Variable, Tiefensuche (Depth First Search, DFS) DFS (G) Solange m < n ist, Suche minimales i > m mit M [ i ] = 0; m i; DFS (G, i). DFS (G, i) M [ i ] 1; Für alle Nachbarn/Nachfolger j von i mit M [ j ] = 0: DFS (G,j).

25 Tiefensuche / 2 DFS (G) besucht jeden Knoten genau ein mal. Zeit, falls G als Adjazenzliste gegeben ist: O ( V + E ) DFS (G) kann Knoten von G durchnummerieren: DFS - Nr. (i) = r i ist der r-te durchlaufene Knoten.

26 Tiefensuche / 3 DFS (G) kann Kanten von S in vier Klassen zerlegen Baumkanten: Kanten, die im Algorithmus genutzt werden, um zu einem noch nicht besuchten Knoten zu gelangen. Erkennung: (i,j) ist Baumkante, falls in DFS (G,i) DFS (G,j) aufgerufen wird. Rückkanten: Kanten (i, j), für die es einen Weg von j nach i über Baumkanten gibt. Erkennung: In DFS (G,i) wird DFS (G, j) nicht aufgerufen, obwohl (i, j) Kante ist, (d.h. j war bereits früher besucht worden) und DFS-Nr (j) < DFS-Nr (i). Vorwärtskanten: Kanten (i,j), die keine Baumkanten sind, für die es aber einen Weg i nach j über Baumkanten gibt. Erkennung: In DFS (G,i) wird DFS (G,j) nicht aufgerufen, obwohl (i,j) Kante ist, und DFS-Nr (i) < DFS-Nr (j). Kreuzungskanten: alle restlichen Kanten.

27 Tiefensuche / 4 Satz: DFS ist ein Rahmenprogramm, das bei Eingabe eines Graphen G in Adjazenzlistendarstellung in O (n + E ) Schritten alle Knoten durchläuft, ggf. die DFS-Nummern definiert, und die Kanten als Vorwärts-, Rück-, Baum- oder Kreuzungskanten markiert. Satz: Kreisfreiheit von Graphen kann in Zeit O (n + E ) getestet werden. Beweis: Es gilt Lemma a) Ein ungerichteter Graph ist zykelfrei, genau dann wenn er ein Wald ist, d.h. nur Baumkanten enthält. b) Ein gerichteter Graph ist zykelfrei, genau dann wenn er keine Rückkanten enthält.

28 Tiefensuche / 5 Satz Ungerichtete Graphen können in Zeit O (n + E ) auf Zusammenhang, gerichtete Graphen auf starken Zusammenhang getestet werden. Lemma Ein gerichteter Graph ist genau dann stark zusammenhängend, wenn es für jeden Knoten v einen Weg von 1 nach v und einen von v nach 1 gibt. Also: Sei G R der Graph, der aus G entsteht, falls wir die Richtung jeder Kante umdrehen. Nach Lemma 6.3 ist G stark zusammenhängend, falls DFS (G,1) und DFS (G R,1) alle Knoten besuchen.

29 Breitensuche Breadth First Search BFS Durchläuft, startend von einem Knoten, erst alle seine Nachfolger, dann deren Nachfolger, usw. Viele Probleme, die mit DFS gelöst werden können, können auch mit BFS gelöst werden.

30