© Michael Philippsen

15. Bäume
Algorithmen und Datenstrukturen
15. Bäume
15.1
15.2
15.3
Suchbäume
Menge als Suchbaum
AVL-Bäume
Prof. Dr. Michael Philippsen
Department Informatik • Martensstraße 3 • 91058 Erlangen
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-2
15.1 Suchbäume
15.1 Suchbäume
Effizientes Suchen
Beispiel
Grundgedanke: Kombiniere Offenheit der verketteten Liste mit
Aufwand O(log2n) des Teile-und-Herrsche-Prinzips.
Bäume kann man sich als strukturelles Abbild des Teile-undTeile und
Herrsche-Prinzips vorstellen, wenn man beim Zugriff jeweils pro
Knoten nur ein Kind weiterverfolgt.
Eine solche Datenstruktur in Form eines Baums wird Suchbaum
genannt.
Ein binärer Suchbaum hat max. zwei Kinder je Knoten:
v
Wert
e<v
Wert
e>v
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-3
© Michael Philippsen
4
7
13 14 20 24 38
Binärer Suchbaum
2
1
h=2
0
4
14
7
24
13
20
38
Die Höhe h eines Knotens entspricht der Anzahl
Bei Graphen wird
der Kanten des längsten Pfades zu einem von
im Allg. eine
diesem Knoten aus erreichbaren Blatt (= Knoten
andere Def. der
ohne Nachfolger).
Höhe verwendet.
Die Höhe h eines Baums ist die Höhe der Wurzel.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-4
1
15.1 Suchbäume
15.1 Suchbäume
Klassifikation von Suchbäumen
Anzahl m der Kinder pro Knoten/Knotengrad:
□ Binärbaum: Anzahl 0 ≤ m ≤ 2
□ Vielwegbaum: Anzahl beliebig
Speicherort der Nutzdaten:
□ Blattbaum/hohler Baum: Nutzdaten werden nur in den Blattknoten gespeichert. Innere Knoten dienen nur der Verzweigung.
□ Natürlicher Baum: Nutzdaten werden bei jedem Knoten
gespeichert.
Übliche Verwendung
Zur Implementierung von Mengen im Hauptspeicher werden
üblicherweise natürliche und ausgewogene Binärbäume
verwendet.
verwendet
Zur Implementierung von Mengen auf Hintergrundspeicher
präferiert man hohle und ausgewogene Vielwegbäume.
mehr dazu in der Vorlesung „Datenbanksysteme“
Ausgewogenheit/Ausgeglichenheit:
□ Ausgewogener/ausgeglichener/balancierter Baum:
Für alle Knoten gilt: Die Höhen aller ihrer Unterbäume unterscheiden
sich höchstens um ∆ (meistens ±1)
Höhenbalance
Vollständig ausgewogen: Die Höhe des Baumes ist log(n).
□ Nicht ausgewogener Baum: Keine derartige Einschränkung.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-5
Zur Erinnerung: aus Abschnitt „12.6 Binärbaum“
Signatur BinBaum(T)
□
□
□
□
□
□
create:
bin:
l ft
left:
right:
value:
empty:
BinBaum x T x BinBaum
BinBaum
Bi
B
BinBaum
BinBaum
BinBaum
BinBaum
BinBaum
Bi B
BinBaum
BinBaum
T
Boolean
Axiome:
□
□
□
□
□
A1:
A2:
A3:
A4:
A5:
left(bin(x,b,y)) = x
right(bin(x,b,y)) = y
value(bin(x,b,y)) = b
empty(create) = true
empty(bin(x,b,y)) = false
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-7
© Michael Philippsen
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-6
Zur Erinnerung: aus Abschnitt „12.6 Binärbaum“
Signatur SuchBaum(T), T mit Ordnungsrelation:
□ create:
BinTree
□ insert: T x BinTree
BinTree
□ find:
find
T x BinTree
Bool
□ delete T x BinTree
BinTree
Signaturen bin, left, right, value und empty des (normalen)
Binärbaums werden verborgen.
Ein ADT-Benutzer kann nur mit insert und delete auf dem Baum
arbeiten
arbeiten.
Zur Implementierung von insert und delete können die Signaturen
des normalen Binärbaums verwendet werden, solange
sichergestellt ist, dass sowohl insert als auch delete die
Eigenschaft „binärer Suchbaum“ erhält.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-8
2
15.2 Menge als Suchbaum
15.2 Menge als Suchbaum
Die eigentliche Funktionalität zur Manipulation der Menge
findet sich in der Klasse TreeSet<Type>, die als Datenstruktur
einen Binärbaum verwendet:
Imperative Impl. einer Menge im Hauptspeicher
Binärer Suchbaum mit Knotenklasse Entry:
Speicherung der Mengenelemente in den Baumknoten.
class Entry {
Entry left;
// linker Nachfolger
Entry right; // rechter Nachfolger
Entry parent; // Elternknoten
Type value;
Doppelte
Verzeigerung:
parent
// Nutzdaten
public Entry(Type o, Entry parent) {
left = right = null;
value = o;
this.parent = parent;
}
}
public class TreeSet<Type extends Comparable<Type>>
implements java.util.Set<Type> {
// Wurzel des Binärbaums
Entry root;
parent
public TreeSet() {
root = null;
}
...
left right
nicht für alle Verwendungen nötig; aber
vieles (z.B. Iterator)
wird leichter
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-9
15.2 Menge als Suchbaum
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-10
15.2 Menge als Suchbaum
Rekursive Suche
Suchen eines Elements
Suche 13
13<14 daher
Abstieg nach links
7<13 daher
Abstieg nach rechts
public boolean contains(Object o) {
return treeContains(o, root);
}
14
7
4
24
13
20
38
// Element suchen durch Abstieg im Baum
private boolean treeContains(Object o, Entry node) {
if (node == null) return false;
int result = node.value.compareTo((Type)o);
5
Das minimale
Element befindet
sich immer
„ganz links“ im Baum.
while (node.left != null) {
node = node.left
}
return node.value;
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-11
© Michael Philippsen
// redundant
if (result == 0) return true;
if (result > 0) {
return treeContains(o, node.left);
} else {
return treeContains(o, node.right);
}
zusammenfassen
mit Hilfsvariable
Hilfsvariable,
Rechtsrekursion,
Transformation in
iterative Form
}
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-12
3
15.2 Menge als Suchbaum
15.2 Menge als Suchbaum
Iterative Suche
Einfügen eines Elements
Grundidee am Beispiel des Einfügens von
public boolean contains(Object o) {
Entry node = root;
while
hil (
(node
d !
!= null)
ll) {
int result = node.value.compareTo((Type)o);
if (result == 0) return true;
if (result > 0) {
Effizienter: Typwandlung nur
node = node.left;
einmal vor der Schleife.
} else {
node = node.right;
}
}
return false;
}
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-13
12<14 daher
Abstieg nach links
7<12 daher
Abstieg nach rechts
12<13 daher neuer
li k N
linker
Nachfolger
hf l
12
Implementierung wie
Suche. Wenn dabei
14
der einzufügende Wert
gefunden wird
false
7
24
Sonst: Neuen Knoten
4
13 20 38 als neuen Nachfolger
des letzten Blatts ein12
t
tragen.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-14
15.2 Menge als Suchbaum
15.2 Menge als Suchbaum
Iteratives Einfügen
Einfügen eines Elements
Grundidee am Beispiel des Einfügens von 12
public boolean containsadd(Type o) {
if (root == null) {
// Sonderfall Einf. in leeren Baum
root = new Entry(o, null);
return
t
t
true;
}
Entry node = root;
Entry schlepp = null; // Schleppzeiger
int result = 0;
while (node != null) {
result = node.value.compareTo(o);
if (result == 0) return truefalse;
schlepp = node;
// zeigt auf letzten Knoten
if (result > 0)
node = node.left;
else
node = node.right;
}
// schlepp zeigt auf Blatt, an das anzuhängen ist.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-15
© Michael Philippsen
node 14
schlepp --node 7
schlepp 14
node 13
schlepp 7
node --schlepp
hl
13
14
7
4
24
13
20
38
node == null
beendet Schleife
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-16
4
15.2 Menge als Suchbaum
15.2 Menge als Suchbaum
Iteratives Einfügen
Löschen eines Elements
// schlepp zeigt auf Blatt, an das anzuhängen ist.
// Neuen Knoten an Blatt anfügen.
Entry
y neu = new Entry(o,
y
schlepp);
pp
if (result > 0) { // result hat Ergebnis des letzten Vergl.
schlepp.left = neu;
} else {
schlepp.right = neu;
}
return falsetrue;
1. Suche (wie oben) den zu löschenden Knoten im Baum
2. Entfernen des Knotens:
nicht gezeigt: Suche
□ Fall
F ll 1
1: Lö
Löschen
h von Bl
Blattknoten
ttk t
schlepp
node
}
Übung: implementieren Sie das Einfügen rekursiv.
Berechnung der
Kinderlosigkeit setzt
nebenbei die Variable
kind (für den Fall 2).
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-17
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-18
15.2 Menge als Suchbaum
15.2 Menge als Suchbaum
Fall 2: Löschen von Knoten mit nur einem Nachfolger
Löschen eines Blattknotens am Beispiel
schlepp
node
14
7
4
14
24
13
20
7
38
4
kind
24
13
20
12
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-19
© Michael Philippsen
mit Schleppzeiger.
...
Entry kind = node.left;
if (kind == null) {
kind = node.right;
}
if (kind == null) { // node ist kinderlos
if (schlepp.left == node) {
schlepp.left = null;
} else {
schlepp.right = null;
}
node.parent = null;
return true;
} else if ...
38
... else if (
(node.left == null)
|| (node.right == null)) {
// node hat genau ein Kind
ki d
kind.parent
t = schlepp;
hl
adjustParentship(node, kind);
return true;
}
...
// Elterneintrag von zu löschendem Eintrag anpassen.
private void adjustParentship(Entry oldparent, Entry kid) {
if (
(oldparent
p
== root)
) {
root = kid;
} else if (oldparent.parent.left == oldparent) {
oldparent.parent.left = kid; // node LinksKind v.schlepp
} else {
//
kid LinksKind v.schlepp
oldparent.parent.right = kid; // node RechtsKind v.schlepp
} }
//
kid neues RechtsKind
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-20
5
15.2 Menge als Suchbaum
15.2 Menge als Suchbaum
Fall 3: Löschen von inneren Knoten mit 2 Nachfolgern
Löschen eines Knotens mit Einzelkind am Beispiel
Beispiel: Lösche Knoten 24
14
14
7
4
24
13
14
20
7
38
4
7
24
12
20
4
38
24
13
6
12
16
15
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-21
15.2 Menge als Suchbaum
14
4
24
13
6
16
15
20
23
21
Keines der Blätter
38
31
6
15
21
31
21
40
33
Bedingungen für Ersatz x von Knoten 24 :
(da rechter Nachfolger von 14)
□ x ≥ 14
□ 20 ≤ x ≤ 38
□ 23 ≤ x ≤ 31
40
(da 20 linker und 38 rechter Nachfolger wird)
(da 23 größter Nachfolger von 20 und
31 kleinster Nachfolger von 38 ist)
(da 20 linker und 38 rechter Nachfolger wird)
(da 23 größter Nachfolger von 20 und
31 kleinster Nachfolger von 38 ist)
mögliche Lösung
14
33
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-23
© Michael Philippsen
23
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-22
33
passt!
p
40
Bedingungen für Ersatz x von Knoten 24 :
□ x ≥ 14
(da rechter Nachfolger von 14)
□ 20 ≤ x ≤ 38
□ 23 ≤ x ≤ 31
38
15.2 Menge als Suchbaum
Welcher Knoten tritt an die Stelle von 24 ?
7
20
Wäh d es iin d
Während
den Fäll
Fällen 1 und
d2
klar war, was zu tun ist und nur das
Zeiger-Umhängen technische
Mühe gemacht hat, braucht man
hier eine Idee: Was macht man mit
den zwei Nachfolgern des zu
löschenden Knotens?
7
4
24
13
6
16
15
20
23
21
14
lösche 24
7
4
38
31
33
40
23
13
6
16
20
21
38
31
15
40
33
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-24
6
15.2 Menge als Suchbaum
15.2 Menge als Suchbaum
Bedingungen für Ersatz x von Knoten 24 :
(da rechter Nachfolger von 14)
□ x ≥ 14
□ 20 ≤ x ≤ 38
□ 23 ≤ x ≤ 31
4
andere Lösung
6
16
15
20
23
31
21
7
4
38
40
33
linker Unterbaum
14
lösche 24
24
13
Ersetze zu löschenden Knoten durch den größten Knoten im
linken Unterbaum (folgender Code) oder durch den kleinsten
Knoten im rechten Unterbaum (beide haben maximal einen
Nachfolger).
(da 20 linker und 38 rechter Nachfolger wird)
(da 23 größter Nachfolger von 20 und
31 kleinster Nachfolger von 38 ist)
14
7
Allgemein
31
13
6
20
23
16
15
38
33
40
21
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-25
15.2 Menge als Suchbaum
Fall 3: Löschen von Knoten mit zwei Nachfolgern
...
schlepp Entry maxLeft = node.left;
node
d
Wertkopie
evtl.:
maxLeft
if (maxLeft.right == null) {
// Sonderfall: linker Nachf. von node
// hat selbst keinen rechten Nachfolger
// Übung! (Benötigt adjustParentship)
} else {
while (maxLeft.right != null) {
maxLeft = maxLeft.right;
}
// Umhängen des evtl. linken Nachfolgers
if (maxLeft.left != null) {
maxLeft.parent.right
L ft
t i ht = maxLeft.left;
L ft l ft
maxLeft.left.parent = maxLeft.parent;
} else {
maxLeft.parent.right = null;
}
node.value = maxLeft.value;
}
...
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-27
© Michael Philippsen
zu löschender Knoten
größter Knoten im linken
Teilbaum, hat max.
einen Nachfolger
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-26
15.2 Menge als Suchbaum
Aufwandsbetrachtung
Suchen: Bei Ausgewogenheit spiegelt der Suchbaum die
Binärsuche strukturell wider.
□ Suchen in O(Höhe) = O(log2n) bei ausgewogenen Bäumen.
Einfügen: add() entspricht einem Einfügeschritt in einer
Sortierprozedur mit O(log2n). Wiederholtes Einfügen ist daher
effektiv eine Sortierprozedur mit einem Aufwand in O(n·log2n) bei
n Elementen (man spricht von Baumsortieren).
□ Einfügen in O(Höhe) = O(log2n) bei ausgewogenen Bäumen.
Löschen:
□ Löschen in O(Höhe) = O(log2n) bei ausgewogenen Bäumen.
Lesen in Sortierreihenfolge: next() leistet dies bei der
Traversierung.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-28
7
Zur Erinnerung aus „10.1 Charakterisierung von Aufwänden“
Zur Erinnerung aus „10.1 Charakterisierung von Aufwänden“
Suchbäume – Einfügereihenfolge bedingt Aussehen
Suchbäume – Einfügereihenfolge bedingt Aussehen
5 4 3 2
Höhenunterschiede aller Unterbäume, z.B.
5
Knoten 5: h(4)=2,
h(4) 2, h(null)
h(null)=-1
1
±3
4
nicht ausgewogener Baum
4 2 5 3
4
2
5
3
2 4 3 5
2
4
3
Höhenunterschiede aller Unterbäume, z.B.
Knoten 4: h(2)=1
h(2)=1, h(5)=0
±1
Knoten 2: h(null)=-1, h(3)=0
±1
Ausgewogener Baum, da rechte und
linke Unterbäume stets etwa die
gleiche Höhe (max. ±1) haben.
Sogar vollständig ausgewogener Baum.
Höhenunterschiede aller Unterbäume, z.B.
Knoten 4: h(3)=0, h(5)=0
0
Knoten 2: h(null)=-1, h(4)=1
±2
nicht ausgewogener Baum.
5
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-29
extremer Fall, da vorsortierte Eingabe.
Suchen, Einfügen und Löschen haben
Aufwand O(n).
3
2
4 3 2 5
4
3
5
ausgewogener Baum.
vollständig ausgewogener Baum.
2
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-30
15.3 AVL-Bäume
15.3 AVL-Bäume
Ausgewogenheit bei Bäumen
Ziel: Herstellen von Ausgewogenheit:
Möglichkeit 1: Reorganisation: Alle Elemente aus einem
unausgewogenen Baum
B
auslesen,
l
di
diese d
dann so umordnen,
d
dass die neu sortierte Folge beim Einfügen in einen frischen
Baum Ausgewogenheit liefert.
aufwändig
Bestimmung der Höhe eines Knotens
Möglichkeit 2: Ausgewogenheit schon bei jedem Einfügen
eines Elements durch lokalen Umbau des Baums sichern.
besser
Balancefaktor eines Knotens v = Differenz zwischen der Höhe des
linken Unterbaums und der Höhe des rechten Unterbaums.
3/0
Höhe/Balancefaktor
2/0
1/1
Baum nicht
ausgewogen!
2/-2
1/-1
1/
1
1/1
0/0
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-31
© Michael Philippsen
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-32
8
15.3 AVL-Bäume
15.3 AVL-Bäume
Bestimmung der Höhe eines Knotens
Bestimmung der Höhe eines Knotens
Induktionsannahme: Höhe und Balancefaktor eines Blattes sind 0
Induktionshypothese: Höhe und Balancefaktoren von
Binärbäumen mit <n Knoten können berechnet werden
werden.
Induktionsschluss:
□ Betrachte die Wurzel eines Baums mit n Knoten.
□ Die Unterbäume haben <n Knoten. Laut Induktionshypothese können
deren Höhen und Balancefaktoren berechnet werden.
□ Die Höhe der Wurzel lässt sich dann bestimmen:
Höhe der Wurzel = 1+max(Höhe
(
linker Unterbaum,, Höhe
rechter Unterbaum)
Balancefaktor d. Wurzel: Höhe linker Unterbaum - Höhe
rechter Unterbaum
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-33
Aufwandsüberlegung:
Berechnung für den ganzen Baum:
□ Di
Die resultierende
lti
d rekursive
k i IImplementierung
l
ti
steigt
t i t bi
bis zu d
den Blätt
Blättern
ab und berechnet dann Höhe und Balancefaktoren „von unten nach
oben“ im Baum.
□ Jeder Knoten wird dabei einmal besucht: O(n)
Korrektur bei einer Änderung:
□ Nimmt man an einem Blatt eine Änderung vor (Hinzufügen eines
neuen Nachfolgers, oder Löschen des Blatts), dann ändern sich die
Höhenangaben und Balancefaktoren nur auf den Knoten, die auf dem
Pfad von der Änderungsstelle zur Wurzel liegen.
□ Die Korrektur nach einer Änderung hat daher bei ausgewogenen
Bäumen den Aufwand O(log2n).
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-34
15.3 AVL-Bäume
15.3 AVL-Bäume
Korrektur bei einer Änderung
AVL-Bäume
AVL-Bedingung:
3/0
===
3/0
Höhe/Balancefaktor
2/1
2/0
===
1/1
von der Änderung
b t ff
betroffene
Baumteile
B
t il
| h(e.links) - h(e.rechts) | ≤ 1
2/-2
0/0
===
1/-1
□ Sei e beliebiger Knoten eines binären Suchbaumes, und h(e) die
Höhe des Unterbaums mit Wurzel e,
e dann gilt für die beide Kinder
e.links und e.rechts von e:
1/1
Ein binärer Suchbaum mit dieser Eigenschaft heißt AVL-Baum
(nach Adel’son-Vel’skii und Landis, 1962), erste Datenstruktur, die
im schlechtesten Fall einen Aufwand O(log2n) für Einfügen,
Löschen und Suchen hatte.
0/0
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-35
© Michael Philippsen
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-36
9
15.3 AVL-Bäume
15.3 AVL-Bäume
AVL-Bäume sind nicht immer vollständig ausgewogen.
Beispiel:
5
3
2
4
1
-erfüllt AVL-Eigenschaft
-nicht
nicht vollständig ausgewogen
8
11
6
7
10
Operationen auf AVL-Bäumen
□ Suchen: wie bei binärem Suchbaum
□ Einfügen:
Z ä h t wie
Zunächst
i b
beii bi
binärem
ä
S
Suchbaum
hb
Dann Wiederherstellen der AVL-Eigenschaft
Rebalancierung
□ Löschen:
Zunächst wie bei binärem Suchbaum
Dann Wiederherstellen der AVL-Eigenschaft
(eventuell mehrfach).
12
9
Rebalancierung
Für die Höhe h eines AVL-Baums mit n Knoten gilt:
log2(n+1) ≤ h < 1,441 log2(n+2)
Im Vergleich zum vollständig ausgewogenen Binärbaum (mit
minimaler Höhe) ist der AVL-Baum also höchstens ~44% höher.
Alle Operationen bleiben daher vom Aufwand in O(log2n).
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-37
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-38
15.3 AVL-Bäume
15.3 AVL-Bäume
Einfügen in AVL-Bäume
Einfügen in AVL-Bäume
1. Einfügen wie in „normale“ binäre Suchbäume, O(log2n).
Zwei Möglichkeiten für Fall c (weitere symmetrische Fälle ignoriert):
C
C
A
Fall a: Neuer Knoten wird unten an ein Blatt aus
Unterbaum C oder C'
C angefügt. Baum bleibt in
AVL-Form.
C'
C
A
Beide Formen symmetrisch
Fall b: neuer Knoten wird unten an ein Blatt aus
Unterbaum C angefügt. Baum bleibt in AVL-Form.
Fall c: neuer Knoten wird unten an ein Blatt aus
Unterbaum A angefügt. Baum wird unausgewogen.
2. Um festzustellen, dass Fall c vorliegt, Neuberechnen der
Balancefaktoren auf dem Pfad vom neuen Knoten zur Wurzel,
O(log2n).
3. Rebalancieren, falls ein Knoten mit Balancefaktor bf ≥2 entsteht.
Wir zeigen, dass dies mit konstantem Aufwand O(1) möglich ist.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-39
© Michael Philippsen
Fall c1:
x
y
C
A
Fall c2:
z
y
D
B
neu
x
C
A
z
D
B
neu
Durch Einfügen von "neu" wird der Balancefaktor bf(x)>1.
Zu großer Balancefaktor
an äußerem Teilbaum,
bf-Vorzeichen bleibt.
Zu großer Balancefaktor
an innerem Teilbaum,
bf-Vorzeichen wechselt.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-40
10
15.3 AVL-Bäume
15.3 AVL-Bäume
Rebalancieren im Fall c1
vorher:
nachher:
x
y
z
y
x
Rebalancieren im Fall c2
vorher:
Idee von Fall c1 klappt nicht: nach oben ziehen
x
und restliche Knoten „einseitig“ anbauen ist
y
z
nicht möglich
möglich, weil es kleinere Werte (in A) und
z
größere Werte (in C,D) gibt.
C
A
A
D
B
B
C
neu
neu
wieder
ausgewogen
D
C
A
D
Betrachte „Vergrößerung“:
x
y
w
B
neu
y wird
i d neue W
Wurzell d
des U
Unterbaums,
t b
d
der K
Knoten
t x und
dB
Baum B
müssen aufgrund der Suchbaumeigenschaft ihre Lage ändern.
x
y
y
Rotation
CD
A
x
Konstante Anzahl von Referenzänderungsschritten.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-41
Beispiel
w
4
x
add(7)
5
B1
A
B2
B2
w
Rotation
ausgewogen
5
w
y
4
w
x
Rotation
x
y
Doppelrotation; konstante Anzahl von Referenzänderungsschritten.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-43
© Michael Philippsen
4
7
add(2)
7 0/0
w wird neue Wurzel des Unterbaums, die ehemalige Wurzel x
wird in Richtung des niedrigeren Teilbaums CD verschoben
verschoben.
x
1
5 1/ -1
5
Rotation
CD wieder
neu
neu
gleiches
Vorzeichen
4 2/ -2
CD
y
neu
15.3 AVL-Bäume
Rebalancieren im Fall c2
x
vorher: y
nachher: y
w
B1
B2
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-42
15.3 AVL-Bäume
A
B1
Falls „neu“ an B1 erfolgt das
Rebalancieren genau gleich.
2
7
OK
5
add(1)
2/2 4
7
Rotation
1/1 2
0/0 1
Vom neuen Knoten
kommend ist 4 der erste
unausgewogene Knoten.
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-44
11
15.3 AVL-Bäume
15.3 AVL-Bäume
Beispiel
Beispiel
5
5
Rotation
2/2
2/
24
2
7
1
1/1 2
7
add(3)
dd(3)
5
2/-1
4
0/0 1
0/0 1
2
7 0/0
2
4
3/2
4 1/1
1
4
5
3
7
2
Doppelrotation
1
3
6
5
7
6
3 0/0
4
Doppelrotation
2
1
add(6)
5
3
7
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-45
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-46
15.3 AVL-Bäume
Weitere Eigenschaften von AVL-Bäumen
Nachteile
□ Zusätzlicher Platzbedarf in den Knoten zur Speicherung der
Höhe oder der Balancefaktoren.
Balancefaktoren (Der andere Wert kann leicht
berechnet werden, weil die Änderungsoperation vom Blatt in
Richtung Wurzel läuft.)
□ Komplizierte Implementierung. Programmieren Sie einen AVLBaum!
Lustig:
fib(h+3) 1 ≤ n < 2h+1-1
fib(h+3)-1
1
Fibonacci-Zahlen tauchen immer wieder mal überraschend
auf ☺
Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-47
© Michael Philippsen
12