Algo+Dat 2

10.
Kapitel BÄUME
(Teil 2)

BALANCIERTE
BÄUME
Algorithmen & Datenstrukturen

Prof. Dr. Wolfgang Schramm
Übersicht
1
1.  Einführung
2.  Algorithmen
3.  EigenschaDen von
Programmiersprachen
4.  Algorithmenparadigmen
5.  Suchen & SorMeren
6.  Hashing
7.  Komplexität von Algorithmen
8.  Abstrakte Datentypen (ADT)
9.  Listen
10. Bäume
11. Graphen
Lernziele des Kapitels
2
2
¨  Verstehen, wie balancierter
Baum aussieht?
¨  Kennenlernen verschiedener
Arten balancierter Bäume.
¨  Kennenlernen der speziellen
OperaMonen, um balancierte
Bäume im Gleichgewicht zu
halten.
Inhalt
3
1.  Balancierte Bäume

n  AVL-‐Bäume
n  B-‐Bäume
2.  Weitere Bäume
Ausgeglichene Bäume
4
Problem
4 4
4 insert (6) insert (8)
6 6
8
4
11
5
¨  Man muss dafür sorgen, dass ein Baum bei einer ungünsMgen
Einfügereihenfolge nicht entartet.
¨  Idee: bei jeder Einfüge-‐ oder LöschoperaMon versucht man den Baum
auszugleichen.
¨  Beispiel:
insert A G F
ausgleichen
E J C I
C F I A E G J
A
6
o  AVL-‐Bäume (nach G.M. Adelson-‐Velskii und E.M. Landis): sind höhenbalanciert.
Halten den Aufwand beim Ausgleichen begrenzt.
o  B-‐Bäume (B wie balanciert, breit, buschig oder Bayer) sind n-‐äre Bäume: sind
höhenbalanciert mit unausgeglichenem Verzweigungsgrad.
o  Es gibt noch weitere ausgeglichene Bäume.

AVL -‐ Bäume
7
¨  AVL-‐Kriterium: Für jeden inneren Knoten ist der absolute Betrag der
Differenz der Höhen des linken und des rechten Teilbaums maximal 1.
¨  Beispiel: Welcher Baum erfüllt die AVL-‐EigenschaD und welcher nicht?
G I
D J D J
C F I C F
E E G
AVL-Baum Kein AVL-Baum

AVL -‐ Bäume
8
o  Balance eines Knotens k: b(k) = height(k.leD) – height(k.right)

o  Mit AVL-‐Kriterium: b(k) ∈ { -‐1, 0, +1 }
o  Einfügen in AVL-‐Baum:
¤  Knoten wird wie in normalen binären Suchbaum als Blao eingefügt.
¤  Durch das Einfügen kann die AVL-‐EigenschaD verletzt werden, d.h. die
Balance eines Knotens kann auch die Werte –2 oder +2 annehmen
→ b(k) ∈ { -‐2, -‐1, 0, +1, +2 }. Der Knoten ist somit außer Balance.
¤  Die Verletzung der AVL-‐EigenschaD muss durch Ausgleichen behoben
werden.
¤  Das Ausgleichen erfolgt durch die Vertauschung von Knoten und damit
einem neuen „Layout“ des Baums.
¤  Diese Vertauschungen nennt man RotaMonen.
AVL – Bäume Ausgleichsregeln
9
Wie wird bei Verletzungen der AVL-‐EigenschaDen ausgeglichen?

⇒  Fallunterscheidungen:
1)  Einfügen im linken Teilbaum des linken Kindes à RotaMon mit dem linken Kind.
2)  Einfügen im rechten Teilbaum des linken Kindes à DoppelrotaMon mit dem
linken Kind.
3)  Einfügen im rechten Teilbaum des rechten Kindes à RotaMon mit dem rechten
Kind.
4)  Einfügen im linken Teilbaum des rechten Kindes à DoppelrotaMon mit dem
rechten Kind.
Wegen der Symmetrie der Fälle 1. und 3. bzw. 2. und 4. à Beschränkung auf 1. und 2.
AVL-‐Bäume -‐ Balancierung
10
+2
k3 0
+1 k2
Einfache Rotation 0 0
k2 (R) nach rechts
0 k1 k3
k1
Rotation von k2 über k3
+2 0
k3 Doppelrotation (LR) k1
-1 erst nach links, dann 0 0
nach rechts
k2 k2 k3
0
Rotation von k1 über k2 und k3
k1
Einfügen im linken Teilbaum des linken Kindes 1/2
11
1. Einfügen

rot = Balance
1 2
7 7
0 1
5 Einfügen 2
5
0
2
Einfügen im linken Teilbaum des linken Kindes 2/2
12
2. Ausgleich durch RotaMon (einfache Darstellung)

Einfache RotaQon
rot = Balance
2
7 0
1 5
0 0
5
0 Einfache Rotation 2 7
2 nach rechts
Einfügen im rechtenTeilbaum des linken Kindes 1/2
13
1.  Einfügen
rot = Balance
1 2
7 7
0 -1
5 Einfügen 6 5
0
6
Einfügen im rechtenTeilbaum des linken Kindes 2/2
14
2. Ausgleich durch RotaMon (einfache Darstellung)

DoppelrotaQon (LR) = RotaMon nach links und dann nach rechts.
rot = Balance
2
7 2
-1 7
Rota
tion 1
5 (L)
0 6
0
6
Rota 0
5 tion
(R) 6
0 0
5 7
AVL – Bäume Anwendung der Ausgleichsregeln
15
o  Ausgleichen für den Knoten k für den das AVL-‐Kriterium verletzt ist.
Fälle:
1.  Einfügen im linken Teilbaum des linken Kindes
à RotaMon des Knotens mit linkem Kind
2.  Einfügen im rechten Teilbaum des linken Kindes.
à DoppelrotaMon
à RotaMon linkes Kind mit seinem rechten Kind
à RotaMon des Knotens mit linken Kind
o  Die Fälle „Einfügen … des rechten Kindes“ sind symmetrisch à hier nicht
betrachtet.
Einfügen – Änderung der Struktur 1/2
16
o  RotaMon (genaue Darstellung): LinksrotaMon von k.

vorher nachher

Wurzel k k.leD
linkes Kind der Wurzel k.leD k.leD.leD
rechte Kind der Wurzel k.right k

li. Ki. des li. Ki. der Wurzel k.leD.leD k.leD.leD.leD
re.Ki. des li. Ki. der Wurzel k.leD.right k.leD.leD.right

li. Ki. des re. Ki. der Wurzel k.right.leD k.leD.right
re.Ki. des re. Ki. der Wurzel k.right.right k.right
Die „nachher“-Position bezieht sich immer auf den den

neuen Wurzelknoten, der Pfad zu dem entsprechenden
Knoten beginnt immer beim alten Wurzelknoten k.
Einfügen – Änderung der Struktur 2/2
17
¨  RotaMonen (genaue Darstellung): Einfache RotaQon

2

10

1 0
rot = Balance
7 13
1 0
0
5 9
0 7
1 0
2
5 10
0 0 0
2 9 13
Nur die blau markierten
Referenzen werden geändert
ImplemenMerung – AVL-‐Baum 1/4
20
public class AVLTreeNode {

Element value;
TreeNode left;
TreeNode right;
int balance; // reicht aus
boolean isbalanced; // redundant !
// Konstruktor
public AVLTreeNode (Element value,
AVLTreeNode left,
AVLTreeNode right) {
this.value = value;
this.left = left;
this.right = right;
balance = 0;
}
}
ImplemenMerung AVL-‐Baum 2/4
21
public class AVLTree {

AVLTreeNode root;
// Konstruktoren
public AVLTree ( ) {
}
public AVLTree (Element v) {

root = new AVLTreeNode (v, null, null);
}
...
22
o  RotaMon (Methode in AVLTree)

private TreeNode rotateLeft (TreeNode t) {
TreeNode tmp = t.right;
t.right = t.right.left;
tmp.left = t;
return tmp;
}
o  Analog rotateRight
23
o  DoppelrotaMon (verwendet in AVLTree)

¤  2 RotaMonen
¤  DoppelrotaMon links = Rot. Rechts + Rot. Links
...
r.right = rotateRight (r.right);
TreeNode tmp = rotateLeft (r);
// tmp ist neue Wurzel
...
ImplemenMerung – AVL-‐Baum -‐ Einfügen 1/8
24
o  Idee
¤  Einfügen des neuen Knotens als Blao (wie Binärbaum).
¤  Anschließend ggf. Ausgleichen durch RotaMon.
¤  Es gilt
n  Es müssen höchstens Knoten auf dem Weg

vom eingefügten Blao zur Wurzel ausgeglichen werden.
n  Es muss höchstens ein Knoten ausgeglichen werden
(d.h. höchstens eine RotataMon oder DoppelrotaMon) .
o  Grundlage
¤  Rekursives insert (= insertR) für Binärbaum.
¤  Rekursiv, da dann Weg von Einfügeknoten zu Wurzel verfügbar ist.
25
o  (Methode in AVLTree)

public void insert (Element p) {
if (root == null) {
root = new AVLTreeNode (p);
} else {
root = insertR (root, p);
}
}
26
private AVLTreeNode insertR (

AVLTreeNode t, Element p) { ... }
1.  Grundlage: rekursives Einfügen des Binärbaums.
2.  Erweiterung: Rebalancieren
a) Feststellen, ob rebalanciert werden soll:
I.  ein Knoten hat die Balance 1 (linker Unterbaum
größer)
UND
es wurde im linken Unterbaum eingefügt
II.  Der Baum wurde noch nicht rebalanciert
(nur ein Rebalancieren notwendig bei Einfügen!)
b) Rebalancieren & Balance aktualisieren
27
private TreeNode insertR (TreeNode t, int i) {

// t not equal null!
if (i < t.val) { Zu 1. Grundlage:
// left subtree rekursives Einfügen
if (t.left == null) { im Binärbaum
// no subtree – insert node
t.left = new TreeNode (i);
} else {
// insert in right subtree
t.left = insertR (t.left, i);
}
} else if (i == t.val) {
// nothing to do
} else {
// i > t.val
// right subtree analogue left subtree
}
}
28
Zu 2 a I: linker Unterbaum größer (Balance 1)

UND in linken Unterbaum wurde eingefügt
¤  Nach dem Einfügen (rekursiver insertR-‐Aufruf):
t.balance == 1 &&
Math.abs (t.left.balance) == 1
Anmerkung:
nach dem Einfügen kann die
Balance auf 0 sein – in dem Fall
ist der Baum jedoch bereits
balanciert
29
Zu 2 a II: Baum noch nicht rebalanciert

¤  Beim „Absteigen“ durch die rekursiven Aufrufe:
in jedem besuchten Knoten t:
t.isbalanced = false
¤  Beim „Aufsteigen“:
1.  t.isbalanced = t.left.isbalanced

falls der Unterbaum bereits balanciert wurde,
dann ist auch der übergeordnete balanciert
2.  Setze t.isbalanced = true
falls der Baum balanciert wird bzw. ist:
n  RotaMonen
n  Es gibt Knoten gleichen Niveaus Baum hat die
mit eingefügtem Knoten in rechten Balance 0
Unterbaum
30
Zu 2 b Balancieren (nur falls noch nicht balanciert wurde)
¤  Balance der Wurzel erhöht sich um 1
¤  Falls Balance == 2
n  Balancierregeln anwenden

n  RotaMon oder DoppelrotaMon
n  Balancen neu berechnen
n  Neue Wurzel: Balance = 0
n  RechtsrotaMon
right (ehemalige Wurzel): Balance = 0
n  DoppelrotaMon: neue Balancen =

alte Balance der neuen Wurzel
1 -‐1
leD 0 1
right -‐1 0
31
¨  Java Programm

AVL-‐Bäume Beispiel für Balancierung
32
+1
Tb1 Tb4
Tb2 Tb3
Welche Aussagen kann man über die Höhenverhältnisse der Teilbäume

machen?
In welche Teilbäume kann man noch Knoten einfügen, ohne dass einer der
angegebenen Knoten aus der Balance gerät?
AVL-‐Bäume Beispiel für Balancierung
33
-1 k k2 0
1
0 k2 k1 0
Tb1
Tb2 Tb3 Tb1 Tb2 Tb3
Welche Aussagen kann man über die Höhenverhältnisse der Teilbäume

machen?
In welche Teilbäume kann man noch Knoten einfügen, ohne dass einer der
angegebenen Knoten aus der Balance gerät?
ImplemenMerung – AVL-‐Baum -‐ Löschen
34
1.  Grundlage: rekursives Löschen im Binärbaum

2.  Erweiterung: Rebalancieren
a) Feststellen, ob rebalanciert werden soll
n  Betrachten des ganzen Pfades von der Wurzel
bis zum gelöschten Element und zurück.
n  Balancieren mehrerer Knoten möglich.
b) Rebalancieren & Balance aktualisieren
Mehrwegbäume: MoMvaMon 1/2
36
o  Mit AVL-‐Bäumen: Bäume sind ausgeglichen à Anzahl der

OperaMonen ist begrenzt.
o  Was ist, wenn der Baum zu groß für den Hauptspeicher ist?
o  Externe Datenspeicherung → Speicherhierarchie:
¤  Register (< 1kB) 1 ns
¤  Cache (L2) (0,5-‐2 MB) 3 ns
¤  Hauptspeicher (512 MB – 8 GB) 20 ns
¤  Festplaoe (20 – 512 GB) 7 ms

o Zugriffsverhältnis zwischen Hauptspeicher und Festplaoe:
t(Plaoe) / t(Hauptspeicher) = (7·∙10-‐3) / (20·∙10-‐9) = 3.5·∙105
Mehrwegbäume: MoMvaMon 2/2
37
è Zugriff auf (externe) Knoten sehr teuer.

Beispiele:
o  Dateibaum des Datei-‐Systems.
o  Tabellen von Datenbanken (DB2 (IBM), Sybase, Oracle, ...).
à Man häoe gerne einen Baum, der noch geringere Tiefe hat
als log2 n.

Idee:
o  Erhöhe die Basis des Logarithmus (à Mehrweg-‐Baum).
o  Speichere mehrere "aufeinanderfolgende" Baum-‐Knoten auf

derselben Seite (Page) auf der Plaoe.
à Reduziere damit die Anzahl der Seitenzugriffe.
m-‐Wege-‐Baum
38
o  Ein m-‐Wege-‐Suchbaum ist eine Verallgemeinerung eines

binären Suchbaumes (d. h., ein binärer Suchbaum ist ein 2-‐
Wege-‐ Suchbaum).
1 Seite
Wenn die Knoten des Baums jeweils wie eingerahmt auf einer Seite liegen, findet
man einen Wert mit maximal 2 Zugriffen auf einem externen Speicher, stao mit max.
5 Zugriffen, wenn das nicht garanMert ist.
Mehrwegebaum: DefiniMon
39
o  In einem m-‐Wege-‐Baum haben alle Knoten den Grad ≤ m.
o  Der Baum ist entweder leer oder besitzt folgende EigenschaDen:
o  Jeder Knoten hat folgende Struktur:
k1 k2 k3 k4
t0 t1 t2 t3 t4
¤  ki sind die Schlüssel, 1 ≤ i ≤ m-‐1.
¤  m-‐1 ist die Anzahl der Schlüssel im Knoten. Beispiel: m = 5
¤  ti sind die Zeiger zu den Unterbäumen des Knotens.

o  Schlüssel innerhalb eines Knotens sind aufsteigend geordnet:
¤  k1 ≤ k2 ≤ ... ≤ km-‐1
o  Alle Schlüssel im Unterbaum ti sind kleiner als ki+1 , für 0 ≤ i < m-‐1.
o  Alle Schlüssel im Unterbaum tm-‐1 sind größer als km-‐1.
o  Die Unterbäume ti , für 0 ≤ i ≤ m-‐1, sind ebenfalls m-‐Wege-‐Bäume.
EigenschaDen von m-‐Wege-‐Bäumen
40
o  Baum ist nicht ausgeglichen.

o  Bläoer sind auf verschiedenen Stufen
o  Bei Veränderungen gibt es keinen Ausgleichsalgorithmus.
o  Schlechte Speicherausnutzung, kann zu verkeoeten Listen

degenerieren.
o  Anzahl der Knoten im vollständigen m-‐Wege Baum mit Höhe h:
h−1 h
ANZ =∑ m
m m −1
=K
−1 i
i=0
o  Maximale Anzahl n von Schlüsseln:

¤  n ≤ AnzK*(m-‐1) = mh -‐1
o  Völlig degenerierter Baum: n = AnzK = h
o  Grenze für die Höhe eines m-‐Wege-‐Baumes: logm(n+1) ≤ h ≤ n.
Prinzip des B-‐Baums
41
o  B-‐Baum-‐Kriterium
¤  Alle Pfade von der Wurzel bis zu den Bläoern sind gleich lang.
¤  Jeder Knoten – außer der Wurzel – enthält zwischen m und 2m
Schlüsselwerte.
¤  Jeder Knoten (außer der Wurzel) hat zwischen m+1 und 2m+1 Kinder
(Unterbäume).
¤  Die Wurzel ist entweder ein Blao oder hat mindestens 2 Kinder.

o  B-‐Baum
¤  Ein B-‐Baum ist ein Baum, der das B-‐Baum-‐Kriterium erfüllt (für ein
gegebenes m).
¤  m heißt Ordnung eines B-‐Baums.
B-‐Baum – EigenschaDen der Knoten 1/2
42
geordnet:
e1 e2 e3 e4
∀ Knoten k aus b2:
∀ Elemente e aus k:
e 1 < e < e2
b1 b2 b3 b4 b5
B-‐Baum – EigenschaDen der Knoten 2/2
43
Baum der Ordnung m:

m < i < 2m
…
e1 e2 e3 ei Max. Anzahl von
Elementen: 2m
Max. Anzahl von
Unterbäumen: 2m+1
b1 b2 b3 bi bi+1
B-‐Baum -‐ Beispiel
44
25 63
8 15 35 43 56
2 4 5 11 12 19 21 22 28 31
B-‐Baum: DefiniMon
46
Ein Baum heißt B-‐Baum der Ordnung m, wenn er folgende EigenschaDen erfüllt:

1.  Jeder Knoten enthält höchstens 2 ⋅ m Elemente.
2.  Jeder Knoten außer dem Wurzelknoten enthält mindestens m Elemente. Der
Wurzelknoten enthält mindestens ein Element.
3.  Jeder Knoten ist entweder ein Blao ohne Nachfolger oder hat i+1 Nachfolger,
falls i die Anzahl der Elemente ist.
4.  Alle Bläoer liegen auf dem gleichen Niveau.
5.  Ist ei ein Element, dann sind im linken Nachfolgeknoten (vi) alle Schlüssel
kleiner und im rechten (vi+1) alle größer (Ordnungskriterium).
Bemerkung: Die Terminologie im Zusammenhang mit B-Bäumen ist in der Literatur nicht ganz einheitlich. Oft
wird auch der maximale Verzweigungsgrad (in unserem Fall 2 ⋅ m + 1) als Ordnung bezeichnet –
etwa von D. Knuth. Deshalb muss man die jeweilige Definition immer genau beachten!
B-‐Bäume: 2-‐3 Bäume
47
o  Ein B-‐Baum der Ordnung 1 hat
¤  pro Knoten mindestens 1 höchstens 2 Elemente.

¤  pro Knoten mindestens 2 höchstens 3 Kinder.
o  Man nennt einen B-‐Baum der Ordnung 1 auch 2-‐3 Baum, wenn man damit die
minimale und maximale Anzahl der Kinder eines Knotens angibt. Diese Art der
KlassifikaMon von B-‐Bäumen wird insbesondere dann verwendet, wenn man den
maximalen Verzweigungsgrad für die Ordnungsangabe heranzieht.
B-‐Bäume Aufnahmekapazität
48
o  Maximale Höhe eines B-‐Baums der Ordnung m bei minimaler Füllung:
o  Sind dort n Knoten unterzubringen, gilt für die Höhe h = logm n.
o  Die Höhe eines B-‐Baums ist logarithmisch in der Anzahl der gespeicherten
Schlüssel beschränkt.
o  Die Ordnung eines B-‐Baums liegt üblicher Weise bei 50 – 100. B-‐Bäume sind auch
bei einer sehr großen Zahl von gespeicherten Schlüsselwerten besonders niedrig.
o  Frage: Wie viele Schlüssel kann ein B-‐Baum der Ordnung m = 50 bei einer Höhe
von h = 4 maximal aufnehmen?
B-‐Bäume: Suchen
49
o  Suchen = KombinaMon des Verfolgens von Verweisen (wie im binären Suchbaum)
und der Suche in einer sorMerten Folge.
o  Gesucht wird nach dem Wert w.
o  Man beginnt im Wurzelknoten und besMmmt dort den Eintrag, für den gilt:
ei ≥ w.
o  Ist ei = w, dann ist man ferMg (man hat w gefunden).
o  Sonst geht man zum Knoten vi , d.h. man folgt dem Verweis, der vor ei liegt.
o  Gibt es kein Element mit ei ≥ w, dann folgt man dem letzen Verweis des Knotens.
o  Findet man den Wert w auch auf einer erreichten Blaoseite nicht, dann ist der
Wert nicht im Baum enthalten.
Ein Beispiel B-‐Baum
50
25
10 20 31 40
2 5 7 8 13 14 17 18 22 24 26 27 28 32 38 42 43
B-‐Baum Einfügen 1/2
51
o  Ziel: Einfügen eines Wertes (Elements) w in den B-‐Baum.

o  Die B-‐Baum EigenschaD (m ≤ Anzahl der Elemente pro Knoten ≤ 2m) darf nicht verletzt
werden.
1.  Suchen des Blaoknotens, in dem eingefügt werden muss (müsste).
2.  PosiMon im gefundenen Knoten – mit 3 Fallunterscheidungen:
a)  Es gibt 2 Elemente s und b mit s < w < b.
b)  Ein Element s als kleinstes Element des Knotens mit w < s; dabei ist s das am weitesten links
stehende Element.
c)  Ein Element b als größtes Element des Knotens mit b < w; dabei ist b das am weitesten rechts
stehende Element.
3.  Einfügen des Elements mit 2 Fallunterscheidungen :
a)  Der Knoten enthält bisher < 2m Elemente: dann muss man nur noch an der richMgen PosiMon
einfügen.
b)  Der Knoten enthält bereits 2m Elemente. Dann platzt der Knoten beim Einfügen eines weiteren
Elements. D.h. es muss ein neuer Knoten eingeführt werden, dadurch ändert sich auch die
Knotenstruktur des Baums.
52
o  Erzeugen eines neuen Knotens:

1.  Die ersten m Werte bleiben im Originalknoten.
2.  Die letzten m Werte werden in den neuen Knoten verschoben.
3.  Das miolere Element wandert in den Elternknoten nach oben.
o  Da der Elternknoten ein Element mehr aufnimmt, kann er auch platzen (Anzahl der
Elemente in Elternknoten > 2m) → der Prozess des Erzeugens eines neuen Knotens beginnt
von neuem und setzt sich rekursiv fort bis in den Wurzelknoten.
o  Platzt auch der Wurzelknoten, dann wird auch er geteilt und ein neuer Elternknoten (ein
neuer Wurzelknoten) erzeugt, d.h. wächst der Baum um eine Ebene.
o  Feststellung: B-‐Bäume wachsen in Richtung Wurzel – anders als die bisherigen Bäume.
Es gibt eine Ausgleichsvariante è später

53
insert 16
25
10 20
2 5 7 8 13 14 17 18 22 24
13 14 16 17 18 Der Blattknoten platzt !
13 14 17 18 Split in 2 Knoten (alten + einen neuen)

54
25
10 16 20
2 5 7 8 13 14 17 18 22 24
B-‐Baum Löschen 1/3
55
o  Im Prinzip ähnlich wie Einfügen – nur mit umgekehrten Effekten. Ein
Knoten kann defizitär werden, d.h. durch Entnahme kann die Anzahl der
Elemente im Knoten < m werden.
1.  Suchen des Knotens, aus dem das Element w en•ernt werden soll.
2.  En•ernen im gefundenen Knoten – mit 2 Fallunterscheidungen:
a)  Liegt w in einem Blaoknoten, dann kann das Element gelöscht
werden. Bleiben auf dem Blaoknoten weniger als m Elemente übrig,
dann ist ein Defizit (Unterlauf) zu behandeln.
b)  Liegt w in einem inneren Knoten, dann wird das Element gelöscht und
durch das nächst kleinere Element von einem Blaoknoten ersetzt
(ähnlich wie beim binärem Suchbaum, wo man das größte Element im
linken Teilbaum einsetzte). Bleiben auf dem Blaoknoten weniger als m
Elemente übrig, dann ist ein Defizit zu behandeln.
Man ist am Ende immer in einem Blaoknoten angekommen.
56
3.  Behandlung des Defizits (Unterlaufs) mit 2 Fallunterscheidungen:

a)  Ausgleichen zweier benachbarter Knoten: wenn der Nachbarknoten n (n > m)
Elemente enthält, dann kann sie einen Knoten „abgeben“. Dabei werden die
Elemente der beiden beteiligten Knoten sowie das „eingeschlossene“ Element auf
dem Elternknoten neu verteilt, so dass beide Kinder(knoten) mindestens m
Elemente enthalten.
b)  Vereinigen zweier benachbarter Knoten: wenn ein Ausgleich nicht möglich ist – das
ist dann der Fall, wenn der Nachbarknoten n = m Elemente enthält – werden die
beiden Knoten zusammengefasst. Zusätzlich wird noch das „eingeschlossene“
Element aus dem Elternknoten herunter gezogen. Dieser neue Blaoknoten hat jetzt
n = 2m Elemente (m-‐1 von dem Knoten, wo ein Element en•ernt wurde, m vom
Nachbarknoten und 1 vom Elternknoten).
c)  Jetzt kann auch der Elternknoten defizitär werden (es wurde ja ein Element
entnommen) → der Prozess der Unterlau‚ehandlung eines Knotens beginnt von
neuem und setzt sich rekursiv fort bis in den Wurzelknoten.
57
o  Wird auch das letzte und einzige Element im Wurzelknoten en•ernt, dann
werden die beiden darunter liegenden Knoten vereinigt. Der Baum
schrumpD um eine Ebene von der Wurzel her.
o  Feststellung: B-‐Bäume schrumpfen an der Wurzel – anders als die
bisherigen Bäume.
B-‐Baum Löschen mit Ausgleichen
58
delete 22 25
10 20 31 40
2 5 7 8 13 14 17 18 22 24 26 27 28 32 38 42 43
10 18
2 5 7 8 13 14 17 20 24
B-‐Baum Löschen mit Vereinigen
59
delete 43 25
10 20 31 40 50
2 5 7 8 13 14 17 18 22 24 26 27 28 32 38 42 43
31 50
26 27 28 32 38 40 42
B-‐Baum Einfügen-‐Variante 1/2
60
insert 16
25
10 20
2 5 7 8 13 14 17 18 22 24
13 14 16 17 18 Der Blattknoten platzt !
Ausgleich mit Nachbarknoten statt Split.

B-‐Baum Einfügen-‐Variante 2/2
61
25
10 18
2 5 7 8 13 14 16 17 20 22 24
B*-‐Baum (nach Donald Knuth, 1973)

¨  Knoten müssen mindestens zu 2/3 gefüllt sein
(anstao nur 1/2).
¨  Durch veränderte Split-‐Strategie: 2 volle Knoten
auf 3 Knoten mit einem Füllgrad von 2/3
auDeilen.
B-‐Bäume: Zusammenfassung
62
o  Vielleicht die Datenstruktur, die in der Praxis am meisten
benutzt wird.
o  B-‐Bäume sind ausgeglichene m-‐Wege-‐Bäume.
o  Man wählt i.A. die Ordnung m gerade so groß, dass jeweils
alle Schlüssel eines B-‐Knotens genau einer page ( = Übertra-‐
gungseinheit, d.h. Blockgröße bei einem Lesezugriff – typisch
4-‐16 kByte) entsprechen:
¤  Typische Größen, z.B. m = 50 oder m = 2500.
¤  Sehr flache Bäume.
¤  Kurzer Weg von der Wurzel zu den Bläoern.
Weitere Bäume
63
o  Bruderbäume
„AVL-‐Bäume mit Bläoern gleichen Niveaus“
¤  Innere Knoten dürfen nur ein Kind haben
o  Treaps
„randomisierte Suchbäume“
¤  Problem: Einfügen einer Folge geordneter Elemente erzeugt
„degenerierten Baum“ (Liste

¤  Abhilfe: Eingabefolgen zufällig vertauschen
o  Digitale Bäume

¤  Tries
¤  Patriciabäume

Algo+Dat 2

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Algo+Dat 2

Hochgeladen von

Copyright:

Verfügbare Formate

10.

Algorithmen & Datenstrukturen

1. Balancierte Bäume

o Es gibt noch weitere ausgeglichene Bäume.

AVL-Baum Kein AVL-Baum

o Balance eines Knotens k: b(k) = height(k.leD) – height(k.right)

Wie wird bei Verletzungen der AVL-­‐EigenschaDen ausgeglichen?

2. Ausgleich durch RotaMon (einfache Darstellung)

2. Ausgleich durch RotaMon (einfache Darstellung)

o RotaMon (genaue Darstellung): LinksrotaMon von k.

Die „nachher“-Position bezieht sich immer auf den den

¨ RotaMonen (genaue Darstellung): Einfache RotaQon

public class AVLTreeNode {

public class AVLTree {

public AVLTree (Element v) {

o RotaMon (Methode in AVLTree)

o DoppelrotaMon (verwendet in AVLTree)

¤ Anschließend ggf. Ausgleichen durch RotaMon.

n Es müssen höchstens Knoten auf dem Weg

o (Methode in AVLTree)

private AVLTreeNode insertR (

private TreeNode insertR (TreeNode t, int i) {

Zu 2 a I: linker Unterbaum größer (Balance 1)

¤ Nach dem Einfügen (rekursiver insertR-­‐Aufruf):

Zu 2 a II: Baum noch nicht rebalanciert

1. t.isbalanced = t.left.isbalanced

¤ Falls Balance == 2

n Balancierregeln anwenden

¨ Java Programm

Welche Aussagen kann man über die Höhenverhältnisse der Teilbäume

Welche Aussagen kann man über die Höhenverhältnisse der Teilbäume

1. Grundlage: rekursives Löschen im Binärbaum

o Mit AVL-­‐Bäumen: Bäume sind ausgeglichen à Anzahl der

è Zugriﬀ auf (externe) Knoten sehr teuer.

o Tabellen von Datenbanken (DB2 (IBM), Sybase, Oracle, ...).

o Speichere mehrere "aufeinanderfolgende" Baum-­‐Knoten auf

o Ein m-­‐Wege-­‐Suchbaum ist eine Verallgemeinerung eines

¤ ti sind die Zeiger zu den Unterbäumen des Knotens.

o Baum ist nicht ausgeglichen.

o Bei Veränderungen gibt es keinen Ausgleichsalgorithmus.

o Schlechte Speicherausnutzung, kann zu verkeoeten Listen

o Maximale Anzahl n von Schlüsseln:

Baum der Ordnung m:

o Ein B-­‐Baum der Ordnung 1 hat

¤ pro Knoten mindestens 1 höchstens 2 Elemente.

o Ziel: Einfügen eines Wertes (Elements) w in den B-­‐Baum.

o Erzeugen eines neuen Knotens:

Es gibt eine Ausgleichsvariante è später

13 14 16 17 18 Der Blattknoten platzt !

13 14 17 18 Split in 2 Knoten (alten + einen neuen)

3. Behandlung des Deﬁzits (Unterlaufs) mit 2 Fallunterscheidungen:

13 14 16 17 18 Der Blattknoten platzt !

Ausgleich mit Nachbarknoten statt Split.

B*-­‐Baum (nach Donald Knuth, 1973)

„degenerierten Baum“ (Liste

o Digitale Bäume

Das könnte Ihnen auch gefallen

1.  Balancierte Bäume

o  Es gibt noch weitere ausgeglichene Bäume.

o  Balance eines Knotens k: b(k) = height(k.leD) – height(k.right)

Wie wird bei Verletzungen der AVL-‐EigenschaDen ausgeglichen?

o  RotaMon (genaue Darstellung): LinksrotaMon von k.

¨  RotaMonen (genaue Darstellung): Einfache RotaQon

o  RotaMon (Methode in AVLTree)

o  DoppelrotaMon (verwendet in AVLTree)

¤  Anschließend ggf. Ausgleichen durch RotaMon.

n  Es müssen höchstens Knoten auf dem Weg

o  (Methode in AVLTree)

¤  Nach dem Einfügen (rekursiver insertR-‐Aufruf):

1.  t.isbalanced = t.left.isbalanced

¤  Falls Balance == 2

n  Balancierregeln anwenden

¨  Java Programm

1.  Grundlage: rekursives Löschen im Binärbaum

o  Mit AVL-‐Bäumen: Bäume sind ausgeglichen à Anzahl der

o  Tabellen von Datenbanken (DB2 (IBM), Sybase, Oracle, ...).

o  Speichere mehrere "aufeinanderfolgende" Baum-‐Knoten auf

o  Ein m-‐Wege-‐Suchbaum ist eine Verallgemeinerung eines

¤  ti sind die Zeiger zu den Unterbäumen des Knotens.

o  Baum ist nicht ausgeglichen.

o  Bei Veränderungen gibt es keinen Ausgleichsalgorithmus.

o  Schlechte Speicherausnutzung, kann zu verkeoeten Listen

o  Maximale Anzahl n von Schlüsseln:

o  Ein B-‐Baum der Ordnung 1 hat

¤  pro Knoten mindestens 1 höchstens 2 Elemente.

o  Ziel: Einfügen eines Wertes (Elements) w in den B-‐Baum.

o  Erzeugen eines neuen Knotens:

3.  Behandlung des Deﬁzits (Unterlaufs) mit 2 Fallunterscheidungen:

B*-‐Baum (nach Donald Knuth, 1973)

o  Digitale Bäume