Rot-Schwarz-Baum

5.7 RotRot-SchwarzSchwarz-Bäume
(2,4)-Bäume
sind ausgeglichen: gleiche Höhe für alle Blätter
Standardoperationen auf Mengen in O(h), d.h. O(log n)
unterschiedliche Knoten (1, 2 oder 3 Schlüssel)
Frage:
lassen
sich die beiden ersten Eigenschaften von (2,4)Bäume auch mit binären Knoten erreichen?
Warum
eigentlich??
(2,4)-Bäume sind Hauptspeicherdatenstruktur,
nur B-Bäume mit t >> 2 für Externspeicher.
Implementierungsvarianten (Hauptspeicher):
gleiche Knoten mit unterschiedlich vielen Werten
=> speicherineffizient
verschiedene Knoten: zusätzliche
Abfragen (welcher Knotentyp?)
hs / fub – alp3-21-RBbaum-1 1
(2,4)(2,4)-Bäume als Binärbäume implementieren?
implementieren?
Antwort:
sicher "nicht ganz": müssten sonst immer 2h+1-1
Knoten enthalten (ausgeglichen!) .
aber "im Wesentlichen":
R. Bayer: Symmetric Binary B-Trees: Data Structure
and Maintenance Algorithms. Acta Informatica, Vol
1, 290-306,
1972 ,
heute Rot-Schwarz-Bäume genannt.
Idee:
Abbilden von (2,4) – Knoten auf binäre.
hs / fub – alp3-21-RBbaum-1 2
1
2, 3 und 44-Knoten als binäre Teilbäume
7
7
5
3 5
3
3
5
6
hs / fub – alp3-21-RBbaum-1 3
5
358
3
8
6
Per Konstruktion: Jeder (2,4)-Baum lässt sich in einen
binären Suchbaum umwandeln.
2
Beispiel
5 12
15
10
3 4
5
2
4
6 79
13 14
11
12
3
17
Fragen:
2
- Höhe von RB-Baum
im Vergleich zu (2,4)?
- Operationen
- Was ist überhaupt
ein RB-Baum??
4
10
11
7
3
6
9
6
15
13
17
14
6
hs / fub – alp3-21-RBbaum-1 5
Eigenschaften
3
2
1
5
3
2
2
4
1
1
12
3
1
3
6
1. Wurzel ist schwarz.
10
1
7
1
0. Knoten sind rot
oder schwarz.
9
6
11
2
1
15
13
1
1
14
6
2. Externe Knoten
sind schwarz
17
3. Die Kinder von
roten Knoten sind
schwarz (Rotbedingung
4. Jeder Pfad von einem Knoten x zu einem externen
Knoten besitzt die gleiche Anzahl schwarzer Knoten.
4a) Diese Anzahl (x nicht gezählt) heißt
schwarze Höhe bh(x) eines Knotens.
hs / fub – alp3-21-RBbaum-1 6
3
RotRot-SchwarzSchwarz-Bäume
Ein
binärer Suchbaum, der die Eigenschaften
0 bis 4 erfüllt, heißt Rot-Schwarz-Baum
(Red-Black-, RB-Tree)
Jeder
(2,4)-Baum kann in einen Rot-Schwarz-Baum
umgewandelt werden.
Gilt nach Konstruktion: beibehalten von 1-Knoten,
ersetzen von 2- und 3-Knoten so, dass schwarzer
Knoten mit einem oder zwei roten Kindern entsteht.
hs / fub – alp3-21-RBbaum-1 7
RotRot-SchwarzSchwarz-Bäume
Umgekehrt:
zu jedem Rot-Schwarz-Baum gibt es
einen (2,4)-Baum.
Konstruktiv: Vereinige jeden roten Knoten x mit seinem
Elternknoten e (der ist schwarz!) zu einem 2-Knoten, wenn x
schwarzen Nachbarn hat, sonst zu einem gemeinsamen 3Knoten, der x, e und den roten Nachbarn y von x enthält.
Dabei folgt aus der Eindeutigkeit der Reihenfolge (x, e) bzw.
(e, x ) und (x, e, y) bzw. (y,e,x) gemäß Sortierfolge die
Eindeutigkeit des (2,4)-Baumes.
Für
die externe Höhe von Rot-Schwarzbäumen mit n
internen Knoten gilt h <= 2* log (n+1).
hs / fub – alp3-21-RBbaum-1 8
4
Operationen auf RotRot-SchwarzSchwarz-Bäumen
search()
: wie in binären Suchbäumen
insert(Key
k)
search(k)
findet externen Knoten e als Einfügepunkt
(oder DUPL_KEY)
ersetze e durch roten Knoten k mit schwarzen Kindern
e' und e'' (externe Knoten)
erhalte RB-Invarianten
7
5
9
6
entspricht
in (2,4)-Baum:
5 7 9
hs / fub – alp3-21-RBbaum-1 9
Einfügen in RotRot-SchwarzSchwarz-Baum: die kritischen Fälle
Kritische
Fälle im (2,4)-Baum:
4-Knoten k, k enthält schon 3 Schlüssel
3 6 8
8
6
3
2
9
5 7
Einfügen an diesen
Stellen ist kritisch
6
entspricht
2
5
7
9
führt zur Verletzung der Rot-Bedingung
hs / fub – alp3-21-RBbaum-1 10
5
Umfärbung der Knoten: Spalten im (2,4)(2,4)-Baum
... 6 ...
3 5
3 6 8
6
5
6
5
8
3
8
3
8
Beachte:
keine Änderung
der schwarzen
Tiefe!
5
hs / fub – alp3-21-RBbaum-1 11
Funktionale Implementierung
data RBTree a = Empty
| Node Color (RBTree a) a (RBTree a)
data Color = R | B
deriving (Show)
insert ::
Ord a => RBTree a -> a -> RBTree a
Situation entspricht dem folgenden Muster:
recolour B (Node R (Node B lll vll llr)
vl (Node R lrl vlr lrr))
v
(Node R rl vr rr)
= Node R (Node B (Node B lll vll llr)
vl (Node R lrl vlr lrr))
v (Node B rl vr rr)
6
Funktionale Implementierung
Weitere
Fälle analog zu (2,4)-Knotenspaltung.
recolour B (Node R (Node R lll vll llr)
vl lr )
v (Node R rl vr rr)
= Node R (Node B (Node R lll vll llr)
vl lr)
v (Node B rl vr rr)
6 v
vl
vll
3
lr
1
rl
6
8 vr
rr
llr
lll
3
8
1
hs / fub – alp3-21-RBbaum-1 13
Funktionale Implementierung
Die
restlichen Fälle:
recolour
B (Node R ll vl
v (Node R (Node
vr rr)
= Node R (Node B ll vl
v (Node B (Node
vr rr)
recolour
= Node
lr)
R rll vrl rlr)
lr)
R rll vrl rlr)
B (Node R ll vl lr)
v (Node R rl
vr (Node R rrl vrr rrr))
R (Node B ll vl lr)
v (Node B rl
vr (Node R rrl vrr rrr))
In allen 4 Fällen: rote Nachbarn (d.h. 4-Knoten in (2,4)-B).
hs / fub – alp3-21-RBbaum-1 14
7
Transformieren in RotRot-SchwarzSchwarz-Baum
Knoten
mit 2 Werten in (2,4)-Baum führen ebenfalls
zur Verletzung der Rot-Eigenschaft!
3 6
1
6 v
vl
vll
... 8 ...
insert()
8 vr
3
lr
1
rr
rl
llr
lll
Kein Problem im (2,4)-Baum, aber....
hs / fub – alp3-21-RBbaum-1 15
Transformieren
1
3 6
1
vl
lll
... 8 ...
... 8 ...
insert()
vll
3 6
1
6 v
3
lr
llr
rl
8 vr
r
rr
vl 3
vll
lll
llr
v
6
1
8 vr
lr
rl
r
rr
hs / fub – alp3-21-RBbaum-1 16
8
Implementierung Transformieren
balance B (Node R (Node R lll vll llr)
vl lr)
v r
= Node B (Node R lll vll llr)
vl (Node R lr v r)
Wenn Musterabgleich zur Färbung vorher durchgeführt
wird, ist hier ein Muster "Schwarzer Zwilling" entbehrlich:
balance B (Node R (Node R lll vll llr)
vl lr)
v (Node B rl vr rr)
= ...
hs / fub – alp3-21-RBbaum-1 17
Transformation: weiterer Fall
vl
ll
vlr 5
6 v
r
3
5
lrl
vlr
vl
ll
3
lrl
6 v
lrr
r
lrr
balance B (Node R ll vl (Node R lrl vlr lrr))
v r
= Node B
(Node R ll vl lrl)
vlr (Node R lrr v r)
hs / fub – alp3-21-RBbaum-1 18
9
|= B4--<
Beispiel
,- B6--<
`- B2--<
,- R8--<
`- B5--<
,- B3--<
`- B1--<
,- B9--<
`- B7--<
,- [-]
`- [-]
,- [-]
`- [-]
,- [-]
`- [-]
,- [
,- R10--<
`- [
`- [-]
,- [-]
`- [-]
Einfügen in von 1 .. 10
in dieser Reihenfolge.
Transformation des BeispielBeispiel-Baums in (2,4)(2,4)-Baum
4
2
1
6 8
3
5
7
9 10
Ergibt sich derselbe (2,4)-Baum bei Einfügen
in gleicher Reihenfolge: insert x : x<- [1..10] ?
hs / fub – alp3-21-RBbaum-1 20
10
Implementierung
Vereinfachte
vl
Implementierung:
vlr 5
6 v
8
vl
vlr
ll
3
ll
5
lrl
6 v
3
8
lrr
lrl
r
lrr
Immer Transformieren, wenn Rotbedingung verletzt,
kein Umfärben.
hs / fub – alp3-21-RBbaum-1 21
Laufzeit
Eine
3
6
Transformation ausreichend!
3
r
5
6
5
Ggf.
r
Wenn Rotbedingung
vor Einfügen erfüllt,
dann auch nach
Transformation.
bis zur Wurzel rückschreitendes Umfärben.
3
6
5
8
3
6
8
5
hs / fub – alp3-21-RBbaum-1 22
11
Laufzeit
Einfügen in einen Rot-Schwarz-Baum benötigt
- O(log n) Schritte zur Suche der Einfügeposition
wie binärer Suchbaum
- maximal eine Transformation O(1)
- maximal h <= 2* log (n+1) Umfärbungen
=> insert() hat Laufzeit O(log n)
Praktisch sehr gute Ergebnisse:
Suche benötigt ca. 1,002 log2 n Vergleiche.
hs / fub – alp3-21-RBbaum-1 23
Löschen in RotRot-SchwarzSchwarz-Bäumen
Löschen
eines von n Werten :
Maximal 2 Umstrukturierungen
O(log n) Umfärbungen
=> Suche, Einfügen, Ändern in Rot-Schwarz-Bäumen in
O(log n) Laufzeit.
... und gute Konstanten.
hs / fub – alp3-21-RBbaum-1 24
12