Algorithmik 1 - Friedrich-Alexander-Universität Erlangen

Organisatorisches
Evaluation der Lehre
Unmittelbar vor der Vorlesung … Gerücht „Super-GAU“
Näheres später …
Algorithmik 1
Prof. Dr. Michael Philippsen
Friedrich-Alexander-Universität
Erlangen-Nürnberg
Informatik 2 • Programmiersysteme
Martensstraße 3 • 91058 Erlangen
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-2
Kapitel 16 - Bäume
16.1 Suchbäume
16.1
16.2
16.3
Effizientes Suchen
Suchbäume
Menge als Suchbaum
AVL-Bäume
M. Philippsen
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
Handy aus!
Werte
<v
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-3
Werte
>v
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-4
M. Philippsen
16.1 Suchbäume
16.1 Suchbäume
Klassifikation von Suchbäumen
Beispiel:
4
7
Anzahl der Kinder pro Knoten/Knotengrad:
13 14 20 24 38
Binärbaum: Anzahl 0 ≤ m ≤ 2
Vielwegbaum: Anzahl beliebig
Binärer Suchbaum
2
1
h=2
0
Speicherort der Nutzdaten:
14
7
4
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.
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.
Ausgewogenheit/Ausgeglichenheit:
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
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
M. Philippsen
16.1 Suchbäume
Algorithmik 1, WS 2003/04, Folie 16-6
M. Philippsen
Zur Erinnerung: aus Abschnitt „10.6 Binärbaum“
Ü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“
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:
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-7
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
M. Philippsen
Algorithmik 1, WS 2003/04, Wiederholungsfolie
M. Philippsen
Zur Erinnerung: aus Abschnitt „10.6 Binärbaum“
16.2 Menge als Suchbaum
Signatur SuchBaum(T), T mit Ordnungsrelation:
create:
insert:
find:
delete
T x BinTree
T x BinTree
T x BinTree
Imperative Implementierung einer Menge im Hauptspeicher
BinTree
BinTree
Bool
BinTree
Binärer Suchbaum mit Knotenklasse Entry:
Speicherung der Mengenelemente in den Baumknoten
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
Object value;
// linker Nachfolger
// rechter Nachfolger
// Elternknoten
Doppelte
Verzeigerung:
parent
// Nutzdaten
public Entry(Object o, Entry parent) {
left = right = null;
value = o;
this.parent = 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, Wiederholungsfolie
M. Philippsen
16.2 Menge als Suchbaum
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;
Suchen eines Elements:
Suche 13
13<14 daher
Abstieg nach links
7<13 daher
Abstieg nach rechts
//redundant
14
7
4
24
13
5
20
38
en
nd
fu
ge
public TreeSet() {
root = null;
}
...
class Entry {
Entry left;
Entry right;
Entry parent;
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-11
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-12
M. Philippsen
16.2 Menge als Suchbaum
16.2 Menge als Suchbaum
Rekursive Suche
Iterative 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
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
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-13
M. Philippsen
16.2 Menge als Suchbaum
12<14 daher
Abstieg nach links
7<12 daher
Abstieg nach rechts
12<13 daher neuer
linker Nachfolger
Iteratives Einfügen (1)
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
Einfügen eines Elements:
Grundidee am Beispiel des Einfügens von
Algorithmik 1, WS 2003/04, Folie 16-14
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
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-16
M. Philippsen
16.2 Menge als Suchbaum
16.2 Menge als Suchbaum
Iteratives Einfügen (2)
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
//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;
14
7
4
24
13
20
38
}
node == null
beendet Schleife
Übung: implementieren Sie das Einfügen rekursiv.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-17
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-18
M. Philippsen
16.2 Menge als Suchbaum
16.2 Menge als Suchbaum
Löschen eines Elements
Löschen eines Blattknotens am Beispiel
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
...
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
16.2 Menge als Suchbaum
Fall 2: Löschen von Knoten mit nur einem Nachfolger
Löschen eines Knotens mit Einzelkind am Beispiel
...
else if (
(node.left == null)
|| (node.right == null)) {
//node hat genau ein Kind
kind.parent = schlepp;
adjustParentship(node,kind);
return true;
}
...
schlepp
node
kind
// 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
14
7
4
24
13
M. Philippsen
16.2 Menge als Suchbaum
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?
38
M. Philippsen
4
24
13
6
20
16
15
23
21
33
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
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-23
20
Welcher Knoten tritt an die Stelle von 24 ?
14
7
24
6
12
16.2 Menge als Suchbaum
14
20
4
Algorithmik 1, WS 2003/04, Folie 16-22
Beispiel: Lösche Knoten 24
13
38
24
12
Fall 3: Löschen von inneren Knoten mit 2 Nachfolgern
4
20
7
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-21
7
14
(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
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-24
M. Philippsen
16.2 Menge als Suchbaum
16.2 Menge als Suchbaum
24 :
Bedingungen für Ersatz von Knoten
x ≥ 14
20 ≤ x ≤ 38
23 ≤ x ≤ 31
14
4
24
13
6
16
15
20
23
x ≥ 14
20 ≤ x ≤ 38
23 ≤ x ≤ 31
7
lösche 24
38
4
31
21
40
33
6
16
15
20
21
4
38
31
40
33
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-25
24
13
6
16
15
20
38
23
4
31
21
40
33
31
13
6
20
23
16
15
38
33
40
21
Algorithmik 1, WS 2003/04, Folie 16-26
M. Philippsen
16.2 Menge als Suchbaum
Allgemein:
Fall 3: Löschen von Knoten mit zwei Nachfolger
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).
...
schlepp Entry maxLeft = node.left;
node
zu löschender Knoten
Wertkopie
evtl.:
größter Knoten im linken Teilbaum,
hat maximal einen Nachfolger
maxLeft
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-27
7
lösche 24
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
16.2 Menge als Suchbaum
linker Unterbaum
14
andere Lösung
7
23
13
(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
14
mögliche Lösung
7
24 :
Bedingungen für Ersatz von Knoten
(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)
if (maxLeft.right == null) {
//Sonderfall: linker Nachfolger 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 = maxLeft.left;
maxLeft.left.parent = maxLeft.parent;
}
node.value = maxLeft.value;
}
...
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-28
M. Philippsen
16.2 Menge als Suchbaum
Zur Erinnerung aus „13.1 Charakterisierung von Aufwänden“
Aufwandsbetrachtung
Suchbäume sehen je nach Einfügereihenfolge anders aus (1)
Suchen: Bei Ausgewogenheit spiegelt der Suchbaum die Binärsuche
strukturell wider.
4 2 5 3
4
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:
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
Löschen in O(Höhe) = O(log2n) bei ausgewogenen Bäumen.
4
Lesen in Sortierreihenfolge: next() leistet dies bei der Traversierung.
3
Friedrich-Alexander-Universität Erlangen-Nürnberg
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-29
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-30
Zur Erinnerung aus „13.1 Charakterisierung von Aufwänden“
16.3 AVL-Bäume
Suchbäume sehen je nach Einfügereihenfolge anders aus (2)
Ausgewogenheit bei Bäumen
4 3 2 5
4
3
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
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
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
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-32
M. Philippsen
16.3 AVL-Bäume
16.3 AVL-Bäume
Bestimmung der Höhe eines Knotens (1)
Bestimmung der Höhe eines Knotens (2)
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
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
1/1
0/0
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2003/04, Folie 16-33
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-34
16.3 AVL-Bäume
16.3 AVL-Bäume
Bestimmung der Höhe eines Knotens (3)
Aufwandsüberlegung:
Korrektur bei einer Änderung
M. Philippsen
3/0
===
3/0
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)
Höhe/Balance
-Faktor
2/1
2/0
===
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
1/1
von der Änderung
betroffene Baumteile
2/-2
0/0
===
1/-1
1/1
0/0
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-36
M. Philippsen
16.3 AVL-Bäume
16.3 AVL-Bäume
AVL-Bäume
Einfügen in AVL-Bäume (1)
AVL-Bedingung:
1. Einfügen wie in „normale“ binäre Suchbäume, O(log2n)
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
C
A
Fall a: Neuer Knoten wird unten an ein Blatt aus
Unterbaum C oder C' angefügt. Baum bleibt in
AVL-Form.
C'
C
C
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.
A
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-37
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-38
M. Philippsen
16.3 AVL-Bäume
16.3 AVL-Bäume
Einfügen in AVL-Bäume (2)
Ausbalancieren im Fall c1
Zwei Möglichkeiten für Fall c (weitere symmetrische Fälle ignoriert)
Fall c1:
Fall c2:
vorher:
x
y
z
x
y
A
B
D
neu
A
B
C
B
C
D
A
D
x
neu
B
C
z
D
neu
neu
Durch Einfügen von "neu" wird der Balance-Faktor bf(x)>1
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-39
y
z
z
A
C
nachher:
x
y
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-40
M. Philippsen
16.3 AVL-Bäume
16.3 AVL-Bäume
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.
Ausbalancieren im Fall c2
vorher:
x
y
z
A
C
B
Ausbalancieren im Fall c2
x
vorher:
nachher:
y
w
CD
D
A
Betrachte "Vergrößerung":
x
y
w
neu
Falls "neu" an B1 erfolgt das
Ausbalancieren genau gleich
x
Rotation
y
Doppelrotation; konstante Anzahl von Referenzänderungsschritten.
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
Algorithmik 1, WS 2003/04, Folie 16-42
16.3 AVL-Bäume
Beispiel (1)
Beispiel (2)
add(7)
w
x
y
w
16.3 AVL-Bäume
5
w
Rotation
neu
Algorithmik 1, WS 2003/04, Folie 16-41
4
ausgewogen
neu
x
y
Friedrich-Alexander-Universität Erlangen-Nürnberg
4
CD wieder
w wird neue Wurzel des Unterbaums, die ehemalige Wurzel x
wird in Richtung des niedrigeren Teilbaums CD verschoben.
B2
B1
B2
neu
CD
A
x
B1
A
B2
B1
w
y
5
5
Rotation
5
4
M. Philippsen
7
add(2)
2
1
7
4
5
7
add(3)
4
2
1
7
Doppelrotation
2
1
4
5
3
7
3
5
4
2
7
5
add(1)
4
Rotation
1
2
7
1
2
OK
5
4
add(6)
2
1
Vom neuen Knoten
kommend ist 4 der erste
unausgewogene Knoten.
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-43
4
7
Friedrich-Alexander-Universität Erlangen-Nürnberg
M. Philippsen
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