Splay Trees Von Projdakov Benjamin

Inhalt Binäre Suchbäume Amortisierte Analyse Splay Trees Einführung/Potential- Methode Self adjustment Hilfssatz Anwendungsbeispiel Definitionen Rotationen Zugrifslemma Zig / Zag Zig/Zag ZigZig/ZagZag ZigZag/ZagZig Operationen Splay Splay/Suche Satz 1: Splay-Baum Einfügen Satz 2: Binärer Baum mit Splay Löschen

Binäre Suchbäume Eigenschaften: Geordnete Menge von Suchschlüsseln Linkes Kind der kleinere Suchschlüssel Rechtes Kind der größere Suchschlüssel Baum kann zu einer linearen Liste ausarten

Splay Tree Splay-Bäume wurden 1985 von Daniel Sleator und Robert Tarjan unter dem Namen Self-Adjusting Binary Search Trees vorgestellt Hat den Vorteil von Selbstjustierung Benutzt Rotationen für Knotenbewegung Typische Befehle auf Knoten: Suche Füge ein Lösche

Self adjustment Nach jeder Operation steht der bearbeitete Knoten in der Wurzel. Die Tiefe eines Pfads halbiert sich im Schnitt bei Ausführung einer Operation darauf. Oft benutzte Knoten sind näher an der Wurzel.

Beispiel Compiler Compiler: Ein Compiler muss die Variablen und andere Bezeichner eines Programms verwalten. Er kann solche Information in einer Liste oder einer Tabelle behalten. Gerne werden Variablen alphabetisch deklariert und ein Baum entartet zu einer linearen Liste. Wenn einige Bezeichner häufiger verwendet werden, muss man dann mehrmals nach diesen suchen. Ein Splay-Baum würde oft benutzte Variablen an der Wurzel halten und ggf. die Liste zu einem Baum formen.

Rotation: Zig / Zag Zig Zag Nur wenn 1 Schritt zur Wurzel. Bei simpler Implementierung werden 2 Zeiger „umgebogen“.

Rotation: ZigZig / ZagZag Wenn mehr als 1 Schritt zur Wurzel. Bei simpler Implementierung werden 4 Zeiger „umgebogen“.

Rotation: ZigZag / ZigZag Wenn mehr als 1 Schritt zur Wurzel. Bei simpler Implementierung werden 4 Zeiger „umgebogen“.

Operation: Splay Binäre Suche nach Element Falls Knoten nicht im Baum, wird der Vorgänger betrachtet oder Nachfolger, wenn kleiner als alle. Bewegung des Elements in die Wurzel

Operationen: Suche Suche: Einfach eine Splay-Operation mit Rückgabe der neuen Wurzel. Laufzeit von einer Splay-Operation mit Rückgabe der Wurzel.

Operation: Einfügen Füge „x“ ein : Suche nach x, falls x gefunden => Splay x Falls x nicht gefunden, wird der Vorgänger y zur Wurzel. Dann füge x als neue Wurzel ein, mit y linkem Kind von x rechtes Kind von y wird zum rechtem Kind von x. Laufzeit von einer Splay Operation und umbiegen von 3 Zeigern

Operation: Löschen Lösche „x“: Splay x Laufzeit von 2 Splay-Operationen und umbiegen von einem Zeiger Lösche „x“: Splay x Wenn x nicht in der Wurzel, ist man fertig. Entferne x, man erhält nun 2 Bäume. Führe Splay ∞ + auf dem linken Baum aus. Somit linker Baum mit Wurzel, an die man rechts den rechten Baum hängen kann.

Amortisierte Analyse Analyse der durchschnittlichen Kosten von Operationsfolgen. Es werden nicht die maximalen Kosten der einzelnen Schritte betrachtet, sondern es wird der Worst Case aller Operationen im gesamten Durchlauf des Algorithmus analysiert. Dies kann zu einer besseren oberen Schranke führen.

Potential-Methode 𝑎 𝑜𝑝 = 𝑡 𝑜𝑝 + 𝜙 𝑛𝑜𝑤 − 𝜙 𝑏𝑒𝑓𝑜𝑟𝑒 𝑎 𝑜𝑝 = 𝑡 𝑜𝑝 + 𝜙 𝑛𝑜𝑤 − 𝜙 𝑏𝑒𝑓𝑜𝑟𝑒 𝑎 sind die amortisierten Kosten für die Operation 𝑜𝑝 𝑡 sind die tatsächlichen Kosten für die Operation 𝑜𝑝 𝜙 ist das Potential eines Zustands (ähnlich zum Kontostand)

Amortisierte Analyse: Hilfsatz Wenn: 𝑎,𝑏>0 , 𝑎+𝑏≤𝑐 Dann: log 2 𝑎 + log 2 𝑏 ≤2 log 2 𝑐−2 Denn: geometrisches Mittel ≤ arithmetisches Mittel b. 𝑎𝑏 ≤ 𝑎+𝑏 2 log 2 𝑎 + log 2 𝑏 = log 2 𝑎∗𝑏 = log 2 𝑎∗𝑏 2 ≤ 𝑏 log 2 𝑎+𝑏 2 2 log 2 𝑎∗𝑏 = log 2 𝑎∗𝑏 2 ≤ 𝑏 log 2 𝑎+𝑏 2 2 ≤ 𝑎 log 2 𝑐 2 4 = log 2 𝑐² − log 2 4 =2 log 2 𝑐 −2

Definition Variablen: x : Schlüssel p : Knoten b : Baum Gewicht von x: 𝑤 𝑥 >0 Größe von p: 𝑠 𝑝 =∑𝑤 𝑥 (Summe der Gewichte aller Schlüssel vom Teilbaum mit Wurzel p) Rang von p: 𝑟 𝑝 = log 2 𝑠 𝑝 (min. Tiefe bei Gewicht 1) 𝑟 𝑥 =𝑟 𝑝 ,p hat Schlüssel x 𝑟 𝑏 =𝑟 𝑝 , p Wurzel von b Potential von b: 𝜙 𝑏 =∑𝑟 𝑝 , p ist innerer Knoten von b (Summe aller Ränge der inneren Knoten)

Jede Splay-Operation hat als amortisierte Laufzeit maximal: Zugriffslemma Jede Splay-Operation hat als amortisierte Laufzeit maximal: 3 𝑟 𝑏 −𝑟 𝑥 +1 Das ist nun zu zeigen. Variablen: x : Schlüssel p : Knoten b : Baum Rang: 𝑟 𝑝 = log 2 𝑠 𝑝 𝑟 𝑥 =𝑟 𝑝 ,p hat Schlüssel x 𝑟 𝑏 =𝑟 𝑝 , p Wurzel von b

Zugriffslemma : Zig / Zag Regeln: 1: 𝑟 ′ 𝑝 =𝑟 𝑞 =𝑟 𝑏 2: 𝑟 ′ 𝑝 ≥𝑟′(𝑞) 3: 𝑟 ′ 𝑝 ≥𝑟(𝑝)

Zugriffslemma : Zig / Zag 𝑎 𝑧𝑖𝑔 =1+ 𝑣 𝑖𝑛𝑛𝑒𝑟 𝐾𝑛𝑜𝑡𝑒𝑛 𝑟′(𝑣) − 𝑣 𝑖𝑛𝑛𝑒𝑟 𝐾𝑛𝑜𝑡𝑒𝑛 𝑟(𝑣) =1+ 𝑟 ′ 𝑝 + 𝑟 ′ 𝑞 −𝑟 𝑝 −𝑟 𝑞 = 1 1+ 𝑟 ′ 𝑞 −𝑟 𝑝 ≤ 2 1+ 𝑟 ′ 𝑝 −𝑟 𝑝 ≤ 3 1+3 𝑟 ′ 𝑝 −𝑟 𝑝 = 1 1+3(𝑟 𝑏 −𝑟 𝑥 ) wegen Aufhebung der nicht bewegten Knoten 𝑎 𝑜𝑝 = 𝑡 𝑜𝑝 + 𝜙 𝑛𝑜𝑤 − 𝜙 𝑏𝑒𝑓𝑜𝑟𝑒 𝑟 𝑝 = log 2 𝑠 𝑝 𝜙 𝑏 =∑𝑟 𝑝 1: 𝑟 ′ 𝑝 =𝑟 𝑞 =𝑟 𝑏 2: 𝑟 ′ 𝑝 ≥ 𝑟 ′ 𝑞 3: 𝑟 ′ 𝑝 ≥𝑟(𝑝)

Zugriffslemma : ZigZag / ZagZig Regeln: 1: 𝑟 ′ 𝑝 =𝑟 𝑟 2: 𝑟 𝑞 ≥𝑟(𝑝) 3: 𝑟 ′ 𝑞 + 𝑟 ′ 𝑟 ≤ 𝐻𝑆 2 𝑟 ′ 𝑝 −2 ,da log 2 𝑠 ′ 𝑞 + log 2 𝑠 ′ 𝑟 ≤2 log 2 𝑠 ′ 𝑝 −2 4: 𝑟 ′ 𝑝 ≥𝑟(𝑝)

Zugriffslemma : ZigZag / ZagZig 𝑎 𝑧𝑖𝑔𝑧𝑎𝑔 =2+ 𝑟 ′ 𝑝 + 𝑟 ′ 𝑞 + 𝑟 ′ 𝑟 −𝑟 𝑝 −𝑟 𝑞 −𝑟(𝑟) = 1 2+ 𝑟 ′ 𝑞 + 𝑟 ′ 𝑟 −𝑟 𝑝 −𝑟(𝑞) ≤ 2 2+ 𝑟 ′ 𝑞 + 𝑟 ′ 𝑟 −𝑟 𝑝 −𝑟(𝑝) ≤ 3 2+2 𝑟 ′ 𝑝 −2 −𝑟 𝑝 −𝑟(𝑝) =2( 𝑟 ′ 𝑝 −𝑟 𝑝 ) ≤ 4 3 𝑟 ′ 𝑝 −𝑟 𝑝 +1 ≤3(𝑟 𝑏 −𝑟 𝑥 )+1 𝑎 𝑜𝑝 = 𝑡 𝑜𝑝 + 𝜙 𝑛𝑜𝑤 − 𝜙 𝑏𝑒𝑓𝑜𝑟𝑒 𝑟 𝑝 = log 2 𝑠 𝑝 𝜙 𝑏 =∑𝑟 𝑝 1: 𝑟 ′ 𝑝 =𝑟 𝑟 2: 𝑟 𝑞 ≥𝑟(𝑝) 3: 𝑟 ′ 𝑞 + 𝑟 ′ 𝑟 ≤ 𝐻𝑆 2 𝑟 ′ 𝑝 −2 4: 𝑟 ′ 𝑝 ≥𝑟(𝑝)

Zugriffslemma : ZigZig / ZagZag Regeln: 1: 𝑟 ′ 𝑝 =𝑟 𝑟 2: 𝑟 𝑞 ≥𝑟(𝑝) , 𝑟 ′ 𝑝 ≥𝑟′(𝑞) 3: 𝑟 𝑝 + 𝑟 ′ 𝑟 ≤ 𝐻𝑆 2 𝑟 ′ 𝑝 −2

Zugriffslemma : ZigZig / ZagZag 𝑎 𝑧𝑖𝑔𝑧𝑖𝑔 =2+ 𝑟 ′ 𝑝 + 𝑟 ′ 𝑞 + 𝑟 ′ 𝑟 −𝑟 𝑝 −𝑟 𝑞 −𝑟(𝑟) = 1 2+ 𝑟 ′ 𝑞 + 𝑟 ′ 𝑟 −𝑟 𝑝 −𝑟(𝑞) ≤ 2 2+ 𝑟 ′ 𝑝 + 𝑟 ′ 𝑟 −𝑟 𝑝 −𝑟(𝑝) =2+ 𝑟 ′ 𝑝 + 𝑟 ′ 𝑟 −𝑟 𝑝 −𝑟 𝑝 +𝑟 𝑝 −𝑟 𝑝 |+0 ≤ 3 2+ 𝑟 ′ 𝑝 +2𝑟′ 𝑝 −2 −3𝑟(𝑝) =3( 𝑟 ′ 𝑝 −𝑟 𝑝 ) ≤3 𝑟 𝑏 −𝑟 𝑥 +1 𝑎 𝑜𝑝 = 𝑡 𝑜𝑝 + 𝜙 𝑛𝑜𝑤 − 𝜙 𝑏𝑒𝑓𝑜𝑟𝑒 𝑟 𝑝 = log 2 𝑠 𝑝 𝜙 𝑏 =∑𝑟 𝑝 1: 𝑟 ′ 𝑝 =𝑟 𝑟 2: 𝑟 𝑞 ≥𝑟(𝑝) , 𝑟 ′ 𝑝 ≥ 𝑟 ′ 𝑞 3: 𝑟 𝑝 + 𝑟 ′ 𝑟 ≤ 𝐻𝑆 2 𝑟 ′ 𝑝 −2

Zugriffslemma : Splay 𝑎 𝑠𝑝𝑙𝑎𝑦 ≤ 3 𝑟 1 𝑝 − 𝑟 0 𝑝 + 3 𝑟 2 𝑝 − 𝑟 1 𝑝 + 3 𝑟 3 𝑝 − 𝑟 2 𝑝 + ⋮ 3 𝑟 𝑘 𝑝 − 𝑟 𝑘−1 𝑝 +1 =3 𝑟 𝑘 𝑝 − 𝑟 0 𝑝 +1 =3 𝑟 𝑏 −𝑟 𝑥 +1 Splay ist eine Folge von vorgestellten Operationen. Rang von 𝑝 vor Splay ist Rang des gesuchten Schlüssels 𝑥 vor Splay. Rang von 𝑝 nach Splay ist Rang des Baumes. 𝑟 𝑘 𝑝 = Rang von 𝑝 nach 𝑘-ter Operation

Satz 1 : Splay Baum Für einen anfangs leeren Baum benötigt das Ausführen von m Wörterbuchoperationen mit höchsten N Einfügeoperationen maximal O(m log N). Wörterbuchoperationen brauchen eine konstante Anzahl von Splay-Operationen + eine konstante Anzahl Einzeloperationen. Für diesen Beweis setzen wir alle Gewichte auf 1 .

Beweis 𝑎 𝑠𝑝𝑙𝑎𝑦 ≤3 𝑟 𝑏 −𝑟 𝑥 +1 ≤3𝑟 𝑏 +1 =3 log 2 𝑠 𝑏 +1 =3 log 2 ∑ 𝑤 𝑥 +1 ≤3 log 2 𝑁 +1 ⇒ 𝑎 𝑠𝑝𝑙𝑎𝑦 ∈𝑂( log 𝑁 ) ⇒𝑚 𝑂𝑝𝑒𝑟𝑎𝑡𝑖𝑜𝑛𝑒𝑛∈𝑂(𝑚 log 𝑁 ) Zugriffslemma 𝑟 𝑥 ≥0 Def. von 𝑟 Def. von 𝑠 Gesamtgewicht ≤𝑁 N = Anzahl der Einfügeoperationen m = Anzahl von Operationen 𝑟 𝑝 = log 2 𝑠 𝑝 Größe : 𝑠 𝑝 =∑𝑤 𝑥

Satz 2 : Binärer Baum mit Splay Für einen binären Suchbaum mit N Knoten, haben m Suchoperationen (über Splay) einen Aufwand von maximal O((N + m) log (N) + m). Eine Suchoperation besteht aus einer Splay-Operation und Rückgabe des neuen Wurzelknotens. Für diesen Beweis setzen wir alle Gewichte auf 1. Wir suchen die tatsächlichen Kosten über: 𝑡 𝑜𝑝 = 𝑎 𝑜𝑝 + 𝜙 𝑏𝑒𝑓𝑜𝑟𝑒 − 𝜙 𝑛𝑜𝑤

Potentialdifferenz 𝜙 𝑏 − 𝜙 𝑛 = 𝑝∈ 𝑃 𝑏 𝑟 𝑝 − 𝑝∈ 𝑃 𝑛 𝑟′ 𝑝 = 𝑎𝑙𝑙𝑒 𝑝 𝑟 𝑝 − 𝑎𝑙𝑙𝑒 𝑝 𝑟′ 𝑝 = 𝑎𝑙𝑙𝑒 𝑝 𝑟 𝑝 − 𝑟 ′ 𝑝 = 𝑎𝑙𝑙𝑒 𝑝 ( log 2 (𝑠 𝑝 )− log 2 𝑠 ′ 𝑝 ) ≤ 𝑎𝑙𝑙𝑒 𝑝 ( log 2 𝑊 − log 2 𝑤( 𝑥 𝑝 )) = 𝑎𝑙𝑙𝑒 𝑝 log 2 𝑊 =𝑁 log 2 𝑁 𝑃 𝑏 =𝑖𝑛𝑛𝑒𝑟𝑒 𝐾𝑛𝑜𝑡𝑒𝑛 𝑣𝑜𝑛 𝑏 𝑏𝑒𝑓𝑜𝑟𝑒 𝑃 𝑛 =𝑖𝑛𝑛𝑒𝑟𝑒 𝐾𝑛𝑜𝑡𝑒𝑛 𝑣𝑜𝑛 𝑏 𝑛𝑜𝑤 𝜙 𝑏 = 𝜙 𝑏𝑒𝑓𝑜𝑟𝑒 , 𝜙 𝑛 = 𝜙 𝑛𝑜𝑤 Erweitere um Blätter (Rang 0, Gewicht 1), somit alle p‘s in beiden Summen Benutze Definitionen: 𝑟 𝑝 = log 2 𝑠 𝑝 𝑠 𝑝 =∑𝑤 𝑥 (𝑥 im Teilbaum von 𝑝) 𝑊= Summe aller Gewichte: 𝑤(𝑥) (Anzahl von Knoten = 𝑁) 𝑊≥𝑠 𝑝 , ∀𝑝∈𝑏 𝑤 𝑥 𝑝 =1, 𝐺𝑒𝑤𝑖𝑐ℎ𝑡 𝑧𝑢𝑚 𝑆𝑐ℎ𝑙ü𝑠𝑠𝑒𝑙 𝑣𝑜𝑛 𝑝 log 𝑖 1 =0

Abschätzung von Suchfolgen 𝑇= 𝑖=1 𝑚 𝑡 𝑖 = 𝑖=1 𝑚 (𝑎 𝑖 + 𝜙 𝑖−1 − 𝜙 𝑖 ) = 𝑖=1 𝑚 (𝑎 𝑖 )+ 𝜙 0 − 𝜙 𝑚 ≤ 𝑍𝐿 𝑖=1 𝑚 (3 𝑟 𝑏 −𝑟 𝑥 +1)+ 𝜙 0 − 𝜙 𝑚 ≤ 𝑖=1 𝑚 (3𝑟(𝑏)+1)+ 𝜙 0 − 𝜙 𝑚 ≤𝑚 3log 2 𝑁 +1 +𝑁 log 2 𝑁 = 3𝑚+𝑁 log 2 𝑁 +𝑚 ∈𝑂( 𝑚+𝑁 log 2 𝑁+𝑚 ) Def. von amortisierten Kosten. Treppensumme Zugriffslemma 𝑟 𝑥 ≥0, somit Wegfall Definition Rang und Potentialdifferenz