Algorithmik 1

Algorithmik 1
Prof. Dr. Michael Philippsen
Friedrich-Alexander-Universität
Erlangen-Nürnberg
Informatik 2 • Programmiersysteme
Martensstraße 3 • 91058 Erlangen
Organisatorisches
Evaluation der Lehre
Unmittelbar vor der Vorlesung … Gerücht „Super-GAU“
Näheres später …
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-2
M. Philippsen
Kapitel 16 - Bäume
16.1
16.2
16.3
Suchbäume
Menge als Suchbaum
AVL-Bäume
Handy aus!
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-3
M. Philippsen
16.1 Suchbäume
Effizientes Suchen
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-undHerrsche-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
Werte
<v
Werte
>v
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-4
M. Philippsen
16.1 Suchbäume
Beispiel:
4
7
13 14 20 24 38
Binärer Suchbaum
2
1
h=2
0
14
7
4
24
13
20
Die Höhe h eines Knotens entspricht der Anzahl
der Kanten des längsten Pfades zu einem von
diesem Knoten aus erreichbaren Blatt (= Knoten
ohne Nachfolger)
Die Höhe h eines Baums ist die Höhe der Wurzel.
38
Bei Graphen wird
i.A. eine andere
Def. der Höhe verwendet.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-5
M. Philippsen
16.1 Suchbäume
Klassifikation von Suchbäumen
Anzahl 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 des Baums dienen nur der Verzweigung.
Natürlicher Baum: Nutzdaten werden bei jedem Knoten gespeichert.
Ausgewogenheit/Ausgeglichenheit:
ausgewogener/balancierter Baum: Für jeden Knoten unterscheiden sich
die Höhen der Unterbäume nur um höchstens 1.
nicht ausgewogener Baum: Es gibt keine derartige Einschränkung.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-6
M. Philippsen
16.1 Suchbäume
Übliche Verwendung:
zur Implementierung von Mengen im Hauptspeicher werden
üblicherweise natürliche und ausgewogene Binärbäume verwendet.
zur Implementierung von Mengen auf Hintergrundspeicher präferiert
man hohle und ausgewogene Vielwegbäume.
mehr dazu in der Vorlesung „Systemprogrammierung 2“
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-7
M. Philippsen
Zur Erinnerung: aus Abschnitt „10.6 Binärbaum“
Signatur BinBaum(T)
create:
bin:
left:
right:
value:
empty:
BinBaum x T x BinBaum
BinBaum
BinBaum
BinBaum
BinBaum
BinBaum
BinBaum
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
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Wiederholungsfolie
M. Philippsen
Zur Erinnerung: aus Abschnitt „10.6 Binärbaum“
Signatur SuchBaum(T), T mit Ordnungsrelation:
create:
insert:
find:
delete
T x BinTree
T x BinTree
T x BinTree
BinTree
BinTree
Bool
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.
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.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Wiederholungsfolie
M. Philippsen
16.2 Menge als Suchbaum
Imperative Implementierung einer Menge im Hauptspeicher
Binärer Suchbaum mit Knotenklasse Entry:
Speicherung der Mengenelemente in den Baumknoten
class Entry {
Entry left;
Entry right;
Entry parent;
Object value;
// linker Nachfolger
// rechter Nachfolger
// Elternknoten
// Nutzdaten
public Entry(Object o, Entry parent) {
left = right = null;
value = o;
this.parent = parent;
}
}
Doppelte
Verzeigerung:
parent
parent
left right
nicht für alle Verwendungen nötig; aber
vieles (z.B. Iterator)
wird leichter
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-10
M. Philippsen
16.2 Menge als Suchbaum
Die eigentliche Funktionalität zur Manipulation der Menge findet sich in
der Klasse TreeSet, die als Datenstruktur einen Binärbaum
verwendet:
public class TreeSet implements java.util.Set {
// Wurzel des Binärbaums
Entry root;
public TreeSet() {
root = null;
}
...
//redundant
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-11
M. Philippsen
16.2 Menge als Suchbaum
Suchen eines Elements:
Suche 13
13<14 daher
Abstieg nach links
7<13 daher
Abstieg nach rechts
14
7
4
24
13
38
en
nd
fu
ge
5
20
Das minimale
while (node.left != null) {
Element befindet
node = node.left
}
sich immer
"ganz links" im Baum return node.value;
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-12
M. Philippsen
16.2 Menge als Suchbaum
Rekursive Suche
public boolean contains(Object o) {
return treeContains(o, root);
}
// Element suchen durch Abstieg im Baum
private boolean treeContains(Object o, Entry entry) {
if (entry == null) return false;
int result = ((Comparable)entry.value).compareTo(o);
if (result == 0) return true;
if (result > 0) {
return treeContains(o, entry.left);
} else {
return treeContains(o, entry.right);
}
zusammenfassen
mit Hilfsvariable,
Rechtsrekursion,
Transformation in
iterative Form
}
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-13
M. Philippsen
16.2 Menge als Suchbaum
Iterative Suche
public boolean contains(Object o) {
Entry node = root;
while (node != null) {
int result = ((Comparable)entry.value).compareTo(o);
if (result == 0) return true;
if (result > 0) {
node = node.left;
} else {
node = node.right;
}
}
return false;
}
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-14
M. Philippsen
16.2 Menge als Suchbaum
Einfügen eines Elements:
Grundidee am Beispiel des Einfügens von
12<14 daher
Abstieg nach links
7<12 daher
Abstieg nach rechts
12<13 daher neuer
linker Nachfolger
12
Implementierung wie
Suche. Wenn dabei
14
der einzufügende Wert
gefunden wird
Fehler
7
24
Sonst: Neuen Knoten
4
13 20 38 als neuen Nachfolger
des letzten Blatts ein12
tragen.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-15
M. Philippsen
16.2 Menge als Suchbaum
Iteratives Einfügen (1)
public boolean containsadd(Object o) {
if (root == null) { //Sonderfall Einfügen in leeren Baum
root = new Entry(o, null);
return true;
}
Entry node = root;
Entry schlepp = null; //Schleppzeiger
int result = 0;
while (node != null) {
result = ((Comparable)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.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-16
M. Philippsen
16.2 Menge als Suchbaum
Einfügen eines Elements:
Grundidee am Beispiel des Einfügens von
node 14
schlepp --node 7
schlepp 14
node 13
schlepp 7
node --schlepp 13
12
14
7
4
24
13
20
38
node == null
beendet Schleife
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-17
M. Philippsen
16.2 Menge als Suchbaum
Iteratives Einfügen (2)
//schlepp zeigt auf Blatt, an das anzuhängen ist.
//Neuen Knoten an Blatt anfügen.
if (result > 0) { //result hat Ergebnis des letzten Vergl.
schlepp.left = o;
} else {
schlepp.right = o;
}
o.parent = schlepp;
return falsetrue;
}
Übung: implementieren Sie das Einfügen rekursiv.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-18
M. Philippsen
16.2 Menge als Suchbaum
Löschen eines Elements
1. Suche (wie oben) den zu löschenden Knoten im Baum
2. Entfernen des Knotens:
nicht gezeigt:
Fall 1: Löschen von Blattknoten
Löschen der Wurzel.
...
schlepp Entry kind = node.left;
boolean hasLeftKid = true;
if (kind == null) {
node
hasLeftKid = false;//kein linkes Kind
kind = node.right;
}
if (kind == null) { //node ist kinderlos
if (schlepp.left == node)
Berechnung der
schlepp.left = null;
Kinderlosigkeit scheint
else
übertrieben, sie
schlepp.right = null;
node.parent = null;
hilft aber in Fall 2.
return true;
}
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-19
M. Philippsen
...
16.2 Menge als Suchbaum
Löschen eines Blattknotens am Beispiel
14
7
4
14
24
13
20
7
38
4
24
13
20
38
12
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-20
M. Philippsen
16.2 Menge als Suchbaum
Fall 2: Löschen von Knoten mit nur einem Nachfolger
schlepp
node
kind
...
else if (
(node.left == null)
|| (node.right == null)) {
//node hat genau ein Kind
kind.parent = schlepp;
adjustParentship(node,kind);
return true;
}
...
// Elterneintrag von zu löschendem Eintrag anpassen.
private void adjustParentship(Entry oldparent, Entry kid) {
if (oldparent == 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
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-21
M. Philippsen
16.2 Menge als Suchbaum
Löschen eines Knotens mit Einzelkind am Beispiel
14
7
4
14
24
13
20
7
38
4
24
12
20
38
12
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-22
M. Philippsen
16.2 Menge als Suchbaum
Fall 3: Löschen von inneren Knoten mit 2 Nachfolgern
Beispiel: Lösche Knoten 24
14
7
4
24
13
6
20
16
15
23
38
31
21
40
Während es in den Fällen 1 und 2
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?
33
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-23
M. Philippsen
16.2 Menge als Suchbaum
Welcher Knoten tritt an die Stelle von 24 ?
14
7
4
24
13
6
20
16
15
23
21
Keines der Blätter
6
38
31
15
21
33
40 passt!
40
33
Bedingungen für Ersatz x von Knoten 24 :
x ≥ 14
20 ≤ x ≤ 38
23 ≤ x ≤ 31
(da rechter Nachfolger von 14)
(da 20 linker und 38 rechter Nachfolger wird)
(da 23 größter Nachfolger von 20 und
31 kleinster Nachfolger von 38 ist)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-24
M. Philippsen
16.2 Menge als Suchbaum
24 :
Bedingungen für Ersatz von Knoten
x ≥ 14
20 ≤ x ≤ 38
23 ≤ x ≤ 31
(da rechter Nachfolger von 14)
(da 20 linker und 38 rechter Nachfolger wird)
(da 23 größter Nachfolger von 20 und
31 kleinster Nachfolger von 38 ist)
14
7
4
24
13
6
16
15
14
mögliche Lösung
20
23
7
lösche 24
38
4
31
21
40
33
23
13
6
16
15
20
21
38
31
40
33
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-25
M. Philippsen
16.2 Menge als Suchbaum
24 :
Bedingungen für Ersatz von Knoten
x ≥ 14
20 ≤ x ≤ 38
23 ≤ x ≤ 31
(da rechter Nachfolger von 14)
(da 20 linker und 38 rechter Nachfolger wird)
(da 23 größter Nachfolger von 20 und
31 kleinster Nachfolger von 38 ist)
14
7
4
24
13
6
16
15
14
andere Lösung
20
23
7
lösche 24
38
4
31
21
40
33
31
13
6
16
15
20
23
38
33
40
21
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-26
M. Philippsen
16.2 Menge als Suchbaum
Allgemein:
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).
linker Unterbaum
zu löschender Knoten
größter Knoten im linken Teilbaum,
hat maximal einen Nachfolger
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-27
M. Philippsen
16.2 Menge als Suchbaum
Fall 3: Löschen von Knoten mit zwei Nachfolger
...
schlepp Entry maxLeft = node.left;
if (maxLeft.right == null) {
//Sonderfall: linker Nachfolger von node
node
//hat selbst keinen rechten Nachfolger
//Übung! (Benötigt adjustParentship)
Wertkopie
evtl.:
maxLeft
} else {
while (maxLeft.right != null)
maxLeft = maxLeft.right;
//Umhängen des evtl. linken Nachfolgers
if (maxLeft.left != null) {
maxLeft.parent.right = maxLeft.left;
maxLeft.left.parent = maxLeft.parent;
}
node.value = maxLeft.value;
}
...
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-28
M. Philippsen
16.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.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-29
M. Philippsen
Zur Erinnerung aus „13.1 Charakterisierung von Aufwänden“
Suchbäume sehen je nach Einfügereihenfolge anders aus (1)
4 2 5 3
4
2
5
3
Höhenunterschiede aller Unterbäume
±1
4: h(2)=1, h(5)=0
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.
2 4 3 5
2
4
3
5
Höhenunterschiede aller Unterbäume
4: h(3)=0, h(5)=0
0
2: h(null)=-1, h(4)=1
±2
nicht ausgewogener Baum
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-30
M. Philippsen
Zur Erinnerung aus „13.1 Charakterisierung von Aufwänden“
Suchbäume sehen je nach Einfügereihenfolge anders aus (2)
4 3 2 5
4
3
ausgewogener Baum
5
2
5 4 3 2
5
4
3
2
Höhenunterschiede aller Unterbäume
±3
5: h(4)=2, h(null)=-1
nicht ausgewogener Baum
extremer Fall, da vorsortierte Eingabe.
Suchen, Einfügen und Löschen haben
Aufwand O(n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-31
M. Philippsen
16.3 AVL-Bäume
Ausgewogenheit bei Bäumen
Ziel: Herstellen von Ausgewogenheit:
Möglichkeit 1: Reorganisation: Alle Elemente aus einem
unausgewogenen Baum auslesen, diese dann so umordnen, dass die
neu sortierte Folge beim Einfügen in einen frischen Baum
Ausgewogenheit liefert
aufwändig
Möglichkeit 2: Ausgewogenheit schon bei jedem Einfügen eines
Elements durch lokalen Umbau des Baums sichern.
besser
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-32
M. Philippsen
16.3 AVL-Bäume
Bestimmung der Höhe eines Knotens (1)
Balance-Faktor eines Knotens v = Differenz zwischen der Höhe des
linken Unterbaums und der Höhe des rechten Unterbaums.
3/0
Höhe/Balance
-Faktor
2/0
1/1
Baum nicht
ausgewogen!
2/-2
1/-1
1/1
0/0
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-33
M. Philippsen
16.3 AVL-Bäume
Bestimmung der Höhe eines Knotens (2)
Induktionsannahme: Höhe und Balance-Faktor eines Blattes sind 0
Induktionshypothese: Höhe und Balance-Faktoren von Binärbäumen
mit <n Knoten können berechnet werden.
Induktionsschluss:
Betrachte die Wurzel eines Baums mit n Knoten.
Die Unterbäume haben <n Knoten. Laut Induktionshypothese können
deren Höhen und Balance-Faktoren 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)
Balance-Faktor d. Wurzel: Höhe linker Unterbaum - Höhe rechter Unterbaum
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-34
M. Philippsen
16.3 AVL-Bäume
Bestimmung der Höhe eines Knotens (3)
Aufwandsüberlegung:
Berechnung für den ganzen Baum:
Die resultierende rekursive Implementierung steigt bis zu den Blättern ab
und berechnet dann Höhe und Balance-Faktoren „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öhenabgaben und Balance-Faktoren 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).
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-35
M. Philippsen
16.3 AVL-Bäume
Korrektur bei einer Änderung
3/0
===
3/0
Höhe/Balance
-Faktor
2/1
2/0
===
1/1
von der Änderung
betroffene Baumteile
2/-2
0/0
===
1/-1
1/1
0/0
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-36
M. Philippsen
16.3 AVL-Bäume
AVL-Bäume
AVL-Bedingung:
Sei e beliebiger Knoten eines binären Suchbaumes, und h(e) die Höhe
des Unterbaums mit Wurzel e, dann gilt für die beide Kinder e.links und
e.rechts von e:
| h(e.links) - h(e.rechts) | ≤ 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.
Suchen in AVL-Bäumen funktioniert genau wie das Suchen in
„normalen“ binären Suchbäumen.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-37
M. Philippsen
16.3 AVL-Bäume
Einfügen in AVL-Bäume (1)
1. Einfügen wie in „normale“ binäre Suchbäume, O(log2n)
C
A
C
Fall a: Neuer Knoten wird unten an ein Blatt aus
Unterbaum C oder 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. Ausbalancieren, falls ein Knoten mit Balancefaktor bf ≥2 entsteht.
Wir zeigen, dass dies mit konstantem Aufwand O(1) möglich ist.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-38
M. Philippsen
16.3 AVL-Bäume
Einfügen in AVL-Bäume (2)
Zwei Möglichkeiten für Fall c (weitere symmetrische Fälle ignoriert)
Fall c1:
Fall c2:
x
y
A
B
z
C
D
neu
x
y
A
B
C
z
D
neu
Durch Einfügen von "neu" wird der Balance-Faktor bf(x)>1
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-39
M. Philippsen
16.3 AVL-Bäume
Ausbalancieren im Fall c1
vorher:
nachher:
x
y
A
B
y
z
C
D
A
x
B
C
z
D
neu
neu
wieder
ausgewogen
y wird neue Wurzel des Unterbaums, der Knoten x und Baum B
müssen aufgrund der Suchbaumeigenschaft ihre Lage ändern.
y
x
Rotation
y
x
Konstante Anzahl von Referenzänderungsschritten.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-40
M. Philippsen
16.3 AVL-Bäume
Ausbalancieren im Fall c2
vorher:
x
y
z
A
B
C
Idee von Fall c1 klappt nicht: nach
oben ziehen und restliche Knoten
"einseitig" anbauen ist nicht
möglich, weil es größere Werte (in
A) und kleinere Werte (in C,D) gibt.
D
neu
Betrachte "Vergrößerung":
x
y
w
CD
A
Falls "neu" an B1 erfolgt das
Ausbalancieren genau gleich
B1
B2
neu
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-41
M. Philippsen
16.3 AVL-Bäume
Ausbalancieren im Fall c2
x
vorher:
nachher:
y
w
y
CD
A
B1
x
B1
A
B2
w
B2
CD wieder
ausgewogen
neu
neu
w wird neue Wurzel des Unterbaums, die ehemalige Wurzel x
wird in Richtung des niedrigeren Teilbaums CD verschoben.
y
x
w
Rotation
w
y
w
x
Rotation
x
y
Doppelrotation; konstante Anzahl von Referenzänderungsschritten.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-42
M. Philippsen
16.3 AVL-Bäume
Beispiel (1)
4
add(7)
5
4
5
Rotation
5
4
7
add(2)
7
5
4
2
7
5
add(1)
4
1
2
7
1
2
OK
5
Rotation
7
4
Vom neuen Knoten
kommend ist 4 der erste
unausgewogene Knoten.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-43
M. Philippsen
16.3 AVL-Bäume
Beispiel (2)
5
2
1
4
5
7
add(3)
4
2
1
7
Doppelrotation
2
1
4
5
3
7
3
4
add(6)
2
1
4
5
3
2
Doppelrotation
7
1
3
6
5
7
6
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-44
M. Philippsen
16.3 AVL-Bäume
Eigenschaften von AVL-Bäumen
Für die Höhe h eines AVL-Baums mit n Knoten gilt:
log2(n+1) ≤ h < 1,441 log2(n+2)
Im Vergleich zu dem Binärbaum mit minimaler Höhe ist der AVLBaum also höchstens ~44% höher. Alle Operationen bleiben daher
vom Aufwand in O(log2n).
Nachteile
zusätzlicher Platzbedarf in den Knoten zur Speicherung der
Balancefaktoren. (Die Kontenhöhe braucht nicht gespeichert zu werden,
weil die Änderungsoperation vom Blatt in Richtung Wurzel läuft und die
aktuelle Höhe dabei mitführen kann.)
Komplizierte Implementierung. Programmieren Sie einen AVL-Baum!
Lustig:
fib(h+3)-1 ≤ n < 2h+1-1
Fibonacci-Zahlen tauchen immer wieder mal überraschend auf ☺
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-45
M. Philippsen