Julius-Maximilians-Universität Würzburg Institut für Informatik Lehrstuhl für Informatik I Effiziente Algorithmen und wissensbasierte Systeme Seminarausarbeitung Entwurf und Analyse von Datenstrukturen Splay Trees Mirco Lukas und Alexander Werthmann Datum: 26.06.2013 Betreuer: Dr. Jan-Hendrik Haunert
Inhaltsverzeichnis 1 Anwendungsbereich des SplayTrees 3 2 Rotationen eines Splay Trees 4 2.1 Einführung................................... 4 2.2 Zick-Rotation.................................. 4 2.3 Zack-Rotation.................................. 5 2.4 Zick-Zick-Rotation und Zack-Zack-Rotation................. 5 2.5 Zack-Zick-Rotation und Zick-Zack-Rotation................. 6 3 Wörterbuchoperationen 7 3.1 Splay(x)..................................... 7 3.2 Search(k).................................... 8 3.3 Insert(k,v).................................... 9 3.4 Remove(k).................................... 10 4 Laufzeitanalyse 12 4.1 Einführung: Amortisierte Analyse....................... 12 4.2 Laufzeitanalyse von splay().......................... 13 4.3 Laufzeitanalyse von search().......................... 15 4.4 Laufzeitanalyse von insert().......................... 15 4.5 Laufzeitanalyse von remove()......................... 15 4.6 Zusammenfassung............................... 15 Anhang: Quellen der Präsentation 16 Literaturverzeichnis 17 2
1 Anwendungsbereich des SplayTrees Man stelle sich eine große Kundendatenbank vor, die als Binärbaum verwaltet werden soll. Die einzelnen Kundenfilialen, die diese Datenbank benutzen, benötigen allerdings hauptsächlich nur eine kleine Teilmenge der Datenbank, um ihre Arbeit zu erledigen (z.b. pro Filiale hauptsächliche die Kunden der Stadt von der entsprechenden Filiale). Trotzdem soll aber jede Filiale jederzeit auf die gesamte Datenbank zugreifen können. Die Abbildung 1.1 zeigt in einem Beispiel die Problematik dabei: Die Knoten x 8, x 9..., x 13 werden mit sehr hoher Wahrscheinlichkeit bearbeitet, die andere Knoten hingegen mit viel geringerer Wahrscheinlichkeit. Abb. 1.1: Bsp. Zugriffsstatistik auf Knoten der Kundendatenbank Der Splay-Tree optimiert den Zugriff auf wenige Knoten, die aber häufig benötigt werden. Dies erreicht er, indem er jeden aktuell gesuchten Knoten mit Hilfe geschickter Rotationen zur Wurzel macht. So wird erzielt, dass die häufig gesuchten Knoten sich nach einer gewissen Anzahl von Operationen in den oberen Schichten des Baumes befinden und so für weitere, noch folgende Operationen, schneller zur Verfügung stehen. 3
2 Rotationen eines Splay Trees 2.1 Einführung Beim Ausführen des Befehls splay() wird der angefragte Knoten nach oben transportiert. Es gibt insgesamt sechs mögliche Rotationen in einem Splay Tree, wobei jeweils zwei symmetrisch sind: Zick- oder Rechts-Rotation mit symmetrischer Zack- oder Linksrotation 1 Zick-Zick-Rotation mit symmetrischer Zack-Zack-Rotation Zick-Zack-Rotation mit symmetrischer Zack-Zick-Rotation Im folgenden werden die Rotationen genauer erläutert. Eine sehr gute Veranschaulichung liefert [Gog07] mit einer Web-Applikation auf Java-Basis. 2.2 Zick-Rotation Für einen Knoten, der nur einen Vaterknoten, aber keinen Großvaterknoten hat, verwendet man eine einfache Rotation. Ist der Knoten ein linkes Kind, so wird es rechtsrotiert. Abb. 2.1: Vorgehen bei der Rechtsrotation Man beachte, dass die Knoten wie in einem Binärbaum üblich in Abb. 2.1 so sortiert sind, dass der kleinste Knoten ganz links und der größte ganz rechts steht. Die 10, ursprünglich Vaterknoten der 5, wird nun zu deren linken Kind. Da die 5 ebenfalls Kinder hat, wird das linke an die 10 gehängt. Somit ergibt sich der Baum in Abb. 2.2. Bei der Abbildung 2.2 erkennt man, dass die Binärbaum-Eigenschaft 2 erhalten bleibt. Algorithmus 1 zeigt die Implementierung der Rechtsrotation. 1 Die Benennung der Rotationen als Zick bzw. Zack ist für Splay Trees gängig und in allen Quellen so zu finden. Daher werden wir den Begriff ebenfalls verwenden. 2 Kleinstes Element links, größtes Element rechts 4
Abb. 2.2: Der Baum nach der Rechtsrotation Algorithmus 1: Rechtsrotation Eingabe : Knoten h, um den rechtsrotiert werden soll 1 Node x = h.left 2 h.left = x.right 3 x.right = h 2.3 Zack-Rotation Hier tritt genau der symmetrische Fall ein. Nehmen wir die Grafik nach der Rechtsrotation (Abb. 2.2) her. Mit dem Pseudocode 2 kann der Baum wieder in den Ursprunszustand (Abb. 2.1) überführt werden. Algorithmus 2: Linksrotation Eingabe : Knoten h, um den linksrotiert werden soll 1 Node x = h.right 2 h.right = x.left 3 x.left = h Die Zick- und die Zackrotation zusammen bilden die Grundlage für alle erweiterten Rotationen. 2.4 Zick-Zick-Rotation und Zack-Zack-Rotation Diese Rotation wird durchgeführt, falls ein Knoten einen Großvater hat und es das linke Kind seines Vaters ist, der wiederum linkes Kind seines Vaters ist. Gegeben sei der Baum in Abb 2.3. Der Knoten soll nun an die Wurzel gespült werden. Hierzu führt man zwei Rechtsrotationen aus, zuerst um die 18, dann um die 15 (vgl. Abb. 2.4). 3. Die Zack-Zack-Rotation funktioniert wieder analog. Man lese die Abb 2.4 von rechts nach links. 3 [And10], 12f. 5
Abb. 2.3: Der Baum vor der Rotation Abb. 2.4: Das Aussehen eines Binärbaums bei einer Zick-Zick-Rotation 2.5 Zack-Zick-Rotation und Zick-Zack-Rotation Auch hier führt man zwei Rotationen durch. Allerdings ist hier der Knoten das rechte Kind (Vgl. Abb. 2.5). Abb. 2.5: Das Aussehen eines Binärbaums bei einer Zick-Zick-Rotation Die Zick-Zack-Rotation funktioniert wieder analog. Man lese die Abb 2.5 von rechts nach links. 6
3 Wörterbuchoperationen Wir wollen nun die Wörterbuchoperationen des SplayTrees, also die Operationen für das Suchen, Einfügen und Löschen von Knoten, anhand von Pseudocodes vorstellen. 1 3.1 Splay(x) Die Splaymethode analysiert die Grandparent-Parent-Konstellation des Eingabeknoten x. Es wird also festgestellt, ob x und sein Parent linke oder rechte Kinder ihres Parents sind. Nun führt die Splaymethode in den Zeilen 8-19 für jede Knotenkonstellation die jeweils richtige Doppelrotation (siehe Kap. 2.4 und 2.5) aus, um x nach oben zu rotieren. Falls x bereits Kind der Wurzel des Baumes ist, muss nur einmal rotiert werden. Die While-Schleife in Zeile 1 hat als Bedingung ϕ(x) nil, damit solange rotiert wird, bis x Wurzel des Baumes geworden ist, denn die Wurzel hat keinen Parent. 1 Die Pseudocodes wurden auf Basis von verschiedenen Implementierungen aus dem Internet oder teils auch völlig frei selbst erstellt. Sie haben daher keine Quellenangaben. 7
Algorithmus 3: Splay(Node x) Eingabe : Knoten x, der zur Wurzel transportiert werden soll 1 while ϕ(x)!= nil do 2 y = ϕ(x) 3 z = ϕ(y) 4 if x == root.left then 5 RightRotate(root) 6 if x == root.right then 7 LeftRotate(root) 8 if x == left[y] and y == left[z] then 9 Right-Rotate(z) 10 Right-Rotate(y) 11 else if x == right[y] and y == right[z] then 12 Left-Rotate(z) 13 Left-Rotate(y) 14 else if x == right[y] and y == left[z] then 15 Left-Rotate(y) 16 Right-Rotate(z) 17 else if x == left[y] and y == right[z] then 18 Right-Rotate(y) 19 Left-Rotate(z) 3.2 Search(k) Die Suchoperation soll den Knoten mit Schlüssel k im Baum finden und zur neuen Wurzel des Baumes machen. Der Pseudocode dazu ist denkbar einfach: Es wird in den Zeilen 3-10 die bereits bekannte Binärbaumsuche angewandt. Ist die Suche beendet, so wird der Knoten am Ende noch zur Wurzel gespült und zurückgegeben. Falls der Knoten mit dem gewünschten Schlüssel jedoch nicht gefunden wurde, wird der Knoten, an dem die Binärsuche endet also der potentielle Parent des Knoten x mit Schlüssel k zur Wurzel gespült. Diesen wichtigen Nebeneffekt werden wir uns bei den anderen beiden Wörterbuchoperationen noch zu Nutze machen. 8
Algorithmus 4: Search(Node root, Key k) Eingabe : Schlüssel k, dessen Knoten -falls vorhanden- zur Wurzel transportiert werden soll 1 z = root 2 p = root 3 while z!= nil do 4 p = z; 5 if z.key > k then 6 z = z.left 7 else if z.key < k then 8 z = z.right 9 else 10 break 11 if z == nil then 12 z = p 13 splay(z) 14 return root 3.3 Insert(k,v) Bei der Analyse der Einfügeoperation fallen sofort zwei Spezialfälle auf: 1. Der Fall, dass der Baum leer ist, in Zeilen 1-3: Hier können wir aus k und v einfach einen neuen Knoten erzeugen und diesen als Wurzel in den Baum einsetzen. 2. Die Möglichkeit, dass bereits ein anderer Knoten mit Schlüssel k im Baum existiert, in Zeile 17f.: Wenn nach der Binärbaumsuche in Zeile 4 der Schlüssel k weder größer noch kleiner als root.k ist, sind die Schlüssel identisch und wir überschreiben einfach die alten Nutzdaten root.v mit den neuen Daten v, ohne einen neuen Knoten zu erzeugen. Ist aber noch kein Schlüssel k im Baum benutzt, so spült search(k) den potentiellen Parent von einem Knoten mit Schlüssel k zur Wurzel. Wir können nun den Einfügevorgang bequem an der Wurzel durchführen, indem wir einen neuen Knoten n erzeugen und den bisherigen Wurzelknoten als linkes(rechtes) Kind von n setzen, falls die Wurzel kleiner(größer) n ist. 9
Algorithmus 5: Insert(Key k, Value v) Eingabe : Wertepaar aus Schlüssel k und Nutzdaten v, das nach der Operation als neuer Knoten im Splaytree stehen soll 1 if root == nil then 2 Let root be new node with Key k and Value v 3 return 4 search(root, k); 5 if k < root.key then 6 Let n be new node with Key k and Value v 7 n.left = root.left 8 n.right = root 9 root.left = nil 10 root = n 11 else if k > root.key then 12 Let n be new node with Key k and Value v 13 n.right = root.right 14 n.left = root 15 root.right = nil 16 root = n 17 else 18 root.value = value 3.4 Remove(k) Die Löschmethode geht nach einem sehr anschaulichen Plan vor: Sie sucht den Knoten mit Schlüssel k, um ihn zur Wurzel zu bringen (Zeile 3 ). Falls der Schlüssel der Wurzel nun k entspricht, wird die Wurzel gelöscht und der Baum in zwei Teile (einen linken und einen rechten Teilbaum) gespalten. Diese Teilbäume sollen nun wieder zu einem neuen Baum vereinigt werden. Die Lösung hierfür ist recht geschickt: Remove() holt sich mit einem Aufruf von Search() auf den linken Teilbaum das Maximum des linken Teilbaums in die Wurzel. Da dieses Maximum im linken Teilbaum kein rechtes Kind hat (da es ja selbst den größten Schlüssel hält), kann an die freie Stelle nun der rechte Teilbaum gesetzt werden und die Bäume sind wieder zu einem Ganzen vereinigt. 10
Algorithmus 6: Remove(Key k) Eingabe : Schlüssel k, dessen Knoten -falls vorhanden- aus dem Baum gelöscht werden soll 1 if root == nil then 2 return 3 search(root, k) 4 if k == root.key then 5 if root.left == nil then 6 root = root.right; 7 else 8 x = root.right 9 root = root.left 10 search(root, k) 11 root.right = x 11
4 Laufzeitanalyse 4.1 Einführung: Amortisierte Analyse Das Ziel dieses Abschnitts ist es, den folgenden Satz zu beweisen: Satz 4.1 (Amortisierte Laufzeit). Alle Operationen eines Splay Trees laufen in amortisiert O(log n) Zeit. Vorgehensweise beim Beweis: 1. Führe auf der Operation splay() eine amortisierte Laufzeitanalyse durch (kompliziert) 2. Analysiere die anderen Funktionen (einfach, wenn Laufzeit von splay() bekannt ist) Man weist jedem Zustand des Baumes ein Potential zu. Zur Erinnerung Definition 4.2 (Potentialfunktion). 1 Eine Potentialfunktion ist eine Funktion mit D i : i-ter Zustand der Datenstruktur. Φ : D i R Man betrachtet nun das Potential vor der Operation und nach der Operation. Die Datenstruktur darf niemals ein negatives Potential haben. Die Potentialfunktion sehe nun wie folgt aus: a = t + Φ + Φ, wobei Φ := Potential vor der Operation, Φ := Potential nach der Operation, t := tatsächliche Kosten und a := amorisierte Kosten. Das m-malige Ausführen einer Operation kostet somit m m m a j = t j + Φ j 1 Φ j = Φ 0 Φ m + t j. j=1 j=1 j=1 Der rechte Teil der Gleichung ergibt sich, da eine Teleskopsumme vorliegt. 1 [Wol12], 115 12
4.2 Laufzeitanalyse von splay() Pseudocode siehe Algorithmus 3. Rotationen haben konstante Laufzeit: O(1) Die while-schleife wird h mal durchlaufen, wobei h := Höhe des Baumes Wir zeigen, dass h O(log n) mit Hilfe des Lemmas 4.5. Zunächst definieren wir zwei wichtige Begriffe (Definitionen 4.3 und 4.4. Definition 4.3 (Größe). Die Größe s(x) ist definiert als s(x) := k Kind von s w(k). Definition 4.4 (Rang). Der Rang r(x) ist definiert als r(x) := log 2 s(x). Lemma 4.5 (Laufzeit von splay()). Die Funktion splay() hat die Laufzeit O (log(n)). Wir verwenden für den Beweis einen Ausschnitt aus dem Baum, wobei die Knoten wie in Abb. 4.1 benannt sind. Abb. 4.1: Referenzbaum für die Analyse Beweis. 2 Für n = 0 und n = 1 Knoten ist die Aussage sicher richtig, da keine Rotation ausgeführt werden muss. Sei also nun n > 1. 1. Eine Rotation wird ausgeführt. r (x) r(x) + r (y) r(y) 1 + r (x) r(x) (4.1) 1 + 3 (r (x) r(x)) (4.2) (4.1) weil y einen höheren Rang bekommt, ist r(y) r (y) r (y) r(y) 0 (4.2) Wir zeigen in Fall 2, dass dies logarithmische Laufzeit hat. 2 [TS85], 658 und [Sch11], 3 13
2. Zwei Rotationen werden ausgeführt. 3 2 + r (x) r(x) + r (y) r(y) + r (z) r(z) = 2 r(x) + r (y) r(y) + r (z) (4.3) 2 + r (x) + r (z) 2r(x) (4.4) 3r (x) 3r(x) (4.5) 2 + r (z) 2r (x) r(x) (4.6) 2 2r (x) r(x) r (z) (4.7) r(x) + r (z) 2r (x) 2 (4.8) log s(x) + log s (z) 2 log s (x) 2 (4.9) ( ) ( s(x) s ) (z) log s + log (x) s 2 (4.10) (x) (4.5) Diese Gleichung versteht man am besten, wenn man sich die Rotationen ansieht (vgl. Abb. 4.2). Abb. 4.2: Rotationsverhalten (4.10) Weil r = log s gilt, suchen wir nun max{x}, max{y}, sodass gilt: log x + log y 2 und x, y 1. Das stimmt für x = y = 1 2, denn log 1 2 = 1 also stimmt die Aussage für Fall 2. Summiert man nun die Zeiten für die Rotationen auf, so ergibt sich eine Teleskopsumme, die nach oben durch 1 + 3(r (x) r(x)) beschränkt ist. Nach Fall 2 ist das logarithmisch. Daraus folgt das Korollar 4.6. Ein Splaybaum hat die erwartete Höhe h O(log n). Mit diesem Satz werden die Analysen der anderen Funktionen sehr leicht. 3 Wir zeigen hier den Fall der Zick-Zick-Rotation. Der Beweis der Zick-Zack-Rotation funktioniert analog. 14
4.3 Laufzeitanalyse von search(). Pseudocode siehe Algorithmus 4 Alle Operationen in der while-schleife sind in O(1). Die while-schleife selbst wird h mal durchlaufen splay() O(log n) search() O(log n) = O(log n) + O(log n) 4.4 Laufzeitanalyse von insert() Pseudocode siehe Algorithmus 5. search() O(log n) Alle anderen Operationen sind in O(1). insert() O(log n) 4.5 Laufzeitanalyse von remove() Pseudocode siehe Algorithmus 6. search() O(log n) Alle anderen Operationen sind in O(1). search() O(log n) 4.6 Zusammenfassung Der Splay Tree implementiert alle Operationen in O(log n) Zeit. Ein Baum hat im schlechtesten Fall die Höhe O(n). Dadurch kostet splay() die Zeit O(n). Aber: Ein Splay-Baum wird für häufige Zugriffe weniger Elemente aus einer großen Datenmenge verwendet. Dadurch stehen diese nahe der Wurzel. Durch amortisierte Analyse kann man jedoch zeigen, dass h O(log n). 15
Anhang: Quellen der Präsentation Folgende Quellen wurden zusätzlich in der Präsentation verwendet: Folien 181f. (Rotation eines entarteten Baumes): [TS85], 657 Folien 187, 227-229: (Übungsaufgabe): [TS85], 657 16
Literaturverzeichnis [And10] James Anderson: Splay Trees. Online-Präsentation, 2010. http://astronomy. swin.edu.au/~pbourke/stereographics/stereorender/. [Gog07] Arsen Gogeshvili: Binary Search Trees, 2007. http://www.qmatica.com/ DataStructures/Trees/BST.html, Java-Webanwendung. [Sch11] Joseph Schröer: Seminar Algorithmen: Splay Bäume. online, 2011. http://www.inf.fu-berlin.de/lehre/ss11/semalg/splayb%c3%a4ume% 20-%20Zusammenfassung.pdf. [TS85] Robert Tarjan und Daniel Sleator: Self-Adjusting Binary Trees. Journal of the Association for Computing Machinery, 32(3):652 686, 1985. [Wol12] Alexander Wolff: Amortisierte Analyse. In: Vorlesung Algorithmen und Datenstrukturen. WS 2011/12. 17