Splay Trees

Splay Trees
Von Projdakov Benjamin
Inhalt
1. Binäre Suchbäume
2. Splay Trees
a. Self adjustment
b. Anwendungsbeispiel
c. Rotationen
I. Zig / Zag
II. ZigZig/ZagZag
III. ZigZag/ZagZig
d. Operationen
I. Splay/Suche
II. Einfügen
III. Löschen
3. Amortisierte Analyse
a. Einführung/PotentialMethode
b. Hilfssatz
c. Definitionen
d. Zugrifslemma
I.
II.
III.
IV.
Zig/Zag
ZigZag/ZagZig
ZigZig/ZagZag
Splay
e. Satz 1: Splay-Baum
f. Satz 2: Binärer Baum
mit Splay
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 SelfAdjusting 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
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
• 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.
Laufzeit von 2
SplayOperationen
und umbiegen
von einem
Zeiger
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
a. Wenn: 𝑎, 𝑏 > 0 , 𝑎 + 𝑏 ≤ 𝑐
• Dann: log 2 𝑎 + log 2 𝑏 ≤ 2 log 2 𝑐 − 2
• Denn: geometrisches Mittel ≤ arithmetisches Mittel
b.
𝑎𝑏 ≤
𝑎+𝑏
2
• log 2 𝑎 + log 2 𝑏 = log 2 𝑎 ∗
Definition
Variablen:
• x : Schlüssel
• p : Knoten
• b : Baum
Rang von p:
• 𝑟 𝑝 = log 2 𝑠 𝑝 (min. Tiefe
bei Gewicht 1)
• 𝑟 𝑥 = 𝑟 𝑝 ,p hat Schlüssel
x
•
𝑟
𝑏
=
𝑟
𝑝
,
p
Wurzel
von
b
• Gewicht von x: 𝑤 𝑥 > 0
• Größe von p: 𝑠 𝑝 =
Potential von b:
∑𝑤 𝑥
(Summe der Gewichte aller • 𝜙 𝑏 = ∑𝑟 𝑝 , p ist innerer
Knoten von b
Schlüssel vom Teilbaum mit
Wurzel p)
(Summe aller Ränge der
inneren Knoten)
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 𝑟 𝑏 − 𝑟 𝑥 )
𝑎𝑜𝑝 = 𝑡𝑜𝑝 + 𝜙𝑛𝑜𝑤 − 𝜙𝑏𝑒𝑓𝑜𝑟𝑒
𝑟 𝑝 = log 2 𝑠 𝑝
𝜙 𝑏 = ∑𝑟 𝑝
wegen Aufhebung der
nicht bewegten Knoten
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: 𝑟 ′ 𝑞
4: 𝑟 ′ 𝑝
=𝑟 𝑟
≥ 𝑟 𝑝)
+ 𝑟 ′ 𝑟 ≤𝐻𝑆 2𝑟 ′ 𝑝 − 2
≥ 𝑟 𝑝)
Zugriffslemma : ZigZig / ZagZag
Regeln:
3: 𝑟 𝑝 + 𝑟 ′ 𝑟 ≤𝐻𝑆 2𝑟 ′ 𝑝 − 2
1: 𝑟 ′ 𝑝 = 𝑟 𝑟
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 𝑟
𝑘
=3 𝑟
⋮
𝑝 −𝑟
𝑘
𝑘−1
𝑝
+1
0
𝑝
+1
𝑝 −𝑟
=𝑘 3 𝑟 𝑏 − 𝑟 𝑥
𝑟
Splay ist eine Folge von vorgestellten
Operationen.
+1
𝑝 = Rang von 𝑝 nach 𝑘-ter Operation
Rang von 𝑝 vor Splay ist Rang des
gesuchten Schlüssels 𝑥 vor Splay.
Rang von 𝑝 nach Splay ist Rang des
Baumes.
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 𝑟 𝑏 − 𝑟 𝑥
≤ 3𝑟 𝑏 + 1
= 3 log 2 𝑠 𝑏 + 1
= 3 log 2 ∑ 𝑤 𝑥
+1
≤ 3 log 2 𝑁 + 1
⇒ 𝑎𝑠𝑝𝑙𝑎𝑦 ∈ 𝑂 log 𝑁 )
⇒ 𝑚 𝑂𝑝𝑒𝑟𝑎𝑡𝑖𝑜𝑛𝑒𝑛
∈ 𝑂 𝑚 log 𝑁 )
+1
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
𝜙𝑏 − 𝜙𝑛 =
𝑟 𝑝 −
𝑝∈𝑃𝑏
=
𝑟 𝑝 −
𝑎𝑙𝑙𝑒 𝑝
𝑟′ 𝑝
𝑝∈𝑃𝑛
𝑃𝑏 = 𝑖𝑛𝑛𝑒𝑟𝑒 𝐾𝑛𝑜𝑡𝑒𝑛 𝑣𝑜𝑛 𝑏𝑏𝑒𝑓𝑜𝑟𝑒
𝑃𝑛 = 𝑖𝑛𝑛𝑒𝑟𝑒 𝐾𝑛𝑜𝑡𝑒𝑛 𝑣𝑜𝑛 𝑏𝑛𝑜𝑤
𝜙𝑏 = 𝜙𝑏𝑒𝑓𝑜𝑟𝑒 , 𝜙𝑛 = 𝜙𝑛𝑜𝑤
Erweitere um Blätter (Rang 0, Gewicht 1), somit alle p‘s in
beiden Summen
𝑟′ 𝑝
𝑎𝑙𝑙𝑒 𝑝
𝑟 𝑝 − 𝑟′ 𝑝
=
𝑎𝑙𝑙𝑒 𝑝
=
Benutze Definitionen:
log 2 𝑠 𝑝 ) − log 2
𝑠′
𝑝 )
•
•
𝑟 𝑝 = log 2 𝑠 𝑝
𝑠 𝑝 = ∑𝑤 𝑥 (𝑥 im Teilbaum von 𝑝)
𝑎𝑙𝑙𝑒 𝑝
≤
log 2 𝑊 − log 2 𝑤 𝑥𝑝 ))
𝑎𝑙𝑙𝑒 𝑝
=
log 2 𝑊 = 𝑁 log 2 𝑁
𝑎𝑙𝑙𝑒 𝑝
𝑊= Summe aller Gewichte: 𝑤 𝑥) (Anzahl von Knoten = 𝑁)
𝑊 ≥ 𝑠 𝑝 , ∀𝑝 ∈ 𝑏
𝑤 𝑥𝑝 = 1, 𝐺𝑒𝑤𝑖𝑐ℎ𝑡 𝑧𝑢𝑚 𝑆𝑐ℎ𝑙ü𝑠𝑠𝑒𝑙 𝑣𝑜𝑛 𝑝
log 𝑖 1 = 0
Abschätzung von Suchfolgen
𝑚
𝑇=
𝑡𝑖 =
𝑖=1
𝑚
=
𝑚
𝑎𝑖 +𝜙𝑖−1 − 𝜙𝑖 )
Def. von amortisierten
Kosten.
𝑖=1
Treppensumme
𝑎𝑖 ) + 𝜙0 − 𝜙𝑚
𝑖=1
𝑚
≤𝑍𝐿
3 𝑟 𝑏 −𝑟 𝑥
+ 1) + 𝜙0 − 𝜙𝑚
𝑖=1
𝑚
≤
3𝑟 𝑏) + 1) + 𝜙0 − 𝜙𝑚
𝑖=1
≤ 𝑚 3log 2 𝑁 + 1 + 𝑁 log 2 𝑁
= 3𝑚 + 𝑁 log 2 𝑁 + 𝑚
∈ 𝑂 𝑚 + 𝑁 log 2 𝑁 + 𝑚)
Zugriffslemma
𝑟 𝑥 ≥ 0, somit Wegfall
Definition Rang und
Potentialdifferenz