Vorlesung 2.5.3

2.5 Bäume 

2.5.1 Binäre Suchbäume 

2.5.2 Optimale Suchbäume 

2.5.3 Balancierte Bäume 

2.5.4 Skip-Listen 

2.5.5 Union-Find-Strukturen 

1 

Datenstrukturen und Algorithmen 

Prof. Dr. Leif Kobbelt, Thomas Ströder, Fabian Emmes, Sven Middelberg, Michael Kremer

Balancierte Bäume 

• Nachteil bei normalen Suchbäumen: 

Worst-case Aufwand ist O(n) 

• Tritt bei degenerierten Bäumen auf 

• Kann durch Balancierung verhindert 

werden 

• Problem: Stelle Balance in O(log n) 

wieder her 

2 




• Gewichtsbalance: Für jeden Knoten 

unterscheidet sich die Anzahl der 

Knoten im linken und rechten Teilbaum 

um maximal eins. 

• Höhenbalance: Für jeden Knoten 

unterscheidet sich die Höhe des linken 

und rechten Teilbaums um maximal 

eins. 

3 




• Zur Erinnerung: 

– Maximale Zahl von Knoten in einem Baum 

der Höhe h ist O(2 h ) 

– Minimale Zahl von Knoten in einem Baum 

der Höhe h ist ΩΩ(h) 

– Minimale Zahl von Knoten in einem 

balancierten Baum der Höhe h ist ΩΩ(2 h/2 ) 

4 




• Zur Erinnerung: 

– Minimale Höhe eines Baums mit n Knoten 

ist ΩΩ(log n) 

– Maximale Höhe eines Baums mit n Knoten 

ist O(n) 

– Maximale Höhe eines balancierten Baums 

mit n Knoten ist O(2×log n)=O(log n) 

5 



2.5 Bäume 




2.5.3.1 AVL-Bäume 

2.5.3.2 Rot-Schwarz-Bäume 

2.5.3.3 B-Bäume 



6 



AVL-Bäume 

• Werden wie normale binäre 

Suchbäume behandelt 

• Jeder Knoten speichert sein 

Ungleichgewicht (+1,0,−1) 

• Nach Insert() oder Delete() 

Wiederherstellung der Balance durch 

Rotation 

7 



AVL-Bäume 

h 

h 

h 

8 



AVL-Bäume 

h 

h 

h+1 

9 



AVL-Bäume 

Einfache 

Rotation 

h 

h 

h+1 

10 



AVL-Bäume 

Einfache 

Rotation 

h 

h 

h+1 

11 



AVL-Bäume 

Einfache 

Rotation 

h h h+1 

12 



AVL-Bäume 

h 

h 

h 

13 



AVL-Bäume 

h 

h+1 

h 

14 



AVL-Bäume 

h 

h 

h 

h 

15 



AVL-Bäume 

Doppelte 

Rotation 

h 

h 

h 

h 

16 



AVL-Bäume 

Doppelte 

Rotation 

h 

h 

h 

h 

17 



AVL-Bäume 

Doppelte 

Rotation 

h 

h 

h 

h 

18 



AVL-Bäume 

Doppelte 

Rotation 

h 

h 

h 

h 

19 



AVL-Bäume 

Doppelte 

Rotation 

h 

h 

h 

h 

20 



AVL-Bäume 

Doppelte 

Rotation 

h 

h 

h 

h 

21 



AVL-Bäume 

• Rotationen müssen ggf. nach oben 

propagiert werden 

• Im schlechtesten Fall O(log n) 

Rotationen bei Delete() 

• Nur praktikabel, wenn gesamte 

Datenstruktur im Hauptspeicher 

22 



2.5 Bäume 









23 



Rot-Schwarz-Bäume 

• Binärer Suchbaum, jeder Knoten hat 

zwei Söhne oder keinen 

• Rote und schwarze Knoten 

• Re-Balancing durch Rotationen und 

Umfärben 

24 




• Konsistenzregeln 

1. Jeder Knoten ist rot oder schwarz 

2. Die Wurzel ist schwarz 

3. Die Blätter sind schwarz 

4. Die Söhne eines roten Knotens sind 

schwarz. 

5. Alle Pfade von einem Knoten zu den 

nachfolgenden Blättern haben gleich 

viele schwarze Knoten 

25 




7 

2 

8 

1 5 

9 

4 6 

Blätter werden im Folgenden nicht mehr dargestellt. 

26 




• Eigenschaften 

– Maximales Pfadlängenverhältnis 2:1 

– Pfadlängen Θ(log n) 

27 




• Lemma: 

Die Höhe eines Rot-Schwarz-Baums 

mit n inneren Knoten ist höchstens 

2×ld(n+1) 

28 




• Die Zahl der schwarzen Knoten auf 

einem (dann jeden) Pfad von einem 

Knoten x (ausschließlich) bis zu einem 

Blatt (einschließlich) sei bh(x) 

29 




bh( 2 ) = 2 

7 

1 bh( 5 ) = 1 

4 6 

8 

9 

30 




• Der Baum unter einem Knoten x enthält 

mindestens 2 bh(x) −1 innere Knoten 

I.A. x ist ein Blatt → 2 bh(x) −1=2 0 −1=0 

I.V. Die Beh. gelte für alle y mit 

height(y) < height(x) 

I.S. x sei ein innerer Knoten mit Söhnen x1,x2 

bh(x1), bh(x2) ≥ bh(x)−1 

der Baum unter x enthält mindestens 

(2 bh(x)−1 −1)+(2 bh(x)−1 −1)+1 = 2 bh(x) −1 innere 

Knoten 

31 




• Es sei h = height(root) die Höhe des Baumes 

– Mindestens die Hälfte der Knoten auf 

einem Pfad von der Wurzel zu einem Blatt 

müssen schwarz sein. 

bh(root) ≥ h ∕ 2 

n ≥ 2 h/2 −1 

h ≤ 2×ld(n+1) 

32 




• Insert(), Delete() 

– Wie bei normalen binären Suchbäumen 

mit anschließender Wiederherstellung der 

Konsistenzbedingungen 

– Insert() → drei verschiedene Fälle 

– Delete() → vier verschiedene Fälle 

– Pseudo-Code: siehe Cormen et al. 

33 



Rot-Schwarz-Bäume: Insert() 

• Jeder eingefügte Knoten wird zunächst 

rot gefärbt 

• Bei Wiederherstellung durch Umfärben 

oder Rotation kann genau eine weitere 

Konsistenzverletzung auftreten. 

• Propagiere Modifikation nach oben. 

34 




• Mögliche Konsistenzverletzungen 

– Neuer Knoten ist Wurzel 

– Neuer Knoten ist Nachfolger eines roten Knotens 

• Fallunterscheidung nach der Farbe des Onkels 

• Konsistenzregeln 

1. Jeder Knoten ist rot oder schwarz. 

2. Die Wurzel ist schwarz. 

3. Die Blätter sind schwarz. 

4. Die Söhne eines roten Knotens sind schwarz. 

5. Alle Pfade von einem Knoten zu den 

nachfolgenden Blättern haben gleich viele 

schwarze Knoten. 

35 




Großvater 

Vater 

X 

Onkel 

Bruder 

Neffen 

36 




7 

2 

8 

1 5 

9 

4 6 

37 



Rot-Schwarz-Bäume Insert – Scheme 

up 

Onkel 

0 Vorgänger schwarz 

à nichts zu tun 

Rot 

Schwarz 

1 

umfärben 

Innen 

Außen 

2 Rotation 3 Rotation 

& Umfärben 

38 




Einfügen zunächst wie bei normalen binären Suchbäumen 

7 

2 

8 

1 5 

9 

4 6 

3 

39 




Fall 1: Der Onkel ist rot → umfärben und weiter mit 

Großvater 

7 

2 

8 

1 5 

9 

4 6 

3 

40 





Großvater 

7 

2 

8 

1 5 

9 

4 6 

3 

41 





Großvater 

7 

2 

8 

1 5 

9 

4 6 

3 

42 





Großvater 

7 

7 

2 

8 

2 

8 

1 5 

9 

1 5 

9 

4 6 

4 6 

3 

3 

43 




7 

2 

8 

1 5 

9 

4 6 

3 

44 




Fall 2: Der Onkel ist schwarz und ist ein innerer Sohn 

→ Rotation nach außen und weiter mit äußeren Sohn (Fall 3) 

7 

2 

8 

1 5 

9 

4 6 

3 

45 






7 

2 

8 

1 5 

9 

4 6 

3 

46 






7 

1 

2 

5 

4 6 

8 

9 

3 

47 






7 

1 

2 

4 

5 

6 

8 

9 

3 

48 






7 

5 

8 

2 

6 

9 

1 

4 

3 

49 






7 

5 

8 

2 

6 

9 

1 

4 

3 

50 






7 

2 

1 5 

4 6 

3 

8 

9 

1 

2 

3 

4 

5 

6 

7 

8 

9 

51 




Fall 3: Der Onkel ist schwarz und ist ein äußerer Sohn 

→ Rotation nach innen und umfärben 

7 

5 

8 

2 

6 

9 

1 

4 

3 

52 






7 

5 

8 

2 

6 

9 

1 

4 

3 

53 






5 

7 

2 

6 

8 

1 

4 

9 

3 

54 






5 

7 

2 

6 

8 

1 

4 

9 

3 

55 






5 

2 

7 

1 4 6 

8 

3 

9 

56 






5 

2 

7 

1 4 6 

8 

3 

9 

57 






1 

2 

3 

4 

5 

6 

7 

8 

9 

5 

2 

1 4 6 

3 

7 

8 

9 

58 



Fallunterscheidung Insert() 

1. Onkel ist rot 

– Umfärben, Rekursion nach oben 

2. Sohn < Vater > Großvater oder 

Sohn > Vater < Großvater 

– Rotation, weiter mit Fall 3 

3. Sohn < Vater < Großvater oder 

Sohn > Vater > Großvater 

– Rotation, Umfärben, Fertig 

59 



Aufwand Insert() 

• Suchen der Einfügestelle O(log n) 

• Einfügen O(1) 

• Konsistenzwiederherstellung 

– Umfärbe-Schritte O(log n) 

(Schritt vom Enkel zum Großvater) 

– Rotationen O(1) (maximal zwei) 

• Insgesamt: O(log n) 

60 



Rot-Schwarz-Bäume: Delete() 

• Wie bei normalen binären Suchbäumen 

wird der Knoten entweder direkt 

gelöscht oder sein Successor wird 

gelöscht und der Inhalt wird kopiert. 


– Wenn der Knoten rot war, ist nichts zu tun 

– Wenn der Knoten schwarz war, gibt es 

4 Fälle 

61 




• Falls der tatsächlich entfernte Knoten 

schwarz ist, fehlt auf allen Pfaden 

innerhalb des entsprechenden Teil- 

Baums eine schwarze Marke 

• Weise diese schwarze Marke dem 

(einen) Nachfolger des gelöschten 

Knotens zu. Dadurch wird dieser 

schwarz-rot oder doppel-schwarz. 

62 



• Erinnerung 


Del( A ) 

D 

α 

B 

C 

γ 

β 

63 





Del( A ) 

D 

α 

Succ( ) = A 

B 

C 

γ 

β 

64 





Del( A ) 

D 

α 

B 

C 

γ 

β 

65 





Del( A ) 

α 

B 

D 

C 

γ 

β 

66 





Del( A ) 

B 

D 

α 

C 

γ 

β 

67 





Del( A ) 

B 

D 

α 

C 

γ 

β 

68 





α 

B 

D 

C 

γ 

β 

69 





B 

D 

α 

C 

β 

γ 

70 





B 

D 

α 

C 

β 

γ 

71 





B 

D 

α 

C 

oder 

C 

C 

β 

γ 

72 




• Umfärben und Rotationen 

– Erhalte die Zahl schwarzer Marken der 

Sub-Bäume 

• Abbruchbedingungen 

– Ein schwarz-roter Knoten wird schwarz 

gefärbt 

– Ein Wurzelknoten wird erreicht 

(doppel-schwarz kann einfach wegfallen, 

da die Wurzel auf allen Pfaden liegt) 

73 



Rot-Schwarz-Bäume – Delete - Scheme 

Up 

Bruder 

0 

: rot-‐schwarz à schwarz 

(nichts weiter zu tun) 

rot 

1 

Rot. und umfärben 

schwarz 

Neffen 

beide innen rot, 

schwarz 

außen rot 

außen schwarz 

2 3 4 

Umfärben Rot. und umfärben Rot. und umfärben 

74 




Fall 1: Der Bruder ist rot → Rotation nach links 

und umfärben 

B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

75 





und umfärben 

B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

76 





und umfärben 

B 

D 

A 

C 

E 

α β γ δ 

ε 

ζ 

77 





und umfärben 

B 

D 

A 

C 

E 

α β γ δ 

ε 

ζ 

78 





und umfärben 

D 

B 

E 

A 

C 

ε 

ζ 

α 

β 

γ 

δ 

79 





und umfärben 

D 

B 

E 

A 

C 

ε 

ζ 

α 

β 

γ 

δ 

80 





und umfärben 

α 

A 

β 

B 

γ 

C 

δ 

D 

E 

A 

ε ζ α β 

B 

γ 

C 

D 

δ 

ε 

E 

ζ 

weiter mit Fall 2,3,4: der Bruder ist nicht rot 

81 




Fall 2: Der Bruder ist schwarz und dessen Söhne sind beide schwarz 

→ umfärben und Marke nach oben weitergeben 

(Ende, falls “B” rot war, sonst weiter mit “B”) 

B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

82 







B 

Nun fehlt in diesem 

Teilbaum auch ein 

schwarzer Knoten! 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

83 







B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

84 







α 

A 

β 

B 

γ 

C 

δ 

D 

ε 

E 

ζ 

α 

A 

β 

B 

γ 

C 

δ 

D 

ε 

E 

ζ 

85 




Fall 3: Bruder ist schwarz, dessen innerer Sohn ist rot 

und dessen äußerer Sohn ist schwarz 

→ Rotation nach außen und umfärben 

B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

86 







B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

87 







B 

A 

C 

D 

α 

β 

γ 

δ 

E 

ε 

ζ 

88 







B 

A 

C 

D 

α 

β 

γ 

δ 

E 

ε 

ζ 

89 







B 

A 

C 

D 

α β γ 

E 

δ 

ε 

ζ 

90 







B 

A 

C 

D 

α β γ 

E 

δ 

ε 

ζ 

91 







α 

A 

β 

B 

D 

C E 

γ δ ε ζ 

… weiter mit Fall 4 

A 

B 

α β γ 

C 

δ 

D 

ε 

E 

ζ 

92 




Fall 4: Der Bruder ist schwarz, dessen äußerer Sohn ist rot 

→ umfärben und Rotation nach innen 

B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

93 






B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

94 






B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

95 






B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

96 






B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

97 






B 

A 

D 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

98 






B 

D 

A 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

99 






B 

D 

A 

C 

E 

α 

β 

γ 

δ 

ε 

ζ 

100 






D 

B 

E 

A 

C 

ε 

ζ 

α 

β 

γ 

δ 

101 






α 

A 

β 

B 

γ 

C 

δ 

D 

ε 

E 

ζ 

α 

A 

β 

B 

γ 

C 

D 

δ 

ε 

E 

ζ 

102 



Aufwand Delete() 

• Suchen des Löschknotens O(log n) 

• Löschen O(1) 


– Umfärbe-Schritte O(log n) 

– Rotationen O(1) (maximal drei) 

• Insgesamt: O(log n) 

103 



2.5 Bäume 









104 



B-Bäume 

• Alternative Interpretation/Implementierung 

der Rot-Schwarz-Bäume führt auf 2,4-Bäume 

• Diese sind ein Spezialfall des allgemeineren 

Konzepts von B-Bäumen 

• Vorteil: größere Mengen von Knoten werden 

zusammengefasst und passen dadurch besser 

in einen Festplatten-Block 

• Hysterese: Nicht in jedem Schritt muss 

rebalanciert werden. 

105 



Speicherhierarchie 

• Mit zunehmendem Abstand vom 

Prozessor ... 

– ... steigt die Speicherkapzität 

– ... wächst die zugreifbare Blockgröße 

– ... sinkt die Zugriffsgeschwindigkeit 

106 




• Effiziente Algorithmen ... 

– ... führen häufige Berechnungen auf kleinen 

Datenmengen durch (“innere Schleife”) 

– ... minimieren die Zugriffe auf externe 

Speicherebenen 

– ... passen die Größe der Datenstrukturen an 

die jeweiligen Blockgrößen an 

107 




• Bei der Suche in externen Binärbaumstrukturen 

hängt die Zugriffszeit im 

Wesentlichen von der Verteilung der 

Knoten auf Festplatten-Sektoren ab. 

• Fasse Teilbäume in Sektoren zusammen 

108 




109 




110 




111 



Definition : B-Bäume 

• Jeder Knoten x hat die folgenden Felder 

– Die Zahl n[x] der aktuell im Knoten 

gespeicherten Schlüssel (“Füllgrad”) 

– n[x] Schlüssel 

key1[x] ≤ ... ≤ keyn[x][x] 

– n[x]+1 Zeiger auf die Söhne 

c0[x], c1[x], ... , cn[x][x] 

– Der Bool-Wert leaf[x] zeigt an, ob x ein Blatt ist 

112 




• Bedingungen 

– Ist ki ein Schlüssel im Unterbaum mit Wurzel 

ci[x] so ist 

k0 ≤ key1[x] ≤ k1 ≤ key2[x] ≤ ... ≤ keyn[x][x] ≤ kn[x] 

– Alle Blätter haben dieselbe Tiefe h 

113 




• Bedingungen (Fortsetzung) 

– Es gibt eine feste Zahl t ≥ 2, den 

minimalen Grad, mit 

• Jeder Knoten außer der Wurzel enthält 

mindestens t−1 Schlüssel 

• Jeder Knoten enthält höchstens 

2×t−1 Schlüssel 

114 




• Bedingungen (Fortsetzung, alternativ) 

– Es gibt eine feste Zahl t ≥ 2, den 

minimalen Grad, mit 

• Jeder Knoten außer der Wurzel hat 

mindestens t Söhne 

• Jeder Knoten hat höchstens 2×t Söhne 

115 



B-Bäume 

• Für die Höhe h eines B-Baums mit n 

Schlüsseln gilt 

#Knoten 

Tiefe 

t t 

t t t t 

0 

1 

2 

3 

1 

≥2 

≥2t 

≥2t 2 

116 



B-Bäume 

• Halte den Wurzelknoten immer im 

Hauptspeicher (da für jeden Zugriff 

notwendig) 

• Erwartete Zugriffe ≈ logt n 

• Beispiel 

– 10 8 Telefonnummern in Deutschland 

– Blockgröße 512 

– maximal 2 Festplattenzugriffe 

117 



B-Bäume 

• Zusammenhang mit Rot-Schwarz- 

Bäumen 

– Jeder schwarze Knoten absorbiert 

seine roten Söhne 

– Minimaler Füllgrad: t = 2 Söhne 

– Maximaler Füllgrad: 2t = 4 Söhne 

– (2,4)-Bäume 

118 




119 




120 




121 




122 




123 




124 




125 




126 




127 




128 



• Operationen 

– Search() 

– Insert() 

– Delete() 

B-Bäume 

• In den meisten Fällen kommen die 

Operationen ohne Restrukturierung des 

Baums aus 

• Sonst: O(1) verallgemeinerte 

Rotationen 

129 



Zugriff auf externen Speicher 

• DiskRead(x), DiskWrite(x) 

• x ← pointer to some object 

DiskRead(x); 

access/modify the contents of x 

DiskWrite(x) // only if modified 

access but don’t modify the contents of x 

130 



Create() 

• Create() 

x ← AllocateNode() 

leaf[x] ← true 

n[x] ← 0 

DiskWrite(x) 

131 



Search() 

• SEARCH( x, k ) 

i ← 1 

while i ≤ n[x] and k > keyi[x] 

i ← i + 1 

if i ≤ n[x] and k = keyi[x] then 

return (x,i) 

if leaf[x] then 

return NIL 

else 

DiskRead( ci−1[x] ) 

Search( ci−1[x], k ) 

132 



Insert() 

• Bei Binärbäumen wird immer ein neuer 

Blattknoten eingefügt 

• Bei B-Bäumen ist kein neuer Knoten 

nötig, solange der Blattknoten noch nicht 

voll ist 

• Steigt die Zahl der Schlüssel über 2×t−1, 

so wird das Blatt geteilt 

133 



Insert() 

• Naiver Ansatz 

– Suche das entsprechende Blatt 

– Split() falls überfüllt 

– Propagiere nach oben, falls Vaterknoten 

ebenfalls überläuft 

– Problem: Auf die Knoten entlang des 

Pfades wird jeweils zweimal zugegriffen 

134 



Insert() 

• One-Pass Algorithmus 

– Teile die Knoten entlang des Suchpfades bereits 

auf dem Hinweg wenn diese schon voll sind 

– Evtl. unnötige Split-Operationen amortisieren sich 

durch den schnelleren Average-Case 

135 



SplitChild() 

• SplitChild(x,i) 

// x : Vaterknoten 

// i : Index des Sohns 

// Vorbedingung: ci[x] ist voll 

136 



SplitChild() 

• Beispiel t = 4 

x 

... 

K S ... 

ci[x] 

L 

M N O 

P Q R 

137 



SplitChild() 


x 

... 

K S ... 

L 

M N 

O 

P Q R 

138 



SplitChild() 


x 

... 

K S ... 

L 

M N 

O 

P Q R 

139 



SplitChild() 


x 

... 

K O S 

... 

ci[x] 

L 

M N 

P Q R 

ci+1[x] 

140 



SplitChild() 

• Spezialfall: Wurzel 

L 

M N O 

P Q R 

141 



SplitChild() 


Erzeuge zuerst einen 

leeren Knoten ... 

L 

M N O 

P Q R 

142 



SplitChild() 



leeren Knoten ... dann 

SplitChild() 

L 

M N 

O 

P Q R 

143 



SplitChild() 



leeren Knoten ... dann 

SplitChild() 

L 

M N 

O 

P Q R 

144 



SplitChild() 


• B-Bäume wachsen an der Wurzel 

O 

L 

M N 

P Q R 

145 



Insert() 

• Insert(T,k) 

r ← root[T] 

if n[r] = 2×t−1 then 

s ← AllocateNode() 

root[T] ← s 

leaf[s] ← false 

n[s] ← 0 

c0[s] ← r 

SplitChild(s,0) 

InsertNonFull(s,k) 

else 

InsertNonFull(r,k) 

146 



InsertNonfull() 

• InsertNonFull(x,k) 

if leaf[x] then 

find correct position for k and insert 

DiskWrite(x) 

else 

find correct subtree ci[x] 

DiskRead(ci[x]) 

if n[ci[x]] = 2×t−1 then 

SplitChild(x,i) 

if k > keyi[x] then 

i ← i + 1 

InsertNonFull(ci[x],k) 

147 



Beispiel 

t = 3 

G 

M P X 

A 

C D E 

J 

K 

N 

O 

R S T U V Y Z 

148 



Beispiel 

• Insert(B) 

G 

M P X 

A 

C D E 

J 

K 

N 

O 

R S T U V Y Z 

149 



Beispiel 

• Insert(B) 

G 

M P X 

A 

C D E 

J 

K 

N 

O 

R S T U V Y Z 

150 



Beispiel 

• Insert(B) 

G 

M P X 

A 

C D E 

J 

K 

N 

O 

R S T U V Y Z 

151 



Beispiel 

• Insert(B) 

G 

M P X 

A 

B 

C D E J K 

N 

O 

R S T U V Y Z 

152 



Beispiel 

• Insert(Q) 

G 

M P X 

A 

B 

C D E 

J 

K 

N 

O 

R S T U V Y Z 

153 



Beispiel 

• Insert(Q) 

G 

M P X 

A 

B 

C D E 

J 

K 

N 

O 

R S T U V Y Z 

154 



Beispiel 

• Insert(Q) 

G 

M P X 

A 

B 

C D E 

J 

K 

N 

O 

R S T U V Y Z 

155 



Beispiel 

• Insert(Q) 

G 

M P X 

T 

A 

B 

C D E 

J 

K 

N 

O 

R 

S 

U 

V 

Y 

Z 

156 



Beispiel 

• Insert(Q) 

G 

M P 

T 

X 

A 

B 

C D E 

J 

K 

N O R S U V Y Z 

157 



Beispiel 

• Insert(Q) 

G 

M P 

T 

X 

A 

B 

C D E 

J 

K 

N O R S U V Y Z 

158 



Beispiel 

• Insert(Q) 

G 

M P 

T 

X 

A 

B 

C D E 

J 

K 

N 

O 

Q R 

S 

U V 

Y 

Z 

159 



Beispiel 

• Insert(L) 

G 

M P 

T 

X 

A 

B 

C D E 

J 

K 

N 

O 

Q 

R S U V Y Z 

160 



Beispiel 

• Insert(L) 

G 

M P 

T 

X 

A 

B 

C D E 

J 

K 

N 

O 

Q 

R S U V Y Z 

161 



Beispiel 

• Insert(L) 

G 

M P 

T 

X 

A 

B 

C D E 

J 

K 

N 

O 

Q 

R S U V Y Z 

162 



Beispiel 

• Insert(L) 

P 

G 

M 

T 

X 

A 

B 

C D E 

J 

K 

N 

O 

Q 

R S U V Y Z 

163 



Beispiel 

• Insert(L) 

P 

G 

M 

T 

X 

A 

B 

C D E 

J 

K 

N 

O 

Q 

R S U V Y Z 

164 



Beispiel 

• Insert(L) 

P 

G 

M 

T 

X 

A 

B 

C D E 

J 

K 

N 

O 

Q 

R S U V Y Z 

165 



Beispiel 

• Insert(L) 

P 

G 

M 

T 

X 

A 

B 

C D E 

J 

K 

N 

O 

Q 

R S U V Y Z 

166 



Beispiel 

• Insert(L) 

P 

G 

M 

T 

X 

A 

B 

C D E 

J 

K 

L 

N 

O 

Q 

R S U V Y Z 

167 



Beispiel 

• Insert(F) 

P 

G 

M 

T 

X 

A 

B 

C D E 

J 

K 

L 

N 

O 

Q 

R S U V Y Z 

168 



Beispiel 

• Insert(F) 

P 

G 

M 

T 

X 

A 

B 

C D E 

J 

K 

L 

N 

O 

Q 

R S U V Y Z 

169 



Beispiel 

• Insert(F) 

P 

G 

M 

T 

X 

C 

A 

B 

D E 

J 

K 

L 

N 

O 

Q 

R S U V Y Z 

170 



Beispiel 

• Insert(F) 

P 

C 

G 

M 

T 

X 

A 

B 

D E 

J 

K 

L 

N 

O 

Q 

R S U V Y Z 

171 



Beispiel 

• Insert(F) 

P 

C 

G 

M 

T 

X 

A 

B 

D E 

J 

K 

L 

N 

O 

Q 

R S U V Y Z 

172 



Beispiel 

• Insert(F) 

P 

C 

G 

M 

T 

X 

A 

B 

D E 

F 

J 

K 

L 

N 

O 

Q 

R S U V Y Z 

173 



Delete() 

• Unkritisch für Blattknoten mit 

hinreichendem Füllgrad (häufigster Fall) 

• Bei Unterlauf müssen Knoten 

verschmolzen werden 

• Kann/muss nach oben propagiert werden 

• One-Pass-Formulierung? 

174 



Delete() 

• Delete() sucht den Schlüssel entlang 

eines Pfades 

• Eine Verschmelzung findet nur statt, 

wenn die entsprechenden Knoten 

beide einen Füllgrad ≤ t−1 haben. 

• Teste vor dem Abstieg, ob der 

Nachfolger Füllgrad ≥ t hat (dann ist 

Verschmelzung ausgeschlossen) 

• Falls dies nicht der Fall ist, erzwinge 

dies durch direkte Umstrukturierung 

175 



Delete() 

• Wie bei Insert() sorgen wir dafür, dass 

der aktuelle Knoten hinreichend gefüllt 

ist, so dass keine Verschmelzung 

notwendig wird (Schleifeninvariante) 

• Falls ein Knoten nicht hinreichend 

gefüllt wäre, hätten wir das bereits bei 

der Bearbeitung des Vaterknotens 

bemerkt und behoben. 

176 



Delete() 

• Hilfsoperationen 

– Steal() 

– Merge() 

– Rotate() 

177 



Steal() 

• Lösche Element aus aktuellem Knoten 

t = 3 

C 

H 

M 

A 

B 

D 

E F 

J 

K 

N 

O P 

mehr als t−1 Knoten → rekursiver Abstieg möglich 

178 



Steal() 

C 

H 

M 

A 

B 

D 

E F 

J 

K 

N 

O P 

... G 

179 



Steal() 

C 

H 

M 

A 

B 

D 

E F 

J 

K 

N 

O P 

... G 

180 



Steal() 

C 

G 

M 

A 

B 

D 

E F 

J 

K 

N 

O P 

... 

181 



Merge() 


C 

G 

M 

A 

B 

D 

E 

J 

K 

N 

O 

nur t−1 Knoten → rekursiver Abstieg nicht möglich 

182 



Merge() 

C 

M 

A 

B 

G 

D E J K N O 

183 



Merge() 

C 

M 

A 

B 

D E G J K N O 

184 



Merge() 


C 

M 

A B D E G J K N O 

185 



Rotate() 

• Lösche Element aus rechtem Teilbaum 

C 

G 

M 

A 

B 

D 

E 

F 

J 

K 

N 

O 


186 



Rotate() 

• Lösche Element aus rechtem Teilbaum 

C 

G 

M 

A 

B 

D 

E 

F 

J 

K 

N 

O 


187 



Rotate() 

C 

M 

G 

A 

B 

D 

F 

E 

J 

K 

N 

O 

188 



Rotate() 

C 

M 

F 

G 

A 

B 

D 

E 

J 

K 

N 

O 

189 



Rotate() 

C 

M 

F 

G 

A 

B 

D 

E 

J 

K 

N 

O 

190 



Rotate() 

C 

F 

M 

A 

B 

D 

E 

G 

J 

K 

N 

O 

191 



Rotate() 

C 

F M 

A 

B 

D 

E 

G 

J 

K 

N 

O 

192 



Delete() 

• Standardfall: Schlüssel nicht im Knoten, 

Rekursion in den entsprechenden Teilbaum 

• Nur in Knoten absteigen, die hinreichend 

gefüllt sind → wenn nicht, vorher den Baum 

mit Merge(), Steal(), Rotate() umstrukturieren. 

• Nicht-Standardfälle: 1, 2a, 2b, 3a, 3b 

(s. Cormen) 

193 



B-Bäume – Delete – Scheme 

Blatt 

Kein Blatt 

1 

This 

Rekursion 

L. oder R. 

≥ t 

Beide 

< t 

L. oder R. 

≥ t 

Beide 

< t 

2ab 2c 3a 3b 

Steal Merge Rotate Merge 

194 



Delete() 

• Fall 1: Schlüssel in einem Blatt 

Del(F, P ) 

C 

G 

M 

T 

X 

A 

B 

D 

E 

F 

J 

K L 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

195 



Delete() 


P 

Del(F, C G M ) 

T 

X 

A 

B 

D 

E 

F 

J 

K L 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

196 



Delete() 


P 

C 

G 

M 

T 

X 

Del(F, D E F ) 

J 

K L 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

197 



Delete() 


• Schlüssel wird gelöscht 

P 

C 

G 

M 

T 

X 

A 

B 

D 

E 

J 

K L 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

198 



Delete() 

• Fall 2a: Schlüssel in innerem Knoten, 

linker Sohn hat ≥ t Schlüssel 

• Stehle Vorgänger aus linkem Teilbaum 

Del(M, P ) 

C 

G 

M 

T 

X 

A 

B 

D 

E 

J 

K L 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

199 



Delete() 




P 

Del(M, C G M ) 

T 

X 

A 

B 

D 

E 

J 

K L 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

200 



Delete() 




P 


T 

X 

A 

B 

D 

E 

J 

K L 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

201 



Delete() 




P 


T 

X 

A 

B 

Del(L, J K L ) 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

202 



Delete() 




P 


L 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

203 



Delete() 




P 

C 

G 

L 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

204 



Delete() 

• Fall 2b: Schlüssel in innerem Knoten, 

rechter Sohn hat ≥ t Schlüssel 

→ analog zu Fall 2a 

205 



Delete() 

• Fall 2c: Schlüssel in innerem Knoten, beide Söhne 

haben t−1 Schlüssel 

Del(G, P ) 

C 

G 

L 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

206 



Delete() 



P 

Del(G, C G L ) 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

207 



Delete() 



• Stehlen nicht möglich → Merge() 

P 

Del(G, C G L ) 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

208 



Delete() 




P 

Del(G, C L ) 

G 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

209 



Delete() 




P 

Del(G, C L ) 

T 

X 

A 

B 

D 

E 

G 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

210 



Delete() 




P 

Del(G, C L ) 

T 

X 

A 

B 

D 

E 

G 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

211 



Delete() 




• Rekursion 

P 

C 

L 

T 

X 

B Del(G, D E G J K ) 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

212 



Delete() 




• Rekursion 

P 

C 

L 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

213 



Delete() 

• Fall 3a: Schlüssel nicht im aktuellen Knoten, der 

entspr. Unterbaum hat nur t−1 Schlüssel, sein 

Bruder aber t Schlüssel 

C 

L 

P 

T 

X 

A B E J K N O 

Q 

R S 

U 

V 

Y 

Z 

214 



Delete() 




Del(B, C L P T X ) 

A B E J K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

215 



Delete() 




• Rotate() 


A B E J K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

216 



Delete() 




• Rotate() 


A 

B 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

217 



Delete() 




• Rotate() 

C 

Del(B, L P T X ) 

E 

A 

B 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

218 



Delete() 




• Rotate() 

Del(B, L P T X ) 

E 

C 

A 

B 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

219 



Delete() 




• Rotate() 

Del(B, E L P T X ) 

A 

B 

C 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

220 



Delete() 




• Rotate(), Rekursion 

E 

L 

P 

T 

X 

Del(B, A B C ) J K N O 

Q 

R S 

U 

V 

Y 

Z 

221 



Delete() 




• Rotate(), Rekursion 

E 

L 

P 

T 

X 

A 

C 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

222 



Delete() 

• Fall 3b: Schlüssel nicht im aktuellen Knoten, 

sowohl der entspr. Unterbaum als auch dessen 

Brüder haben t−1 Schlüssel 

P 

C 

L 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

223 



Delete() 




Del(D, P ) 

C 

L 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

224 



Delete() 




Abstieg nicht 

möglich! 

Del(D, P ) 

C 

L 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

225 



Delete() 




• Merge zwei der Unterbäume 

Abstieg nicht 

möglich! 

Del(D, P ) 

C 

L 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

226 



Delete() 





Del(D, ) 

C 

L 

P 

T 

X 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

227 



Delete() 





Del(D, C L P T X ) 

A 

B 

D 

E 

J 

K 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

228 



Delete() 





C 

L 

P 

T 

X 

Del(D, D E J K ) 

N 

O 

Q 

R S 

U 

V 

Y 

Z 

229 



Delete() 





C 

L 

P 

T 

X 

A B E J K N O 

Q 

R S 

U 

V 

Y 

Z 

230 



Zusammenfassung 

• B-Bäume 

– Optimierter Zugriff auf externen Speicher 

durch Blockung mehrerer Schlüssel 

– Minimaler/maximaler Füllgrad 

– Garantierte Balancierung 

– Hysterese bei der Umstrukturierung 

– Steal(), Merge(), Rotate() 

231

Vorlesung 2.5.3

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?