Algorithmen und Datenstrukturen SS09

Algorithmen und Datenstrukturen SS09
Foliensatz 9
Michael Brinkmeier
Technische Universität Ilmenau
Institut für Theoretische Informatik
Sommersemester 2009
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 1 / 63
Wörterbücher
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 2 / 63
Wörterbücher
Ein Wörterbuch (Englisch: Dictionary, Synonym: dynamische Abbildung) ist
eine partielle Abbildung von einer Schlüsselmenge U in einen Wertebereich R
(engl. range).
Manchen Schlüsseln x ∈ U soll ein Wert f (x) ∈ R zugeordnet werden.
Man kann ein Wörterbuch als eine Menge von Paaren in D = U × R
auffassen, wobei jedes x ∈ U in höchstens einem Paar vorkommt.
Ein Wörterbuch soll es ermöglichen
nachzusehen, ob und welcher Wert einem Schlüssel zugeordnet ist
(lookup)
Schlüssel-Wert-Paare einzufügen, bzw. zu ersetzen (insert)
ein Paar anhand des Schlüssels zu löschen (delete)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 3 / 63
Wörterbücher
Ein Wörterbuch (Englisch: Dictionary, Synonym: dynamische Abbildung) ist
eine partielle Abbildung von einer Schlüsselmenge U in einen Wertebereich R
(engl. range).
Manchen Schlüsseln x ∈ U soll ein Wert f (x) ∈ R zugeordnet werden.
Man kann ein Wörterbuch als eine Menge von Paaren in D = U × R
auffassen, wobei jedes x ∈ U in höchstens einem Paar vorkommt.
Ein Wörterbuch soll es ermöglichen
nachzusehen, ob und welcher Wert einem Schlüssel zugeordnet ist
(lookup)
Schlüssel-Wert-Paare einzufügen, bzw. zu ersetzen (insert)
ein Paar anhand des Schlüssels zu löschen (delete)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 3 / 63
Wörterbücher
Ein Wörterbuch (Englisch: Dictionary, Synonym: dynamische Abbildung) ist
eine partielle Abbildung von einer Schlüsselmenge U in einen Wertebereich R
(engl. range).
Manchen Schlüsseln x ∈ U soll ein Wert f (x) ∈ R zugeordnet werden.
Man kann ein Wörterbuch als eine Menge von Paaren in D = U × R
auffassen, wobei jedes x ∈ U in höchstens einem Paar vorkommt.
Ein Wörterbuch soll es ermöglichen
nachzusehen, ob und welcher Wert einem Schlüssel zugeordnet ist
(lookup)
Schlüssel-Wert-Paare einzufügen, bzw. zu ersetzen (insert)
ein Paar anhand des Schlüssels zu löschen (delete)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 3 / 63
Wörterbücher
Ein Wörterbuch (Englisch: Dictionary, Synonym: dynamische Abbildung) ist
eine partielle Abbildung von einer Schlüsselmenge U in einen Wertebereich R
(engl. range).
Manchen Schlüsseln x ∈ U soll ein Wert f (x) ∈ R zugeordnet werden.
Man kann ein Wörterbuch als eine Menge von Paaren in D = U × R
auffassen, wobei jedes x ∈ U in höchstens einem Paar vorkommt.
Ein Wörterbuch soll es ermöglichen
nachzusehen, ob und welcher Wert einem Schlüssel zugeordnet ist
(lookup)
Schlüssel-Wert-Paare einzufügen, bzw. zu ersetzen (insert)
ein Paar anhand des Schlüssels zu löschen (delete)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 3 / 63
Wörterbücher
Ein Wörterbuch (Englisch: Dictionary, Synonym: dynamische Abbildung) ist
eine partielle Abbildung von einer Schlüsselmenge U in einen Wertebereich R
(engl. range).
Manchen Schlüsseln x ∈ U soll ein Wert f (x) ∈ R zugeordnet werden.
Man kann ein Wörterbuch als eine Menge von Paaren in D = U × R
auffassen, wobei jedes x ∈ U in höchstens einem Paar vorkommt.
Ein Wörterbuch soll es ermöglichen
nachzusehen, ob und welcher Wert einem Schlüssel zugeordnet ist
(lookup)
Schlüssel-Wert-Paare einzufügen, bzw. zu ersetzen (insert)
ein Paar anhand des Schlüssels zu löschen (delete)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 3 / 63
Wörterbücher
Ein Wörterbuch (Englisch: Dictionary, Synonym: dynamische Abbildung) ist
eine partielle Abbildung von einer Schlüsselmenge U in einen Wertebereich R
(engl. range).
Manchen Schlüsseln x ∈ U soll ein Wert f (x) ∈ R zugeordnet werden.
Man kann ein Wörterbuch als eine Menge von Paaren in D = U × R
auffassen, wobei jedes x ∈ U in höchstens einem Paar vorkommt.
Ein Wörterbuch soll es ermöglichen
nachzusehen, ob und welcher Wert einem Schlüssel zugeordnet ist
(lookup)
Schlüssel-Wert-Paare einzufügen, bzw. zu ersetzen (insert)
ein Paar anhand des Schlüssels zu löschen (delete)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 3 / 63
Wörterbücher
Ein Wörterbuch (Englisch: Dictionary, Synonym: dynamische Abbildung) ist
eine partielle Abbildung von einer Schlüsselmenge U in einen Wertebereich R
(engl. range).
Manchen Schlüsseln x ∈ U soll ein Wert f (x) ∈ R zugeordnet werden.
Man kann ein Wörterbuch als eine Menge von Paaren in D = U × R
auffassen, wobei jedes x ∈ U in höchstens einem Paar vorkommt.
Ein Wörterbuch soll es ermöglichen
nachzusehen, ob und welcher Wert einem Schlüssel zugeordnet ist
(lookup)
Schlüssel-Wert-Paare einzufügen, bzw. zu ersetzen (insert)
ein Paar anhand des Schlüssels zu löschen (delete)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 3 / 63
Die Signatur Dictionary
Die Signatur Dictionary
Sorten:
Keys
Elements
Dictionary
Operationen:
empty: → Dictionary
lookup: Dictionary × Keys → Elements
insert: Dictionary × Keys × Elements → Dictionary
delete: Dictionary × Keys → Dictionary
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 4 / 63
Die Signatur Dictionary
Die Signatur Dictionary
Sorten:
Keys
Elements
Dictionary
Operationen:
empty: → Dictionary
lookup: Dictionary × Keys → Elements
insert: Dictionary × Keys × Elements → Dictionary
delete: Dictionary × Keys → Dictionary
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 4 / 63
Die Signatur Dictionary
Die Signatur Dictionary
Sorten:
Keys
Elements
Dictionary
Operationen:
empty: → Dictionary
lookup: Dictionary × Keys → Elements
insert: Dictionary × Keys × Elements → Dictionary
delete: Dictionary × Keys → Dictionary
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 4 / 63
Die Signatur Dictionary
Die Signatur Dictionary
Sorten:
Keys
Elements
Dictionary
Operationen:
empty: → Dictionary
lookup: Dictionary × Keys → Elements
insert: Dictionary × Keys × Elements → Dictionary
delete: Dictionary × Keys → Dictionary
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 4 / 63
Die Signatur Dictionary
Die Signatur Dictionary
Sorten:
Keys
Elements
Dictionary
Operationen:
empty: → Dictionary
lookup: Dictionary × Keys → Elements
insert: Dictionary × Keys × Elements → Dictionary
delete: Dictionary × Keys → Dictionary
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 4 / 63
Die Modellalgebra
Die Modellalgebra für Dictionary
Keys =
ˆ die nichtleere Menge U aller Schlüssel
Elements =
ˆ die nichtleere Menge R aller Werte
Dictionary =
ˆ
{f | f : S → R für ein endliches S ⊆ U}
Für die Operationen nutzen wir die relationale Formulierung partieller
Abbildungen:
Ist f eine Abbildung von S nach R, dann kann f als Teilmenge von U × R
aufgefasst werden, so dass für alle x ∈ U höchstens ein r ∈ R mit
(x, r ) ∈ f existiert.
Die Menge aller Schlüssel x, für die ein Wert r ∈ R mit (x, r ) ∈ f existiert,
heisst Definitionsbereich D(f ), d.h.
D(f ) := {x ∈ U | ∃r ∈ R : (x, r ) ∈ f } .
Für x ∈ D(f ) ist f (x) das eindeutig bestimmte r ∈ R mit (x, r ) ∈ f .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 5 / 63
Die Modellalgebra
Die Modellalgebra für Dictionary
Keys =
ˆ die nichtleere Menge U aller Schlüssel
Elements =
ˆ die nichtleere Menge R aller Werte
Dictionary =
ˆ
{f | f : S → R für ein endliches S ⊆ U}
Für die Operationen nutzen wir die relationale Formulierung partieller
Abbildungen:
Ist f eine Abbildung von S nach R, dann kann f als Teilmenge von U × R
aufgefasst werden, so dass für alle x ∈ U höchstens ein r ∈ R mit
(x, r ) ∈ f existiert.
Die Menge aller Schlüssel x, für die ein Wert r ∈ R mit (x, r ) ∈ f existiert,
heisst Definitionsbereich D(f ), d.h.
D(f ) := {x ∈ U | ∃r ∈ R : (x, r ) ∈ f } .
Für x ∈ D(f ) ist f (x) das eindeutig bestimmte r ∈ R mit (x, r ) ∈ f .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 5 / 63
Die Modellalgebra
Die Modellalgebra für Dictionary
Keys =
ˆ die nichtleere Menge U aller Schlüssel
Elements =
ˆ die nichtleere Menge R aller Werte
Dictionary =
ˆ
{f | f : S → R für ein endliches S ⊆ U}
Für die Operationen nutzen wir die relationale Formulierung partieller
Abbildungen:
Ist f eine Abbildung von S nach R, dann kann f als Teilmenge von U × R
aufgefasst werden, so dass für alle x ∈ U höchstens ein r ∈ R mit
(x, r ) ∈ f existiert.
Die Menge aller Schlüssel x, für die ein Wert r ∈ R mit (x, r ) ∈ f existiert,
heisst Definitionsbereich D(f ), d.h.
D(f ) := {x ∈ U | ∃r ∈ R : (x, r ) ∈ f } .
Für x ∈ D(f ) ist f (x) das eindeutig bestimmte r ∈ R mit (x, r ) ∈ f .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 5 / 63
Die Modellalgebra
Die Modellalgebra für Dictionary
Keys =
ˆ die nichtleere Menge U aller Schlüssel
Elements =
ˆ die nichtleere Menge R aller Werte
Dictionary =
ˆ
{f | f : S → R für ein endliches S ⊆ U}
Für die Operationen nutzen wir die relationale Formulierung partieller
Abbildungen:
Ist f eine Abbildung von S nach R, dann kann f als Teilmenge von U × R
aufgefasst werden, so dass für alle x ∈ U höchstens ein r ∈ R mit
(x, r ) ∈ f existiert.
Die Menge aller Schlüssel x, für die ein Wert r ∈ R mit (x, r ) ∈ f existiert,
heisst Definitionsbereich D(f ), d.h.
D(f ) := {x ∈ U | ∃r ∈ R : (x, r ) ∈ f } .
Für x ∈ D(f ) ist f (x) das eindeutig bestimmte r ∈ R mit (x, r ) ∈ f .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 5 / 63
Die Modellalgebra
Die Modellalgebra für Dictionary
Keys =
ˆ die nichtleere Menge U aller Schlüssel
Elements =
ˆ die nichtleere Menge R aller Werte
Dictionary =
ˆ
{f | f : S → R für ein endliches S ⊆ U}
Für die Operationen nutzen wir die relationale Formulierung partieller
Abbildungen:
Ist f eine Abbildung von S nach R, dann kann f als Teilmenge von U × R
aufgefasst werden, so dass für alle x ∈ U höchstens ein r ∈ R mit
(x, r ) ∈ f existiert.
Die Menge aller Schlüssel x, für die ein Wert r ∈ R mit (x, r ) ∈ f existiert,
heisst Definitionsbereich D(f ), d.h.
D(f ) := {x ∈ U | ∃r ∈ R : (x, r ) ∈ f } .
Für x ∈ D(f ) ist f (x) das eindeutig bestimmte r ∈ R mit (x, r ) ∈ f .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 5 / 63
Die Modellalgebra
Die Modellalgebra für Dictionary (Fortsetzung)
empty() := ∅
(
lookup(f , x) :=
f (x)
⊥
falls x ∈ D(f )
sonst
delete(f , x) :=
(
f \ {(x, f (x))}
⊥
insert(f , x, r ) :=
(
delete(f , x) ∪ {(x, r )}
f ∪ {(x, r )}
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 6 / 63
falls x ∈ D(f )
sonst
falls x ∈ D(f )
sonst
Die Modellalgebra
Die Modellalgebra für Dictionary (Fortsetzung)
empty() := ∅
(
lookup(f , x) :=
f (x)
⊥
falls x ∈ D(f )
sonst
delete(f , x) :=
(
f \ {(x, f (x))}
⊥
insert(f , x, r ) :=
(
delete(f , x) ∪ {(x, r )}
f ∪ {(x, r )}
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 6 / 63
falls x ∈ D(f )
sonst
falls x ∈ D(f )
sonst
Die Modellalgebra
Die Modellalgebra für Dictionary (Fortsetzung)
empty() := ∅
(
lookup(f , x) :=
f (x)
⊥
falls x ∈ D(f )
sonst
delete(f , x) :=
(
f \ {(x, f (x))}
⊥
insert(f , x, r ) :=
(
delete(f , x) ∪ {(x, r )}
f ∪ {(x, r )}
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 6 / 63
falls x ∈ D(f )
sonst
falls x ∈ D(f )
sonst
Die Modellalgebra
Die Modellalgebra für Dictionary (Fortsetzung)
empty() := ∅
(
lookup(f , x) :=
f (x)
⊥
falls x ∈ D(f )
sonst
delete(f , x) :=
(
f \ {(x, f (x))}
⊥
insert(f , x, r ) :=
(
delete(f , x) ∪ {(x, r )}
f ∪ {(x, r )}
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 6 / 63
falls x ∈ D(f )
sonst
falls x ∈ D(f )
sonst
Die Modellalgebra
Die Modellalgebra für Dictionary (Fortsetzung)
empty() := ∅
(
lookup(f , x) :=
f (x)
⊥
falls x ∈ D(f )
sonst
delete(f , x) :=
(
f \ {(x, f (x))}
⊥
insert(f , x, r ) :=
(
delete(f , x) ∪ {(x, r )}
f ∪ {(x, r )}
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 6 / 63
falls x ∈ D(f )
sonst
falls x ∈ D(f )
sonst
Ein Beispiel
U = Seq({a, . . . , z, A, . . . , Z }) = R
Befehl
Wörterbuch
empty()
∅
Ausgabe
insert(Homer , zuHause) {(Homer , zuHause)}
insert(Marge, zuHause)
{(Homer , zuHause), (Marge, zuHause)}
insert(Bart, Schule)
{(Homer , zuHause), (Marge, zuHause),
(Bart, Schule)}
insert(Lisa, Schule)
{(Homer , zuHause), (Marge, zuHause),
(Bart, Schule), (Lisa, Schule)}
lookup(Homer )
”
zuHause
lookup(Maggie)
”
⊥
insert(Homer , AKW )
lookup(Homer )
delete(Lisa)
{(Homer , AKW ), (Marge, zuHause),
(Bart, Schule), (Lisa, Schule)}
”
{(Homer , AKW ), (Marge, zuHause),
(Bart, Schule)}
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 7 / 63
AKW
Implementierungen
Listen/Arrays mit Einträgen aus U × R
mit Wiederholung: das erste Auftreten des Schlüssels zählt
ohne Wiederholung
Wenn U = {1, . . . , N} kann ein Array A[1 . . . N] mit Einträgen aus
R ∪ {⊥} verwendet werden.
Hashtabellen (später)
Suchbäume
Die Operationen der Array/Listen-Implementierungen benötigen die gleiche
Zeit wie die für Sets.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 8 / 63
Implementierungen
Listen/Arrays mit Einträgen aus U × R
mit Wiederholung: das erste Auftreten des Schlüssels zählt
ohne Wiederholung
Wenn U = {1, . . . , N} kann ein Array A[1 . . . N] mit Einträgen aus
R ∪ {⊥} verwendet werden.
Hashtabellen (später)
Suchbäume
Die Operationen der Array/Listen-Implementierungen benötigen die gleiche
Zeit wie die für Sets.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 8 / 63
Implementierungen
Listen/Arrays mit Einträgen aus U × R
mit Wiederholung: das erste Auftreten des Schlüssels zählt
ohne Wiederholung
Wenn U = {1, . . . , N} kann ein Array A[1 . . . N] mit Einträgen aus
R ∪ {⊥} verwendet werden.
Hashtabellen (später)
Suchbäume
Die Operationen der Array/Listen-Implementierungen benötigen die gleiche
Zeit wie die für Sets.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 8 / 63
Implementierungen
Listen/Arrays mit Einträgen aus U × R
mit Wiederholung: das erste Auftreten des Schlüssels zählt
ohne Wiederholung
Wenn U = {1, . . . , N} kann ein Array A[1 . . . N] mit Einträgen aus
R ∪ {⊥} verwendet werden.
Hashtabellen (später)
Suchbäume
Die Operationen der Array/Listen-Implementierungen benötigen die gleiche
Zeit wie die für Sets.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 8 / 63
Implementierungen
Listen/Arrays mit Einträgen aus U × R
mit Wiederholung: das erste Auftreten des Schlüssels zählt
ohne Wiederholung
Wenn U = {1, . . . , N} kann ein Array A[1 . . . N] mit Einträgen aus
R ∪ {⊥} verwendet werden.
Hashtabellen (später)
Suchbäume
Die Operationen der Array/Listen-Implementierungen benötigen die gleiche
Zeit wie die für Sets.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 8 / 63
Implementierungen
Listen/Arrays mit Einträgen aus U × R
mit Wiederholung: das erste Auftreten des Schlüssels zählt
ohne Wiederholung
Wenn U = {1, . . . , N} kann ein Array A[1 . . . N] mit Einträgen aus
R ∪ {⊥} verwendet werden.
Hashtabellen (später)
Suchbäume
Die Operationen der Array/Listen-Implementierungen benötigen die gleiche
Zeit wie die für Sets.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 8 / 63
Binäre Suchbäume
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 9 / 63
Binäre Suchbäume
(Binäre) Suchbäume implementieren den Datentyp Dictionary auf einer
total geordneten Schlüsselmenge (U, <).
Beispiel
G
4
E
7
B
9
Jeder Knoten v enthält zwei Einträge:
key(v ) ∈ U ist der Schlüssel
K
2
I
4
D
2
M
11
data(v ) ∈ R ist der Wert, bzw. sind die
Daten (oft Zeiger oder Referenz)
Def (f ) = {G , E , K , B, I , M, D} und f (B) = 9,
f (D) = 2, f (E ) = 7 . . .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 10 / 63
Binäre Suchbäume
(Binäre) Suchbäume implementieren den Datentyp Dictionary auf einer
total geordneten Schlüsselmenge (U, <).
Beispiel
G
4
E
7
B
9
Jeder Knoten v enthält zwei Einträge:
key(v ) ∈ U ist der Schlüssel
K
2
I
4
D
2
M
11
data(v ) ∈ R ist der Wert, bzw. sind die
Daten (oft Zeiger oder Referenz)
Def (f ) = {G , E , K , B, I , M, D} und f (B) = 9,
f (D) = 2, f (E ) = 7 . . .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 10 / 63
Binäre Suchbäume
Definition (Binärer Suchbaum)
(U, <) sei eine total geordnete Schlüsselmenge und R ein Wertebereich.
Ein Binärbaum T mit Einträgen aus U × R ist ein binärer Suchbaum
((U, R)-BSB oder (U, R)-BST), wenn für jeden Knoten v in T folgendes
gilt:
Ist w im linken Unterbaum von Tv , dann gilt key(w ) < key(v ).
Ist w im rechten Unterbaum von Tv , dann gilt key(w ) > key(v ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 11 / 63
Binäre Suchbäume
Definition (Binärer Suchbaum)
(U, <) sei eine total geordnete Schlüsselmenge und R ein Wertebereich.
Ein Binärbaum T mit Einträgen aus U × R ist ein binärer Suchbaum
((U, R)-BSB oder (U, R)-BST), wenn für jeden Knoten v in T folgendes
gilt:
Ist w im linken Unterbaum von Tv , dann gilt key(w ) < key(v ).
Ist w im rechten Unterbaum von Tv , dann gilt key(w ) > key(v ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 11 / 63
Binäre Suchbäume
Definition (Binärer Suchbaum)
(U, <) sei eine total geordnete Schlüsselmenge und R ein Wertebereich.
Ein Binärbaum T mit Einträgen aus U × R ist ein binärer Suchbaum
((U, R)-BSB oder (U, R)-BST), wenn für jeden Knoten v in T folgendes
gilt:
Ist w im linken Unterbaum von Tv , dann gilt key(w ) < key(v ).
Ist w im rechten Unterbaum von Tv , dann gilt key(w ) > key(v ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 11 / 63
Binäre Suchbäume
Definition (Binärer Suchbaum)
(U, <) sei eine total geordnete Schlüsselmenge und R ein Wertebereich.
Ein Binärbaum T mit Einträgen aus U × R ist ein binärer Suchbaum
((U, R)-BSB oder (U, R)-BST), wenn für jeden Knoten v in T folgendes
gilt:
Ist w im linken Unterbaum von Tv , dann gilt key(w ) < key(v ).
Ist w im rechten Unterbaum von Tv , dann gilt key(w ) > key(v ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 11 / 63
Binäre Suchbäume
Definition (Binäre Suchbäume – rekursive Definition)
1
2
ist ein (U, S)-BSB mit Schlüsselmenge S = ∅
Wenn x ∈ U und r ∈ R
und wenn T1 und T2 (U, R)-BSB sind mit Schlüsselmengen S1 und S2 ,
und wenn key(v ) < x für alle Knoten v ∈ S1
und wenn key(v ) > x für alle v ∈ S1
dann ist (T1 , (x, r ), T2 ) ein (U, R)-BSB.
3
Nichts sonst ist ein (U, R)-BSB.
Im zweiten Fall setzen wir key(T ) := x und data(T ) := t.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 12 / 63
Binäre Suchbäume
Definition (Binäre Suchbäume – rekursive Definition)
1
2
ist ein (U, S)-BSB mit Schlüsselmenge S = ∅
Wenn x ∈ U und r ∈ R
und wenn T1 und T2 (U, R)-BSB sind mit Schlüsselmengen S1 und S2 ,
und wenn key(v ) < x für alle Knoten v ∈ S1
und wenn key(v ) > x für alle v ∈ S1
dann ist (T1 , (x, r ), T2 ) ein (U, R)-BSB.
3
Nichts sonst ist ein (U, R)-BSB.
Im zweiten Fall setzen wir key(T ) := x und data(T ) := t.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 12 / 63
Binäre Suchbäume
Definition (Binäre Suchbäume – rekursive Definition)
1
2
ist ein (U, S)-BSB mit Schlüsselmenge S = ∅
Wenn x ∈ U und r ∈ R
und wenn T1 und T2 (U, R)-BSB sind mit Schlüsselmengen S1 und S2 ,
und wenn key(v ) < x für alle Knoten v ∈ S1
und wenn key(v ) > x für alle v ∈ S1
dann ist (T1 , (x, r ), T2 ) ein (U, R)-BSB.
3
Nichts sonst ist ein (U, R)-BSB.
Im zweiten Fall setzen wir key(T ) := x und data(T ) := t.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 12 / 63
Binäre Suchbäume
Definition (Binäre Suchbäume – rekursive Definition)
1
2
ist ein (U, S)-BSB mit Schlüsselmenge S = ∅
Wenn x ∈ U und r ∈ R
und wenn T1 und T2 (U, R)-BSB sind mit Schlüsselmengen S1 und S2 ,
und wenn key(v ) < x für alle Knoten v ∈ S1
und wenn key(v ) > x für alle v ∈ S1
dann ist (T1 , (x, r ), T2 ) ein (U, R)-BSB.
3
Nichts sonst ist ein (U, R)-BSB.
Im zweiten Fall setzen wir key(T ) := x und data(T ) := t.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 12 / 63
Binäre Suchbäume
Definition (Binäre Suchbäume – rekursive Definition)
1
2
ist ein (U, S)-BSB mit Schlüsselmenge S = ∅
Wenn x ∈ U und r ∈ R
und wenn T1 und T2 (U, R)-BSB sind mit Schlüsselmengen S1 und S2 ,
und wenn key(v ) < x für alle Knoten v ∈ S1
und wenn key(v ) > x für alle v ∈ S1
dann ist (T1 , (x, r ), T2 ) ein (U, R)-BSB.
3
Nichts sonst ist ein (U, R)-BSB.
Im zweiten Fall setzen wir key(T ) := x und data(T ) := t.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 12 / 63
Binäre Suchbäume
Definition (Binäre Suchbäume – rekursive Definition)
1
2
ist ein (U, S)-BSB mit Schlüsselmenge S = ∅
Wenn x ∈ U und r ∈ R
und wenn T1 und T2 (U, R)-BSB sind mit Schlüsselmengen S1 und S2 ,
und wenn key(v ) < x für alle Knoten v ∈ S1
und wenn key(v ) > x für alle v ∈ S1
dann ist (T1 , (x, r ), T2 ) ein (U, R)-BSB.
3
Nichts sonst ist ein (U, R)-BSB.
Im zweiten Fall setzen wir key(T ) := x und data(T ) := t.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 12 / 63
Inorder-Durchlauf auf Binäresn Suchbäumen
Proposition
Wenn man die Einträge eines (U, R)-BSB in Inorder-Reihenfolge ausgibt,
dann sind sie aufsteigend nach den Schlüsseln sortiert.
Beweisskizze
Die Behauptung kann mittels Induktion über den rekursiven Aufbau von
binären Suchbäumen bewiesen werden.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 13 / 63
Inorder-Durchlauf auf Binäresn Suchbäumen
Proposition
Wenn man die Einträge eines (U, R)-BSB in Inorder-Reihenfolge ausgibt,
dann sind sie aufsteigend nach den Schlüsseln sortiert.
Beweisskizze
Die Behauptung kann mittels Induktion über den rekursiven Aufbau von
binären Suchbäumen bewiesen werden.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 13 / 63
Implementierung von BSB
T:
(G,4)
(E,3)
(K,7)
(B,1)
(I,5)
(D,2)
(M,8)
(J,6)
Man kann einen (U, R)-BSB als Binärbaum mit leeren äußeren Knoten
implementieren.
Die Knoten enthalten Paare aus U × R als Eintrag.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 14 / 63
Implementierung von BSB
T:
(G,4)
(E,3)
(K,7)
(B,1)
(I,5)
(D,2)
(M,8)
(J,6)
Man kann einen (U, R)-BSB als Binärbaum mit leeren äußeren Knoten
implementieren.
Die Knoten enthalten Paare aus U × R als Eintrag.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 14 / 63
Suche in BSB
lookup
Eingabe: (U, R)-BSB T und x ∈ U
if T == then return ⊥;
// Leerer Baum
if T = (T1 , (x, r ), T2 ) then return r und Zeiger auf T ; // in der Wurzel
if T = (T1 , (y , r ), T2 ) then
if x < y then return lookup(T1 , x);
if x > y then return lookup(T2 , x);
end
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 15 / 63
// linker Unterbaum
// rechter Unterbaum
Suche in BSB
lookup
Eingabe: (U, R)-BSB T und x ∈ U
if T == then return ⊥;
// Leerer Baum
if T = (T1 , (x, r ), T2 ) then return r und Zeiger auf T ; // in der Wurzel
if T = (T1 , (y , r ), T2 ) then
if x < y then return lookup(T1 , x);
if x > y then return lookup(T2 , x);
end
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 15 / 63
// linker Unterbaum
// rechter Unterbaum
Suche in BSB
lookup
Eingabe: (U, R)-BSB T und x ∈ U
if T == then return ⊥;
// Leerer Baum
if T = (T1 , (x, r ), T2 ) then return r und Zeiger auf T ; // in der Wurzel
if T = (T1 , (y , r ), T2 ) then
if x < y then return lookup(T1 , x);
if x > y then return lookup(T2 , x);
end
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 15 / 63
// linker Unterbaum
// rechter Unterbaum
Suche in BSB
lookup
Eingabe: (U, R)-BSB T und x ∈ U
if T == then return ⊥;
// Leerer Baum
if T = (T1 , (x, r ), T2 ) then return r und Zeiger auf T ; // in der Wurzel
if T = (T1 , (y , r ), T2 ) then
if x < y then return lookup(T1 , x);
if x > y then return lookup(T2 , x);
end
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 15 / 63
// linker Unterbaum
// rechter Unterbaum
Suche in BSB
lookup
Eingabe: (U, R)-BSB T und x ∈ U
if T == then return ⊥;
// Leerer Baum
if T = (T1 , (x, r ), T2 ) then return r und Zeiger auf T ; // in der Wurzel
if T = (T1 , (y , r ), T2 ) then
if x < y then return lookup(T1 , x);
if x > y then return lookup(T2 , x);
end
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 15 / 63
// linker Unterbaum
// rechter Unterbaum
Suche in BSB
lookup
Eingabe: (U, R)-BSB T und x ∈ U
if T == then return ⊥;
// Leerer Baum
if T = (T1 , (x, r ), T2 ) then return r und Zeiger auf T ; // in der Wurzel
if T = (T1 , (y , r ), T2 ) then
if x < y then return lookup(T1 , x);
if x > y then return lookup(T2 , x);
end
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 15 / 63
// linker Unterbaum
// rechter Unterbaum
Suche in BSB
Beispiel
H
D
K
lookup(Q)
B
b
b
F
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 16 / 63
Suche in BSB
Beispiel
H
D
K
lookup(Q)
B
b
b
F
b
W
b
Q >H
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 16 / 63
⇒
rechts
Suche in BSB
Beispiel
H
D
K
lookup(Q)
B
b
b
F
b
W
b
O
b
S
b
Z
b
Q
b
Q >H
Q >K
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 16 / 63
⇒
⇒
rechts
rechts
Suche in BSB
Beispiel
H
D
K
lookup(Q)
B
b
b
F
b
W
b
O
b
S
b
Z
b
Q
b
Q >H
Q >K
Q <W
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 16 / 63
⇒
⇒
⇒
rechts
rechts
links
Suche in BSB
Beispiel
H
D
K
lookup(Q)
B
b
b
F
b
W
b
O
b
S
b
Z
b
Q
b
Q
Q
Q
Q
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 16 / 63
>H
>K
<W
>O
⇒
⇒
⇒
⇒
rechts
rechts
links
rechts
Suche in BSB
Beispiel
H
D
K
lookup(Q)
B
b
b
F
b
W
b
O
b
S
b
Z
b
Q
b
Q
Q
Q
Q
Q
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 16 / 63
>H
>K
<W
>O
<S
⇒
⇒
⇒
⇒
⇒
rechts
rechts
links
rechts
links
Suche in BSB
Beispiel
H
D
K
lookup(Q)
B
b
b
F
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
Q
Q
Q
Q
Q
Q
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 16 / 63
>H
>K
<W
>O
<S
=Q
⇒
⇒
⇒
⇒
⇒
⇒
rechts
rechts
links
rechts
links
gefunden
Suche in BSB
Beispiel
H
D
B
K
b
b
F
b
lookup(X )
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 17 / 63
Suche in BSB
Beispiel
H
D
B
K
F
lookup(X )
W
b
X >H
b
b
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 17 / 63
⇒
rechts
Suche in BSB
Beispiel
H
D
B
K
b
b
F
b
lookup(X )
W
b
O
b
S
b
Z
b
Q
b
X >H
X >K
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 17 / 63
⇒
⇒
rechts
rechts
Suche in BSB
Beispiel
H
D
B
K
b
b
F
b
lookup(X )
W
b
O
b
S
b
Z
b
Q
b
X >H
X >K
X >W
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 17 / 63
⇒
⇒
⇒
rechts
rechts
rechts
Suche in BSB
Beispiel
H
D
B
K
b
b
F
b
lookup(X )
W
b
O
b
S
b
Z
b
Q
b
X
X
X
X
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 17 / 63
>H
>K
>W
<Y
⇒
⇒
⇒
⇒
rechts
rechts
rechts
links
Suche in BSB
Beispiel
H
D
B
K
b
b
F
b
lookup(X )
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
X >H
X >K
X >W
X <Y
Blatt
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 17 / 63
⇒
rechts
⇒
rechts
⇒
rechts
⇒
links
⇒
nicht gefunden
Korrektheit und Zeitaufwand von lookup
Die Korrektheit ergibt sich direkt aus der Struktur.
Formal läßt sie sich über den rekursiven Aufbau von binären Suchbäumen
beweisen.
Wenn x in Knoten vx ist, wird für jeden Knoten auf dem Weg von der
Wurzel zu vx konstante Zeit (O(1)) benötigt.
Es gibt d(vx ) ≤ d(T ) solche Knoten.
Wenn x nicht in T vorhanden ist, dann endet die Suche in einem externen
Knoten lx .
Wiederum benötigt man konstante Zeit für jeden der d(lx ) ≤ d(T ) + 1
Knoten auf dem Weg von der Wurzel zu lx .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 18 / 63
Korrektheit und Zeitaufwand von lookup
Die Korrektheit ergibt sich direkt aus der Struktur.
Formal läßt sie sich über den rekursiven Aufbau von binären Suchbäumen
beweisen.
Wenn x in Knoten vx ist, wird für jeden Knoten auf dem Weg von der
Wurzel zu vx konstante Zeit (O(1)) benötigt.
Es gibt d(vx ) ≤ d(T ) solche Knoten.
Wenn x nicht in T vorhanden ist, dann endet die Suche in einem externen
Knoten lx .
Wiederum benötigt man konstante Zeit für jeden der d(lx ) ≤ d(T ) + 1
Knoten auf dem Weg von der Wurzel zu lx .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 18 / 63
Korrektheit und Zeitaufwand von lookup
Die Korrektheit ergibt sich direkt aus der Struktur.
Formal läßt sie sich über den rekursiven Aufbau von binären Suchbäumen
beweisen.
Wenn x in Knoten vx ist, wird für jeden Knoten auf dem Weg von der
Wurzel zu vx konstante Zeit (O(1)) benötigt.
Es gibt d(vx ) ≤ d(T ) solche Knoten.
Wenn x nicht in T vorhanden ist, dann endet die Suche in einem externen
Knoten lx .
Wiederum benötigt man konstante Zeit für jeden der d(lx ) ≤ d(T ) + 1
Knoten auf dem Weg von der Wurzel zu lx .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 18 / 63
Korrektheit und Zeitaufwand von lookup
Die Korrektheit ergibt sich direkt aus der Struktur.
Formal läßt sie sich über den rekursiven Aufbau von binären Suchbäumen
beweisen.
Wenn x in Knoten vx ist, wird für jeden Knoten auf dem Weg von der
Wurzel zu vx konstante Zeit (O(1)) benötigt.
Es gibt d(vx ) ≤ d(T ) solche Knoten.
Wenn x nicht in T vorhanden ist, dann endet die Suche in einem externen
Knoten lx .
Wiederum benötigt man konstante Zeit für jeden der d(lx ) ≤ d(T ) + 1
Knoten auf dem Weg von der Wurzel zu lx .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 18 / 63
Korrektheit und Zeitaufwand von lookup
Die Korrektheit ergibt sich direkt aus der Struktur.
Formal läßt sie sich über den rekursiven Aufbau von binären Suchbäumen
beweisen.
Wenn x in Knoten vx ist, wird für jeden Knoten auf dem Weg von der
Wurzel zu vx konstante Zeit (O(1)) benötigt.
Es gibt d(vx ) ≤ d(T ) solche Knoten.
Wenn x nicht in T vorhanden ist, dann endet die Suche in einem externen
Knoten lx .
Wiederum benötigt man konstante Zeit für jeden der d(lx ) ≤ d(T ) + 1
Knoten auf dem Weg von der Wurzel zu lx .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 18 / 63
Korrektheit und Zeitaufwand von lookup
Die Korrektheit ergibt sich direkt aus der Struktur.
Formal läßt sie sich über den rekursiven Aufbau von binären Suchbäumen
beweisen.
Wenn x in Knoten vx ist, wird für jeden Knoten auf dem Weg von der
Wurzel zu vx konstante Zeit (O(1)) benötigt.
Es gibt d(vx ) ≤ d(T ) solche Knoten.
Wenn x nicht in T vorhanden ist, dann endet die Suche in einem externen
Knoten lx .
Wiederum benötigt man konstante Zeit für jeden der d(lx ) ≤ d(T ) + 1
Knoten auf dem Weg von der Wurzel zu lx .
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 18 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
insert
Eingabe: (U, R)-BSB T , x ∈ U und r ∈ R
if T == then Erzeuge einen neuen Knoten T neu mit Eintrag (x, r ) ;
if T = (T1 , (x, r ′ ), T2 ) then T neu = (T1 , (x, r ), T2 );
if T = (T1 , (y , r ), T2 ) then
if x < y then
T1neu = insert(T1 , x, r );
T neu = (T1neu , (y , r ′ ), T2 );
end
if x > y then
T2neu = insert(T2 , x, r );
T neu = (T1 , (y , r ′ ), T2neu );
end
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 19 / 63
Einfügen in BSB
Beispiel
H
insert(E )
D
B
K
b
b
F
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
b
E <H
K
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
links
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
b
E <H
E >D
K
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
⇒
links
rechts
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
b
E <H
E >D
E <F
K
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
⇒
⇒
links
rechts
links
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
b
E <H
E >D
E <F
Blatt
K
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
⇒
⇒
⇒
links
rechts
links
neuer Knoten
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
E
b
b
E <H
E >D
E <F
Blatt
K
W
b
O
b
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
⇒
⇒
⇒
links
rechts
links
neuer Knoten
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
E
b
E <H
E >D
E <F
Blatt
K
W
b
O
b
⇒
⇒
⇒
⇒
Y
insert(N)
b
b
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
links
rechts
links
neuer Knoten
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
E
b
E <H
E >D
E <F
Blatt
K
W
b
O
b
⇒
⇒
⇒
⇒
links
rechts
links
neuer Knoten
Y
insert(N)
b
b
S
b
Q
b
Z
b
V
U
b
b
b
N>H
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
rechts
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
E
b
E <H
E >D
E <F
Blatt
K
W
b
O
b
⇒
⇒
⇒
⇒
links
rechts
links
neuer Knoten
Y
insert(N)
b
b
S
b
Q
b
Z
b
V
U
b
b
b
b
N>H
N>K
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
⇒
rechts
rechts
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
E
b
E <H
E >D
E <F
Blatt
K
W
b
O
b
⇒
⇒
⇒
⇒
links
rechts
links
neuer Knoten
Y
insert(N)
b
b
S
b
Q
b
Z
b
V
U
b
b
b
b
N>H
N>K
N<W
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
⇒
⇒
rechts
rechts
links
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
E
b
E <H
E >D
E <F
Blatt
K
W
b
O
b
⇒
⇒
⇒
⇒
links
rechts
links
neuer Knoten
Y
insert(N)
b
b
S
b
Q
b
Z
b
V
U
b
b
b
b
b
N
N
N
N
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
>H
>K
<W
<O
⇒
⇒
⇒
⇒
rechts
rechts
links
links
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
E
b
E <H
E >D
E <F
Blatt
K
W
b
O
b
⇒
⇒
⇒
⇒
links
rechts
links
neuer Knoten
Y
insert(N)
b
b
S
b
Q
b
Z
b
V
U
b
b
b
b
b
N>H
N>K
N<W
N<O
Blatt
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
rechts
⇒
rechts
⇒
links
⇒
links
⇒
neuer Knoten
Einfügen in BSB
Beispiel
H
insert(E )
D
B
b
F
E
b
E <H
E >D
E <F
Blatt
K
W
b
O
b
⇒
⇒
⇒
⇒
links
rechts
links
neuer Knoten
Y
insert(N)
b
b
N
S
Q
b
Z
b
V
U
b
b
b
b
b
N>H
N>K
N<W
N<O
Blatt
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 20 / 63
⇒
rechts
⇒
rechts
⇒
links
⇒
links
⇒
neuer Knoten
Korrektheit und Zeitaufwand von insert
Man beweist durch Induktion über den rekursiven Aufbau von T , dass
insert(T , x, r ) einen binären Suchbaum T neu erzeugt, der die Funktion
insert(f , x, r ) darstellt.
Wenn der Schlüssel x bereits in Knoten vx vorhanden ist, dann benötigt man
Zeit O(1) für jeden der d(vx ) ≤ d(T ) Knoten auf dem Weg zu vx .
Wenn der Schlüssel x noch nicht vorhanden ist, dann benötigt man Zeit
O(1) für jeden Knoten auf dem Weg zu dem Blatt lx in dem (x, r ) eingefügt
wird.
Es gibt d(lx ) ≤ d(T ) + 1 solcher Knoten.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 21 / 63
Korrektheit und Zeitaufwand von insert
Man beweist durch Induktion über den rekursiven Aufbau von T , dass
insert(T , x, r ) einen binären Suchbaum T neu erzeugt, der die Funktion
insert(f , x, r ) darstellt.
Wenn der Schlüssel x bereits in Knoten vx vorhanden ist, dann benötigt man
Zeit O(1) für jeden der d(vx ) ≤ d(T ) Knoten auf dem Weg zu vx .
Wenn der Schlüssel x noch nicht vorhanden ist, dann benötigt man Zeit
O(1) für jeden Knoten auf dem Weg zu dem Blatt lx in dem (x, r ) eingefügt
wird.
Es gibt d(lx ) ≤ d(T ) + 1 solcher Knoten.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 21 / 63
Korrektheit und Zeitaufwand von insert
Man beweist durch Induktion über den rekursiven Aufbau von T , dass
insert(T , x, r ) einen binären Suchbaum T neu erzeugt, der die Funktion
insert(f , x, r ) darstellt.
Wenn der Schlüssel x bereits in Knoten vx vorhanden ist, dann benötigt man
Zeit O(1) für jeden der d(vx ) ≤ d(T ) Knoten auf dem Weg zu vx .
Wenn der Schlüssel x noch nicht vorhanden ist, dann benötigt man Zeit
O(1) für jeden Knoten auf dem Weg zu dem Blatt lx in dem (x, r ) eingefügt
wird.
Es gibt d(lx ) ≤ d(T ) + 1 solcher Knoten.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 21 / 63
Korrektheit und Zeitaufwand von insert
Man beweist durch Induktion über den rekursiven Aufbau von T , dass
insert(T , x, r ) einen binären Suchbaum T neu erzeugt, der die Funktion
insert(f , x, r ) darstellt.
Wenn der Schlüssel x bereits in Knoten vx vorhanden ist, dann benötigt man
Zeit O(1) für jeden der d(vx ) ≤ d(T ) Knoten auf dem Weg zu vx .
Wenn der Schlüssel x noch nicht vorhanden ist, dann benötigt man Zeit
O(1) für jeden Knoten auf dem Weg zu dem Blatt lx in dem (x, r ) eingefügt
wird.
Es gibt d(lx ) ≤ d(T ) + 1 solcher Knoten.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 21 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen in BSB
delete
Eingabe: (U, R)-BSB T und x ∈ U
if T == then Tue nichts;
if T = (T1 , (y , r ), T2 ) und y 6= x then
if x < y then
T1neu = delete(T1 , x);
T neu = (T1neu , (y , r ), T2 );
end
if x > y then
T2neu = delete(T2 , x);
T neu = (T1 , (y , r ′ ), T2neu );
end
end
if T = (T1 , (x, r ), T2 ) then Lösche die Wurzel;
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 22 / 63
Löschen der Wurzel
1. Fall:
T1 = x
⇒
b
T2
3. Fall: T2 = Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 23 / 63
T2
Löschen der Wurzel
1. Fall:
T1 = x
b
⇒
T2
⇒
T1
T2
3. Fall: T2 = x
b
T1
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 23 / 63
Löschen der Wurzel
x
3. Fall:
T1 6= und T2 6= T1
T2
Suche den Eintrag (y , r ′ ) in T2 mit minimalem Schlüssel y .
Lösche ihn aus T2 und kopiere (y , r ′ ) in die Wurzel (bzw. aktualisiere
Zeiger).
Frage
Wie findet und löscht man den Eintrag mit minimalem Schlüssel?
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 24 / 63
Löschen der Wurzel
x
3. Fall:
T1 6= und T2 6= y
T2
T1
Suche den Eintrag (y , r ′ ) in T2 mit minimalem Schlüssel y .
Lösche ihn aus T2 und kopiere (y , r ′ ) in die Wurzel (bzw. aktualisiere
Zeiger).
Frage
Wie findet und löscht man den Eintrag mit minimalem Schlüssel?
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 24 / 63
Löschen der Wurzel
y
3. Fall:
T1 6= und T2 6= y
T2
T1
Suche den Eintrag (y , r ′ ) in T2 mit minimalem Schlüssel y .
Lösche ihn aus T2 und kopiere (y , r ′ ) in die Wurzel (bzw. aktualisiere
Zeiger).
Frage
Wie findet und löscht man den Eintrag mit minimalem Schlüssel?
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 24 / 63
Löschen der Wurzel
y
3. Fall:
T1 6= und T2 6= y
T2
T1
Suche den Eintrag (y , r ′ ) in T2 mit minimalem Schlüssel y .
Lösche ihn aus T2 und kopiere (y , r ′ ) in die Wurzel (bzw. aktualisiere
Zeiger).
Frage
Wie findet und löscht man den Eintrag mit minimalem Schlüssel?
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 24 / 63
Lösche die Wurzel eines BSB
deleteRoot
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
if T1 == then T neu = T2 ;
if T2 == then T neu = T1 ;
if T1 ! = und T2 ! = then
Suche in T2 den Eintrag (y , r ′ ) mit minimalem y ;
T2neu = deleteMin(T2 , y );
T neu = (T1 , (y , r ′ ), T2neu );
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 25 / 63
Lösche die Wurzel eines BSB
deleteRoot
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
if T1 == then T neu = T2 ;
if T2 == then T neu = T1 ;
if T1 ! = und T2 ! = then
Suche in T2 den Eintrag (y , r ′ ) mit minimalem y ;
T2neu = deleteMin(T2 , y );
T neu = (T1 , (y , r ′ ), T2neu );
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 25 / 63
Lösche die Wurzel eines BSB
deleteRoot
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
if T1 == then T neu = T2 ;
if T2 == then T neu = T1 ;
if T1 ! = und T2 ! = then
Suche in T2 den Eintrag (y , r ′ ) mit minimalem y ;
T2neu = deleteMin(T2 , y );
T neu = (T1 , (y , r ′ ), T2neu );
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 25 / 63
Lösche die Wurzel eines BSB
deleteRoot
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
if T1 == then T neu = T2 ;
if T2 == then T neu = T1 ;
if T1 ! = und T2 ! = then
Suche in T2 den Eintrag (y , r ′ ) mit minimalem y ;
T2neu = deleteMin(T2 , y );
T neu = (T1 , (y , r ′ ), T2neu );
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 25 / 63
Lösche die Wurzel eines BSB
deleteRoot
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
if T1 == then T neu = T2 ;
if T2 == then T neu = T1 ;
if T1 ! = und T2 ! = then
Suche in T2 den Eintrag (y , r ′ ) mit minimalem y ;
T2neu = deleteMin(T2 , y );
T neu = (T1 , (y , r ′ ), T2neu );
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 25 / 63
Lösche die Wurzel eines BSB
deleteRoot
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
if T1 == then T neu = T2 ;
if T2 == then T neu = T1 ;
if T1 ! = und T2 ! = then
Suche in T2 den Eintrag (y , r ′ ) mit minimalem y ;
T2neu = deleteMin(T2 , y );
T neu = (T1 , (y , r ′ ), T2neu );
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 25 / 63
Lösche die Wurzel eines BSB
deleteRoot
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
if T1 == then T neu = T2 ;
if T2 == then T neu = T1 ;
if T1 ! = und T2 ! = then
Suche in T2 den Eintrag (y , r ′ ) mit minimalem y ;
T2neu = deleteMin(T2 , y );
T neu = (T1 , (y , r ′ ), T2neu );
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 25 / 63
Lösche die Wurzel eines BSB
deleteRoot
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
if T1 == then T neu = T2 ;
if T2 == then T neu = T1 ;
if T1 ! = und T2 ! = then
Suche in T2 den Eintrag (y , r ′ ) mit minimalem y ;
T2neu = deleteMin(T2 , y );
T neu = (T1 , (y , r ′ ), T2neu );
end
return T neu
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 25 / 63
Extraktion des Minimums
deleteMin
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
Ausgabe: Der Baum T neu ohne das Minimum und den Eintrag (y , r ′ ) mit
minimalem Schlüssel
if T1 == then T neu = T2 , (y , r ′ ) = (x, r );
if T1 ! = then
(T neu , (y , r ′ )) = deleteMin(T1 )
end
return T neu und (y , r ′ )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 26 / 63
Extraktion des Minimums
deleteMin
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
Ausgabe: Der Baum T neu ohne das Minimum und den Eintrag (y , r ′ ) mit
minimalem Schlüssel
if T1 == then T neu = T2 , (y , r ′ ) = (x, r );
if T1 ! = then
(T neu , (y , r ′ )) = deleteMin(T1 )
end
return T neu und (y , r ′ )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 26 / 63
Extraktion des Minimums
deleteMin
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
Ausgabe: Der Baum T neu ohne das Minimum und den Eintrag (y , r ′ ) mit
minimalem Schlüssel
if T1 == then T neu = T2 , (y , r ′ ) = (x, r );
if T1 ! = then
(T neu , (y , r ′ )) = deleteMin(T1 )
end
return T neu und (y , r ′ )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 26 / 63
Extraktion des Minimums
deleteMin
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
Ausgabe: Der Baum T neu ohne das Minimum und den Eintrag (y , r ′ ) mit
minimalem Schlüssel
if T1 == then T neu = T2 , (y , r ′ ) = (x, r );
if T1 ! = then
(T neu , (y , r ′ )) = deleteMin(T1 )
end
return T neu und (y , r ′ )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 26 / 63
Extraktion des Minimums
deleteMin
Eingabe: (U, R)-BSB T = (T1 , (x, r ), T2 )
Ausgabe: Der Baum T neu ohne das Minimum und den Eintrag (y , r ′ ) mit
minimalem Schlüssel
if T1 == then T neu = T2 , (y , r ′ ) = (x, r );
if T1 ! = then
(T neu , (y , r ′ )) = deleteMin(T1 )
end
return T neu und (y , r ′ )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 26 / 63
Extraktion des Minimums
Prinzipielles Vorgehen: Gehe nach Links, bis das linke Kind ein leerer
äußerer Knoten () ist.
Der jeweilige Knoten hat kein linkes Kind.
Löschen von v führt zum Hochrutschen“ von T2
”
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 27 / 63
Extraktion des Minimums
Prinzipielles Vorgehen: Gehe nach Links, bis das linke Kind ein leerer
äußerer Knoten () ist.
Der jeweilige Knoten hat kein linkes Kind.
Löschen von v führt zum Hochrutschen“ von T2
”
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 27 / 63
(y,r’)
T2
v
Extraktion des Minimums
Prinzipielles Vorgehen: Gehe nach Links, bis das linke Kind ein leerer
äußerer Knoten () ist.
Der jeweilige Knoten hat kein linkes Kind.
Löschen von v führt zum Hochrutschen“ von T2
”
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 27 / 63
(y,r’)
T2
v
Löschen in BSB
Beispiel
H
D
K
delete(Q)
B
b
b
F
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 28 / 63
Löschen in BSB
Beispiel
H
D
K
delete(Q)
B
b
b
F
b
W
b
Q >H
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 28 / 63
⇒
rechts
Löschen in BSB
Beispiel
H
D
K
delete(Q)
B
b
b
F
b
W
b
O
b
S
b
Z
b
Q
b
Q >H
Q >K
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 28 / 63
⇒
⇒
rechts
rechts
Löschen in BSB
Beispiel
H
D
K
delete(Q)
B
b
b
F
b
W
b
O
b
S
b
Z
b
Q
b
Q >H
Q >K
Q <W
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 28 / 63
⇒
⇒
⇒
rechts
rechts
links
Löschen in BSB
Beispiel
H
D
K
delete(Q)
B
b
b
F
b
W
b
O
b
S
b
Z
b
Q
b
Q
Q
Q
Q
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 28 / 63
>H
>K
<W
>O
⇒
⇒
⇒
⇒
rechts
rechts
links
rechts
Löschen in BSB
Beispiel
H
D
K
delete(Q)
B
b
b
F
b
W
b
O
b
S
b
Z
b
Q
b
Q
Q
Q
Q
Q
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 28 / 63
>H
>K
<W
>O
<S
⇒
⇒
⇒
⇒
⇒
rechts
rechts
links
rechts
links
Löschen in BSB
Beispiel
H
D
K
delete(Q)
B
b
b
F
b
W
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
Q
Q
Q
Q
Q
Q
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 28 / 63
>H
>K
<W
>O
<S
=Q
⇒
⇒
⇒
⇒
⇒
⇒
rechts
rechts
links
rechts
links
löschen
Löschen in BSB
Beispiel
H
D
K
delete(Q)
B
b
b
F
b
W
b
O
b
Y
S
b
Z
b
V
b
U
b
b
b
Q
Q
Q
Q
Q
Q
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 28 / 63
>H
>K
<W
>O
<S
=Q
⇒
⇒
⇒
⇒
⇒
⇒
rechts
rechts
links
rechts
links
löschen
Löschen in BSB
Beispiel
H
D
B
K
F
W
b
delete(K )
b
b
b
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 29 / 63
Löschen in BSB
Beispiel
H
D
B
K
F
W
b
delete(K )
b
b
b
O
b
Y
S
b
Q
b
V
U
b
b
K >H
Z
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 29 / 63
⇒
rechts
Löschen in BSB
Beispiel
H
D
B
K
F
W
b
delete(K )
b
b
b
O
b
Y
S
b
Q
b
V
U
b
b
K >H
K =K
Z
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 29 / 63
⇒
⇒
rechts
löschen
Löschen in BSB
Beispiel
H
D
B
F
W
delete(K )
b
b
b
O
b
Y
S
b
Q
b
V
U
b
b
K >H
K =K
Z
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 29 / 63
⇒
⇒
rechts
löschen
Löschen in BSB
Beispiel
H
D
B
W
b
b
F
b
delete(H)
O
b
Y
S
b
Q
b
Z
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 30 / 63
Löschen in BSB
Beispiel
H
D
B
W
b
b
F
b
delete(H)
O
b
S
b
Z
b
Q
b
H=H
Y
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 30 / 63
⇒
löschen
Löschen in BSB
Beispiel
H
D
B
W
b
b
F
b
delete(H)
O
b
S
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
⇒
deleteMin(W )
Z
b
Q
b
H=H
Y
Seite 30 / 63
löschen
Löschen in BSB
Beispiel
H
D
B
W
b
b
F
b
delete(H)
O
b
S
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
⇒
deleteMin(W )
Z
b
Q
b
H=H
Y
Seite 30 / 63
löschen
Löschen in BSB
Beispiel
H
D
B
W
b
b
F
b
delete(H)
O
b
S
b
V
U
b
b
b
b
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
⇒
deleteMin(W )
Z
b
Q
b
H=H
Y
Seite 30 / 63
löschen
Löschen in BSB
Beispiel
H
D
B
W
b
b
F
b
delete(H)
O
b
S
b
V
U
b
b
b
löschen
b
O nach H kopieren Knoten löschen
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
⇒
deleteMin(W )
Z
b
Q
b
H=H
Y
Seite 30 / 63
Löschen in BSB
Beispiel
O
D
B
W
b
delete(H)
b
F
b
H=H
Y
S
b
Q
b
V
U
b
b
b
b
O nach H kopieren Knoten löschen
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
löschen
deleteMin(W )
Z
b
⇒
Seite 30 / 63
Korrektheit von delete
Lemma
delete(T , x) erzeugt einen binären Suchbaum T neu , der die Funktion
delete(fT , x) darstellt.
Beweisskizze
Die Behauptung wird mittels Induktion über den rekursiven Aufbau von
Binärbäumen bewiesen.
Dabei muss man gesondert zeigen, dass die Prozedur deleteMin(T ) auf
einem nichtleeren Baum das verlangte Resultat liefert. Das kann man
ebenfalls per Induktion über den rekursiven Aufbau machen.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 31 / 63
Korrektheit von delete
Lemma
delete(T , x) erzeugt einen binären Suchbaum T neu , der die Funktion
delete(fT , x) darstellt.
Beweisskizze
Die Behauptung wird mittels Induktion über den rekursiven Aufbau von
Binärbäumen bewiesen.
Dabei muss man gesondert zeigen, dass die Prozedur deleteMin(T ) auf
einem nichtleeren Baum das verlangte Resultat liefert. Das kann man
ebenfalls per Induktion über den rekursiven Aufbau machen.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 31 / 63
Korrektheit von delete
Lemma
delete(T , x) erzeugt einen binären Suchbaum T neu , der die Funktion
delete(fT , x) darstellt.
Beweisskizze
Die Behauptung wird mittels Induktion über den rekursiven Aufbau von
Binärbäumen bewiesen.
Dabei muss man gesondert zeigen, dass die Prozedur deleteMin(T ) auf
einem nichtleeren Baum das verlangte Resultat liefert. Das kann man
ebenfalls per Induktion über den rekursiven Aufbau machen.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 31 / 63
Zeitaufwand von delete
Wenn x im Knoten vx vorhanden ist und eines seiner Kinder leer ist,
dann benötigt das Löschen lediglich Zeit O(1) für jeden der
d(vx ) ≤ d(T ) Knoten auf dem Weg.
Wenn x im Knoten vx vorhanden ist und beide Kinder nicht leer sind,
benötigen wir O(1) Zeit für jeden der d(vx ) Knoten auf dem Weg zu vx .
Außerdem benötigen wir O(1) Zeit für die d(u) − d(vx ) Knoten auf
dem Weg von vx zum Inorder-Nachfolger u (Minimum unter vx ).
Insgesamt ergibt sich also eine Laufzeit von O(d(T )).
Wenn x nicht im Baum vorhanden ist, dann Kostet es Zeit O(1) für
jeden Knoten auf dem Weg zum Blatt lx bei dem dies festgestellt wird.
Davon gibt es insgesamt d(lx ) ≤ d(T ) + 1 Stück.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 32 / 63
Zeitaufwand von delete
Wenn x im Knoten vx vorhanden ist und eines seiner Kinder leer ist,
dann benötigt das Löschen lediglich Zeit O(1) für jeden der
d(vx ) ≤ d(T ) Knoten auf dem Weg.
Wenn x im Knoten vx vorhanden ist und beide Kinder nicht leer sind,
benötigen wir O(1) Zeit für jeden der d(vx ) Knoten auf dem Weg zu vx .
Außerdem benötigen wir O(1) Zeit für die d(u) − d(vx ) Knoten auf
dem Weg von vx zum Inorder-Nachfolger u (Minimum unter vx ).
Insgesamt ergibt sich also eine Laufzeit von O(d(T )).
Wenn x nicht im Baum vorhanden ist, dann Kostet es Zeit O(1) für
jeden Knoten auf dem Weg zum Blatt lx bei dem dies festgestellt wird.
Davon gibt es insgesamt d(lx ) ≤ d(T ) + 1 Stück.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 32 / 63
Zeitaufwand von delete
Wenn x im Knoten vx vorhanden ist und eines seiner Kinder leer ist,
dann benötigt das Löschen lediglich Zeit O(1) für jeden der
d(vx ) ≤ d(T ) Knoten auf dem Weg.
Wenn x im Knoten vx vorhanden ist und beide Kinder nicht leer sind,
benötigen wir O(1) Zeit für jeden der d(vx ) Knoten auf dem Weg zu vx .
Außerdem benötigen wir O(1) Zeit für die d(u) − d(vx ) Knoten auf
dem Weg von vx zum Inorder-Nachfolger u (Minimum unter vx ).
Insgesamt ergibt sich also eine Laufzeit von O(d(T )).
Wenn x nicht im Baum vorhanden ist, dann Kostet es Zeit O(1) für
jeden Knoten auf dem Weg zum Blatt lx bei dem dies festgestellt wird.
Davon gibt es insgesamt d(lx ) ≤ d(T ) + 1 Stück.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 32 / 63
Zeitaufwand von delete
Wenn x im Knoten vx vorhanden ist und eines seiner Kinder leer ist,
dann benötigt das Löschen lediglich Zeit O(1) für jeden der
d(vx ) ≤ d(T ) Knoten auf dem Weg.
Wenn x im Knoten vx vorhanden ist und beide Kinder nicht leer sind,
benötigen wir O(1) Zeit für jeden der d(vx ) Knoten auf dem Weg zu vx .
Außerdem benötigen wir O(1) Zeit für die d(u) − d(vx ) Knoten auf
dem Weg von vx zum Inorder-Nachfolger u (Minimum unter vx ).
Insgesamt ergibt sich also eine Laufzeit von O(d(T )).
Wenn x nicht im Baum vorhanden ist, dann Kostet es Zeit O(1) für
jeden Knoten auf dem Weg zum Blatt lx bei dem dies festgestellt wird.
Davon gibt es insgesamt d(lx ) ≤ d(T ) + 1 Stück.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 32 / 63
Zeitaufwand von delete
Wenn x im Knoten vx vorhanden ist und eines seiner Kinder leer ist,
dann benötigt das Löschen lediglich Zeit O(1) für jeden der
d(vx ) ≤ d(T ) Knoten auf dem Weg.
Wenn x im Knoten vx vorhanden ist und beide Kinder nicht leer sind,
benötigen wir O(1) Zeit für jeden der d(vx ) Knoten auf dem Weg zu vx .
Außerdem benötigen wir O(1) Zeit für die d(u) − d(vx ) Knoten auf
dem Weg von vx zum Inorder-Nachfolger u (Minimum unter vx ).
Insgesamt ergibt sich also eine Laufzeit von O(d(T )).
Wenn x nicht im Baum vorhanden ist, dann Kostet es Zeit O(1) für
jeden Knoten auf dem Weg zum Blatt lx bei dem dies festgestellt wird.
Davon gibt es insgesamt d(lx ) ≤ d(T ) + 1 Stück.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 32 / 63
Der Zeitaufwand
Wie wir gesehen haben, ist die Zeit, die für einen Aufruf von insert,
lookup oder delete benötigt wird in O(d(T )).
Im Folgenden wollen wir uns exemplarisch die lookup-Operation genauer
ansehen.
Ist x vorhanden, ist die Laufzeit in O(d(vx )), wobei vx der innere Knoten
von T ist, der x enthält.
Ist x nicht vorhanden, ist die Laufzeit in O(d(lx )), wobei lx der äußere
Knoten ist, zu dem uns die Suche nach x führt.
Um ein Gefühl für die mittlere Laufzeit zu erhalten, ist es also nötig die
Tiefen der inneren und äußeren Knoten zu untersuchen.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 33 / 63
Der Zeitaufwand
Wie wir gesehen haben, ist die Zeit, die für einen Aufruf von insert,
lookup oder delete benötigt wird in O(d(T )).
Im Folgenden wollen wir uns exemplarisch die lookup-Operation genauer
ansehen.
Ist x vorhanden, ist die Laufzeit in O(d(vx )), wobei vx der innere Knoten
von T ist, der x enthält.
Ist x nicht vorhanden, ist die Laufzeit in O(d(lx )), wobei lx der äußere
Knoten ist, zu dem uns die Suche nach x führt.
Um ein Gefühl für die mittlere Laufzeit zu erhalten, ist es also nötig die
Tiefen der inneren und äußeren Knoten zu untersuchen.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 33 / 63
Der Zeitaufwand
Wie wir gesehen haben, ist die Zeit, die für einen Aufruf von insert,
lookup oder delete benötigt wird in O(d(T )).
Im Folgenden wollen wir uns exemplarisch die lookup-Operation genauer
ansehen.
Ist x vorhanden, ist die Laufzeit in O(d(vx )), wobei vx der innere Knoten
von T ist, der x enthält.
Ist x nicht vorhanden, ist die Laufzeit in O(d(lx )), wobei lx der äußere
Knoten ist, zu dem uns die Suche nach x führt.
Um ein Gefühl für die mittlere Laufzeit zu erhalten, ist es also nötig die
Tiefen der inneren und äußeren Knoten zu untersuchen.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 33 / 63
Der Zeitaufwand
Wie wir gesehen haben, ist die Zeit, die für einen Aufruf von insert,
lookup oder delete benötigt wird in O(d(T )).
Im Folgenden wollen wir uns exemplarisch die lookup-Operation genauer
ansehen.
Ist x vorhanden, ist die Laufzeit in O(d(vx )), wobei vx der innere Knoten
von T ist, der x enthält.
Ist x nicht vorhanden, ist die Laufzeit in O(d(lx )), wobei lx der äußere
Knoten ist, zu dem uns die Suche nach x führt.
Um ein Gefühl für die mittlere Laufzeit zu erhalten, ist es also nötig die
Tiefen der inneren und äußeren Knoten zu untersuchen.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 33 / 63
Der Zeitaufwand
Wie wir gesehen haben, ist die Zeit, die für einen Aufruf von insert,
lookup oder delete benötigt wird in O(d(T )).
Im Folgenden wollen wir uns exemplarisch die lookup-Operation genauer
ansehen.
Ist x vorhanden, ist die Laufzeit in O(d(vx )), wobei vx der innere Knoten
von T ist, der x enthält.
Ist x nicht vorhanden, ist die Laufzeit in O(d(lx )), wobei lx der äußere
Knoten ist, zu dem uns die Suche nach x führt.
Um ein Gefühl für die mittlere Laufzeit zu erhalten, ist es also nötig die
Tiefen der inneren und äußeren Knoten zu untersuchen.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 33 / 63
Totale innere und äußere Weglänge von
Binärbäumen
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 34 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2+2
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2+2+3
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2+2+3+3
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2+2+3+3+3
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2+2+3+3+3+4
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2+2+3+3+3+4+4
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2+2+3+3+3+4+4+4
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1+2+2+3+3+3+4+4+4+5
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Frage
Wieviele Knoten werden insgesamt besucht, wenn man zu jedem inneren
Knoten einmal hinläuft?
Beispiel
1 + 2 + 2 + 3 + 3 + 3 + 4 + 4 + 4 + 5 = 31
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 35 / 63
Die totale innere Weglänge
Definition (Totale innere Weglänge)
Die totale innere Weglänge (total inner path length) ist definiert als
X
TIPL(T ) :=
d(v ).
v∈V
Damit ist die Gesamtzahl der besuchten Knoten n + TIPL(T ).
Die mittlere Weglänge ist n1 TIPL(T )
Die mittlere Anzahl besuchter Knoten ist 1 + n1 TIPL(T )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 36 / 63
Die totale innere Weglänge
Definition (Totale innere Weglänge)
Die totale innere Weglänge (total inner path length) ist definiert als
X
TIPL(T ) :=
d(v ).
v∈V
Damit ist die Gesamtzahl der besuchten Knoten n + TIPL(T ).
Die mittlere Weglänge ist n1 TIPL(T )
Die mittlere Anzahl besuchter Knoten ist 1 + n1 TIPL(T )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 36 / 63
Die totale innere Weglänge
Definition (Totale innere Weglänge)
Die totale innere Weglänge (total inner path length) ist definiert als
X
TIPL(T ) :=
d(v ).
v∈V
Damit ist die Gesamtzahl der besuchten Knoten n + TIPL(T ).
Die mittlere Weglänge ist n1 TIPL(T )
Die mittlere Anzahl besuchter Knoten ist 1 + n1 TIPL(T )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 36 / 63
Die totale innere Weglänge
Definition (Totale innere Weglänge)
Die totale innere Weglänge (total inner path length) ist definiert als
X
TIPL(T ) :=
d(v ).
v∈V
Damit ist die Gesamtzahl der besuchten Knoten n + TIPL(T ).
Die mittlere Weglänge ist n1 TIPL(T )
Die mittlere Anzahl besuchter Knoten ist 1 + n1 TIPL(T )
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 36 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4+4
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4+4+5
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4+4+5+5
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4+4+5+5+5
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4+4+5+5+5+5
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4+4+5+5+5+5+5
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4+4+5+5+5+5+5+6
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3+4+4+4+5+5+5+5+5+6+6
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Frage
Wieviele innere und äußere Knoten werden insgesamt besucht, wenn man zu
jedem äußeren Knoten einmal hinläuft?
Beispiel
3 + 4 + 4 + 4 + 5 + 5 + 5 + 5 + 5 + 6 + 6 = 52
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 37 / 63
Die totale äußere Weglänge
Definition (Totale äußere Weglänge)
Die totale äußere Weglänge (total external path length) ist definiert als
X
TEPL(T ) :=
d(l).
l∈L
Die Gesamtzahl der besuchten Knoten ist (n + 1) + TEPL(T )
Die Mittlere äußere Weglänge ist
1
n+1 TEPL(T )
Die Mittlere Anzahl der besuchten Knoten ist 1 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 38 / 63
1
n+1 TEPL(T )
Die totale äußere Weglänge
Definition (Totale äußere Weglänge)
Die totale äußere Weglänge (total external path length) ist definiert als
X
TEPL(T ) :=
d(l).
l∈L
Die Gesamtzahl der besuchten Knoten ist (n + 1) + TEPL(T )
Die Mittlere äußere Weglänge ist
1
n+1 TEPL(T )
Die Mittlere Anzahl der besuchten Knoten ist 1 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 38 / 63
1
n+1 TEPL(T )
Die totale äußere Weglänge
Definition (Totale äußere Weglänge)
Die totale äußere Weglänge (total external path length) ist definiert als
X
TEPL(T ) :=
d(l).
l∈L
Die Gesamtzahl der besuchten Knoten ist (n + 1) + TEPL(T )
Die Mittlere äußere Weglänge ist
1
n+1 TEPL(T )
Die Mittlere Anzahl der besuchten Knoten ist 1 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 38 / 63
1
n+1 TEPL(T )
Die totale äußere Weglänge
Definition (Totale äußere Weglänge)
Die totale äußere Weglänge (total external path length) ist definiert als
X
TEPL(T ) :=
d(l).
l∈L
Die Gesamtzahl der besuchten Knoten ist (n + 1) + TEPL(T )
Die Mittlere äußere Weglänge ist
1
n+1 TEPL(T )
Die Mittlere Anzahl der besuchten Knoten ist 1 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 38 / 63
1
n+1 TEPL(T )
Totale äußere und innere Weglänge
Proposition
Für jeden Binärbaum mit n inneren Knoten gilt:
TEPL(T ) = TIPL(T ) + 2n
Beweis
Induktion über die Anzahl n innerer Knoten des Binärbaumes
Induktionsanfang: T = (z), d.h. n = 0.
Es gilt TIPL((z)) = 0 = TEPL((z)), was die Behauptung beweist.
Induktionsannahme: Für n > 0 gilt die Behauptung gilt für alle Bäume
mit weniger als n inneren Knoten.
...
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 39 / 63
Totale äußere und innere Weglänge
Proposition
Für jeden Binärbaum mit n inneren Knoten gilt:
TEPL(T ) = TIPL(T ) + 2n
Beweis
Induktion über die Anzahl n innerer Knoten des Binärbaumes
Induktionsanfang: T = (z), d.h. n = 0.
Es gilt TIPL((z)) = 0 = TEPL((z)), was die Behauptung beweist.
Induktionsannahme: Für n > 0 gilt die Behauptung gilt für alle Bäume
mit weniger als n inneren Knoten.
...
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 39 / 63
Totale äußere und innere Weglänge
Proposition
Für jeden Binärbaum mit n inneren Knoten gilt:
TEPL(T ) = TIPL(T ) + 2n
Beweis
Induktion über die Anzahl n innerer Knoten des Binärbaumes
Induktionsanfang: T = (z), d.h. n = 0.
Es gilt TIPL((z)) = 0 = TEPL((z)), was die Behauptung beweist.
Induktionsannahme: Für n > 0 gilt die Behauptung gilt für alle Bäume
mit weniger als n inneren Knoten.
...
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 39 / 63
Totale äußere und innere Weglänge
Proposition
Für jeden Binärbaum mit n inneren Knoten gilt:
TEPL(T ) = TIPL(T ) + 2n
Beweis
Induktion über die Anzahl n innerer Knoten des Binärbaumes
Induktionsanfang: T = (z), d.h. n = 0.
Es gilt TIPL((z)) = 0 = TEPL((z)), was die Behauptung beweist.
Induktionsannahme: Für n > 0 gilt die Behauptung gilt für alle Bäume
mit weniger als n inneren Knoten.
...
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 39 / 63
Totale äußere und innere Weglänge
Beweis (Fortsetzung)
Induktionsschritt: T = (T1 , x, T2 )
ni sei die Anzahl innerer Knoten in Ti für i = 1, 2. Offensichtlich gilt
n = n1 + n2 + 1 und somit n1 , n2 < n.
Nach Induktionsbehauptung gilt somit
TEPL(Ti ) = TIPL(Ti ) + 2ni für i = 1, 2.
Da die Tiefe der externen Knoten in T um eins höher ist, als in den
Teilbäumen, gilt
TEPL(T ) = (TEPL(T1 ) + (n1 + 1)) + (TEPL(T2 ) + (n2 + 1)).
Das gleiche gilt für die inneren Knoten, und somit
TIPL(T ) = (TIPL(T1 ) + n1 ) + (TIPL(T2 ) + n2 ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 40 / 63
Totale äußere und innere Weglänge
Beweis (Fortsetzung)
Induktionsschritt: T = (T1 , x, T2 )
ni sei die Anzahl innerer Knoten in Ti für i = 1, 2. Offensichtlich gilt
n = n1 + n2 + 1 und somit n1 , n2 < n.
Nach Induktionsbehauptung gilt somit
TEPL(Ti ) = TIPL(Ti ) + 2ni für i = 1, 2.
Da die Tiefe der externen Knoten in T um eins höher ist, als in den
Teilbäumen, gilt
TEPL(T ) = (TEPL(T1 ) + (n1 + 1)) + (TEPL(T2 ) + (n2 + 1)).
Das gleiche gilt für die inneren Knoten, und somit
TIPL(T ) = (TIPL(T1 ) + n1 ) + (TIPL(T2 ) + n2 ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 40 / 63
Totale äußere und innere Weglänge
Beweis (Fortsetzung)
Induktionsschritt: T = (T1 , x, T2 )
ni sei die Anzahl innerer Knoten in Ti für i = 1, 2. Offensichtlich gilt
n = n1 + n2 + 1 und somit n1 , n2 < n.
Nach Induktionsbehauptung gilt somit
TEPL(Ti ) = TIPL(Ti ) + 2ni für i = 1, 2.
Da die Tiefe der externen Knoten in T um eins höher ist, als in den
Teilbäumen, gilt
TEPL(T ) = (TEPL(T1 ) + (n1 + 1)) + (TEPL(T2 ) + (n2 + 1)).
Das gleiche gilt für die inneren Knoten, und somit
TIPL(T ) = (TIPL(T1 ) + n1 ) + (TIPL(T2 ) + n2 ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 40 / 63
Totale äußere und innere Weglänge
Beweis (Fortsetzung)
Induktionsschritt: T = (T1 , x, T2 )
ni sei die Anzahl innerer Knoten in Ti für i = 1, 2. Offensichtlich gilt
n = n1 + n2 + 1 und somit n1 , n2 < n.
Nach Induktionsbehauptung gilt somit
TEPL(Ti ) = TIPL(Ti ) + 2ni für i = 1, 2.
Da die Tiefe der externen Knoten in T um eins höher ist, als in den
Teilbäumen, gilt
TEPL(T ) = (TEPL(T1 ) + (n1 + 1)) + (TEPL(T2 ) + (n2 + 1)).
Das gleiche gilt für die inneren Knoten, und somit
TIPL(T ) = (TIPL(T1 ) + n1 ) + (TIPL(T2 ) + n2 ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 40 / 63
Totale äußere und innere Weglänge
Beweis (Fortsetzung)
Induktionsschritt: T = (T1 , x, T2 )
ni sei die Anzahl innerer Knoten in Ti für i = 1, 2. Offensichtlich gilt
n = n1 + n2 + 1 und somit n1 , n2 < n.
Nach Induktionsbehauptung gilt somit
TEPL(Ti ) = TIPL(Ti ) + 2ni für i = 1, 2.
Da die Tiefe der externen Knoten in T um eins höher ist, als in den
Teilbäumen, gilt
TEPL(T ) = (TEPL(T1 ) + (n1 + 1)) + (TEPL(T2 ) + (n2 + 1)).
Das gleiche gilt für die inneren Knoten, und somit
TIPL(T ) = (TIPL(T1 ) + n1 ) + (TIPL(T2 ) + n2 ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 40 / 63
Totale äußere und innere Weglänge
Beweis (Fortsetzung)
Damit gilt
TEPL(T ) − TIPL(T )
= (TEPL(T1 ) − TIPL(T1 )) + (TEPL(T2 ) − TIPL(T1 )) + 2
IV
= 2n1 + 2n2 + 2 = 2n
Unser nächstes Ziel ist es nachzuweisen, dass die mittlere Weglänge in
Binärbäumen mindestens logarithmisch mit der Knotenzahl wächst.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 41 / 63
(1)
Totale äußere und innere Weglänge
Beweis (Fortsetzung)
Damit gilt
TEPL(T ) − TIPL(T )
= (TEPL(T1 ) − TIPL(T1 )) + (TEPL(T2 ) − TIPL(T1 )) + 2
IV
= 2n1 + 2n2 + 2 = 2n
Unser nächstes Ziel ist es nachzuweisen, dass die mittlere Weglänge in
Binärbäumen mindestens logarithmisch mit der Knotenzahl wächst.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 41 / 63
(1)
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1
4
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1
+
4 8
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1
+ +
4 8 8
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
+ + +
4 8 8 8
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
1
+ + + +
4 8 8 8 16
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
1
1
+ + + +
+
4 8 8 8 16 16
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
1
1
1
+ + + +
+
+
4 8 8 8 16 16 16
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
1
1
1
1
+ + + +
+
+
+
4 8 8 8 16 16 16 16
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
1
1
1
1
1
+ + + +
+
+
+
+
4 8 8 8 16 16 16 16 16
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
1
1
1
1
1
1
+ + + +
+
+
+
+
+
4 8 8 8 16 16 16 16 16 32
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
1
1
1
1
1
1
1
+ + + +
+
+
+
+
+
+
4 8 8 8 16 16 16 16 16 32 32
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Lemma
Es sei L die Menge der externen Knoten in einem Binärbaum T . Dann gilt:
X
2−d(l) = 1.
l∈L
Beispiel
1 1 1 1
1
1
1
1
1
1
1
+ + + +
+
+
+
+
+
+
=1
4 8 8 8 16 16 16 16 16 32 32
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 42 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis
Wie in einem Codierungsbaum, markieren wir an jedem inneren Knoten die
Kante zum linken Kind mit 0 und die zum rechten Kind mit 1.
Jedem Blatt l ∈ L entspricht dann eine eindeutige Bitfolge ωl = b1 . . . bd(l) .
Die Bitfolgen für alle Blätter sind präfixfrei, d.h. kei ωl ist Präfix der Folge
ωl ′ für ein anderes Blatt l ′ .
Sei D = d(T ) die Tiefe des tiefsten Blatts.
Jedes ωl kann man auf 2D−d(l) Arten zu einer Bitfolge der Länge D
verlängern. Oder anders ausgedrückt: ωl ist Präfix von 2D−d(l) Bitstrings der
Länge D.
Außerdem hat jeder Bitstring der Länge D genau ein ωl als Präfix.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 43 / 63
...
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis
Wie in einem Codierungsbaum, markieren wir an jedem inneren Knoten die
Kante zum linken Kind mit 0 und die zum rechten Kind mit 1.
Jedem Blatt l ∈ L entspricht dann eine eindeutige Bitfolge ωl = b1 . . . bd(l) .
Die Bitfolgen für alle Blätter sind präfixfrei, d.h. kei ωl ist Präfix der Folge
ωl ′ für ein anderes Blatt l ′ .
Sei D = d(T ) die Tiefe des tiefsten Blatts.
Jedes ωl kann man auf 2D−d(l) Arten zu einer Bitfolge der Länge D
verlängern. Oder anders ausgedrückt: ωl ist Präfix von 2D−d(l) Bitstrings der
Länge D.
Außerdem hat jeder Bitstring der Länge D genau ein ωl als Präfix.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 43 / 63
...
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis
Wie in einem Codierungsbaum, markieren wir an jedem inneren Knoten die
Kante zum linken Kind mit 0 und die zum rechten Kind mit 1.
Jedem Blatt l ∈ L entspricht dann eine eindeutige Bitfolge ωl = b1 . . . bd(l) .
Die Bitfolgen für alle Blätter sind präfixfrei, d.h. kei ωl ist Präfix der Folge
ωl ′ für ein anderes Blatt l ′ .
Sei D = d(T ) die Tiefe des tiefsten Blatts.
Jedes ωl kann man auf 2D−d(l) Arten zu einer Bitfolge der Länge D
verlängern. Oder anders ausgedrückt: ωl ist Präfix von 2D−d(l) Bitstrings der
Länge D.
Außerdem hat jeder Bitstring der Länge D genau ein ωl als Präfix.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 43 / 63
...
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis
Wie in einem Codierungsbaum, markieren wir an jedem inneren Knoten die
Kante zum linken Kind mit 0 und die zum rechten Kind mit 1.
Jedem Blatt l ∈ L entspricht dann eine eindeutige Bitfolge ωl = b1 . . . bd(l) .
Die Bitfolgen für alle Blätter sind präfixfrei, d.h. kei ωl ist Präfix der Folge
ωl ′ für ein anderes Blatt l ′ .
Sei D = d(T ) die Tiefe des tiefsten Blatts.
Jedes ωl kann man auf 2D−d(l) Arten zu einer Bitfolge der Länge D
verlängern. Oder anders ausgedrückt: ωl ist Präfix von 2D−d(l) Bitstrings der
Länge D.
Außerdem hat jeder Bitstring der Länge D genau ein ωl als Präfix.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 43 / 63
...
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis
Wie in einem Codierungsbaum, markieren wir an jedem inneren Knoten die
Kante zum linken Kind mit 0 und die zum rechten Kind mit 1.
Jedem Blatt l ∈ L entspricht dann eine eindeutige Bitfolge ωl = b1 . . . bd(l) .
Die Bitfolgen für alle Blätter sind präfixfrei, d.h. kei ωl ist Präfix der Folge
ωl ′ für ein anderes Blatt l ′ .
Sei D = d(T ) die Tiefe des tiefsten Blatts.
Jedes ωl kann man auf 2D−d(l) Arten zu einer Bitfolge der Länge D
verlängern. Oder anders ausgedrückt: ωl ist Präfix von 2D−d(l) Bitstrings der
Länge D.
Außerdem hat jeder Bitstring der Länge D genau ein ωl als Präfix.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 43 / 63
...
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis
Wie in einem Codierungsbaum, markieren wir an jedem inneren Knoten die
Kante zum linken Kind mit 0 und die zum rechten Kind mit 1.
Jedem Blatt l ∈ L entspricht dann eine eindeutige Bitfolge ωl = b1 . . . bd(l) .
Die Bitfolgen für alle Blätter sind präfixfrei, d.h. kei ωl ist Präfix der Folge
ωl ′ für ein anderes Blatt l ′ .
Sei D = d(T ) die Tiefe des tiefsten Blatts.
Jedes ωl kann man auf 2D−d(l) Arten zu einer Bitfolge der Länge D
verlängern. Oder anders ausgedrückt: ωl ist Präfix von 2D−d(l) Bitstrings der
Länge D.
Außerdem hat jeder Bitstring der Länge D genau ein ωl als Präfix.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 43 / 63
...
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis (Fortsetzung)
Zählen wir für jedes Blatt l die Anzahl aller Bitstrings der Länge D, die ωl
als Präfix haben, erhalten wir alle möglichen, d.h.
X
X
2D =
2D−d(l) = 2D
2−d(l) ,
l∈L
l∈L
was die Behauptung beweist.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 44 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Proposition
T sei ein Binärbaum mit N = n + 1 externen Knoten. Dann gilt
TEPL(T ) ≥ N log N.
Beweis
Die Logarithmusfunktion ist konkav, d.h. für M ≥ 2 und a1 , . . . , aM > 0 gilt:
!
M
M
1 X
1 X
log
ai ≥
log(ai ).
M
M
i =0
i =1
...
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 45 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Proposition
T sei ein Binärbaum mit N = n + 1 externen Knoten. Dann gilt
TEPL(T ) ≥ N log N.
Beweis
Die Logarithmusfunktion ist konkav, d.h. für M ≥ 2 und a1 , . . . , aM > 0 gilt:
!
M
M
1 X
1 X
log
ai ≥
log(ai ).
M
M
i =0
i =1
...
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 45 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis (Fortsetzung)
1.4
log x
Sekante
1.2
1
0.8
0.6
0.4
0.2
0
-0.2
-0.4
-0.6
0.8
1
1.2
1.4
1.6
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 46 / 63
1.8
2
2.2
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis (Fortsetzung)
Mit m = N = n + 1 und al = 2−d(l) für l ∈ L ergibt sich
!
1 X
1
1 X −d(l)
≥
log
2
−d(l) = − TEPL(T ).
N
N
N
l∈L
l∈L
Das führt zu




 1 X −d(l) 
 = N log N.
TEPL(T ) ≥ −N log 
2
N

 l∈L

| {z }
=1
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 47 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Beweis (Fortsetzung)
Mit m = N = n + 1 und al = 2−d(l) für l ∈ L ergibt sich
!
1 X
1
1 X −d(l)
≥
log
2
−d(l) = − TEPL(T ).
N
N
N
l∈L
l∈L
Das führt zu




 1 X −d(l) 
 = N log N.
TEPL(T ) ≥ −N log 
2
N

 l∈L

| {z }
=1
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 47 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Fazit
Die mittlere äußere Weglänge eines Binärbaumes mit N äußeren Knoten ist
≥ log(N).
Da TEPL(T ) = TIPL(T ) + 2n, ergibt sich
TIPL(T ) = TEPL(T ) − 2n ≥ (n + 1) log(n + 1) − 2n ≥ n(log n − 2).
Fazit
Die mittlere innere Weglänge eines Binärbaumes mit n inneren Knoten ist
≥ log(n) − 2.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 48 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Fazit
Die mittlere äußere Weglänge eines Binärbaumes mit N äußeren Knoten ist
≥ log(N).
Da TEPL(T ) = TIPL(T ) + 2n, ergibt sich
TIPL(T ) = TEPL(T ) − 2n ≥ (n + 1) log(n + 1) − 2n ≥ n(log n − 2).
Fazit
Die mittlere innere Weglänge eines Binärbaumes mit n inneren Knoten ist
≥ log(n) − 2.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 48 / 63
Was Sie schon immer über Binärbäume wissen
wollten ...
Fazit
Die mittlere äußere Weglänge eines Binärbaumes mit N äußeren Knoten ist
≥ log(N).
Da TEPL(T ) = TIPL(T ) + 2n, ergibt sich
TIPL(T ) = TEPL(T ) − 2n ≥ (n + 1) log(n + 1) − 2n ≥ n(log n − 2).
Fazit
Die mittlere innere Weglänge eines Binärbaumes mit n inneren Knoten ist
≥ log(n) − 2.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 48 / 63
Zufällig erzeugte binäre Suchbäume
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 49 / 63
Zufällig erzeugte binäre Suchbäume
T wird auf die folgende Art zufällig erzeugt:
Starte mit einem leeren Baum.
Füge alle Schlüssel aus der Menge S = {x1 , x2 , . . . , xn } in zufälliger
1
Reihenfolge ein, d.h. jede Reihenfolge hat die Wahrscheinlichkeit n!
.
Dann ist der erwartete (über die Eingabereihenfolgen gemittelte) mittlere
(über n Schlüssel x ∈ S gemittelte) Aufwand für lookup(x):
1+
A(n)
n
mit
A(n) = E (TIPL(T )).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 50 / 63
Zufällig erzeugte binäre Suchbäume
T wird auf die folgende Art zufällig erzeugt:
Starte mit einem leeren Baum.
Füge alle Schlüssel aus der Menge S = {x1 , x2 , . . . , xn } in zufälliger
1
Reihenfolge ein, d.h. jede Reihenfolge hat die Wahrscheinlichkeit n!
.
Dann ist der erwartete (über die Eingabereihenfolgen gemittelte) mittlere
(über n Schlüssel x ∈ S gemittelte) Aufwand für lookup(x):
1+
A(n)
n
mit
A(n) = E (TIPL(T )).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 50 / 63
Zufällig erzeugte binäre Suchbäume
T wird auf die folgende Art zufällig erzeugt:
Starte mit einem leeren Baum.
Füge alle Schlüssel aus der Menge S = {x1 , x2 , . . . , xn } in zufälliger
1
Reihenfolge ein, d.h. jede Reihenfolge hat die Wahrscheinlichkeit n!
.
Dann ist der erwartete (über die Eingabereihenfolgen gemittelte) mittlere
(über n Schlüssel x ∈ S gemittelte) Aufwand für lookup(x):
1+
A(n)
n
mit
A(n) = E (TIPL(T )).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 50 / 63
Zufällig erzeugte binäre Suchbäume
T wird auf die folgende Art zufällig erzeugt:
Starte mit einem leeren Baum.
Füge alle Schlüssel aus der Menge S = {x1 , x2 , . . . , xn } in zufälliger
1
Reihenfolge ein, d.h. jede Reihenfolge hat die Wahrscheinlichkeit n!
.
Dann ist der erwartete (über die Eingabereihenfolgen gemittelte) mittlere
(über n Schlüssel x ∈ S gemittelte) Aufwand für lookup(x):
1+
A(n)
n
mit
A(n) = E (TIPL(T )).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 50 / 63
Die erwartete innere Weglänge
Wie kann A(n) = E (TIPL(T )) abgeschätzt werden?
Offensichtlich gilt A(0) = 0, denn TIPL() = 0.
A(1) = 0, denn der Baum hat nur einen inneren Knoten mit Tiefe 0.
Außerdem A(2) = 1, denn in diesem Fall ist TIPL(T ) = 1.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 51 / 63
Die erwartete innere Weglänge
Wie kann A(n) = E (TIPL(T )) abgeschätzt werden?
Offensichtlich gilt A(0) = 0, denn TIPL() = 0.
A(1) = 0, denn der Baum hat nur einen inneren Knoten mit Tiefe 0.
Außerdem A(2) = 1, denn in diesem Fall ist TIPL(T ) = 1.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 51 / 63
Die erwartete innere Weglänge
Wie kann A(n) = E (TIPL(T )) abgeschätzt werden?
Offensichtlich gilt A(0) = 0, denn TIPL() = 0.
A(1) = 0, denn der Baum hat nur einen inneren Knoten mit Tiefe 0.
Außerdem A(2) = 1, denn in diesem Fall ist TIPL(T ) = 1.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 51 / 63
Die erwartete innere Weglänge
Wie kann A(n) = E (TIPL(T )) abgeschätzt werden?
Offensichtlich gilt A(0) = 0, denn TIPL() = 0.
A(1) = 0, denn der Baum hat nur einen inneren Knoten mit Tiefe 0.
Außerdem A(2) = 1, denn in diesem Fall ist TIPL(T ) = 1.
b
b
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 51 / 63
b
Die erwartete innere Weglänge
Für n = 3 gibt es 6 Enfügereihenfolgen für {x1 , x2 , x3 } = {1, 2, 3}.
123
132
1
1
2
3
3
312
321
3
3
1
2
2
1
2
213
231
2
2
3
A(3) =
1
1
TIPL = 2
3
8
1
· (4 · 3 + 2 · 2) = .
6
3
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 52 / 63
TIPL = 3
Die erwartete innere Weglänge
Für n = 3 gibt es 6 Enfügereihenfolgen für {x1 , x2 , x3 } = {1, 2, 3}.
123
132
1
1
2
3
3
312
321
3
3
1
2
2
1
2
213
231
2
2
3
A(3) =
1
1
TIPL = 2
3
8
1
· (4 · 3 + 2 · 2) = .
6
3
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 52 / 63
TIPL = 3
Eine Rekursionsformel
Wenn xi der erste eingefügte Schlüssel ist, dann enthält der linke Unterbaum
i − 1 Schlüssel und der rechte n − i.
xi
x1 , . . . , xi −1
xi +1 , . . . , xn
Die Unterbäume sind selbst zufällig erzeugte binäre Suchbäume.
Da der Weg in T zu jedem der n − 1 Knoten in den beiden Unterbäumen um
eins Länger ist, gilt
TIPL(T ) = (i − 1) + TIPL(T1 ) + (n − i) + TIPL(T2 )
= (n − 1) + TIPL(T1 ) + TIPL(T2 ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 53 / 63
Eine Rekursionsformel
Wenn xi der erste eingefügte Schlüssel ist, dann enthält der linke Unterbaum
i − 1 Schlüssel und der rechte n − i.
xi
x1 , . . . , xi −1
xi +1 , . . . , xn
Die Unterbäume sind selbst zufällig erzeugte binäre Suchbäume.
Da der Weg in T zu jedem der n − 1 Knoten in den beiden Unterbäumen um
eins Länger ist, gilt
TIPL(T ) = (i − 1) + TIPL(T1 ) + (n − i) + TIPL(T2 )
= (n − 1) + TIPL(T1 ) + TIPL(T2 ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 53 / 63
Eine Rekursionsformel
Wenn xi der erste eingefügte Schlüssel ist, dann enthält der linke Unterbaum
i − 1 Schlüssel und der rechte n − i.
xi
x1 , . . . , xi −1
xi +1 , . . . , xn
Die Unterbäume sind selbst zufällig erzeugte binäre Suchbäume.
Da der Weg in T zu jedem der n − 1 Knoten in den beiden Unterbäumen um
eins Länger ist, gilt
TIPL(T ) = (i − 1) + TIPL(T1 ) + (n − i) + TIPL(T2 )
= (n − 1) + TIPL(T1 ) + TIPL(T2 ).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 53 / 63
Eine Rekursionsformel
Für den Erwartungswert gilt dann:
E (TIPL(n) | falls xi als erster ) = (n − 1) + A(i − 1) + A(n − i)
Da jeder Schlüssel mit der Wahrscheinlichkeit
ergibt sich
A(n) =
1
n
als erster eingefügt wird,
n
1X
E (TIPL(n) | falls xi als erster )
n
i =1
n
1X
=
((n − 1) + A(i − 1) + A(n − i))
n
i =1
= (n − 1) +
n
1X
(A(i − 1) + A(n − i)) .
n
i =1
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 54 / 63
Eine Rekursionsformel
Für den Erwartungswert gilt dann:
E (TIPL(n) | falls xi als erster ) = (n − 1) + A(i − 1) + A(n − i)
Da jeder Schlüssel mit der Wahrscheinlichkeit
ergibt sich
A(n) =
1
n
als erster eingefügt wird,
n
1X
E (TIPL(n) | falls xi als erster )
n
i =1
n
1X
=
((n − 1) + A(i − 1) + A(n − i))
n
i =1
= (n − 1) +
n
1X
(A(i − 1) + A(n − i)) .
n
i =1
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 54 / 63
Eine Rekursionsformel
Umordnen und Ausnutzen von A(0) = 0 ergibt
n−1
A(n) = (n − 1) +
2X
A(i)
n
i =1
Man erhält
A(1) = (1 − 1) +
A(2) = (2 − 1) +
A(3) = (3 − 1) +
A(4) = (4 − 1) +
A(5) = (5 − 1) +
2
1
2
2
2
3
2
4
2
5
·0
=0
·0
=1
8
3
8
29
· (0 + 1 + )
=
3
6
8 29
37
· (0 + 1 + + )=
3
6
5
· (0 + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 55 / 63
=
Eine Rekursionsformel
Umordnen und Ausnutzen von A(0) = 0 ergibt
n−1
A(n) = (n − 1) +
2X
A(i)
n
i =1
Man erhält
A(1) = (1 − 1) +
A(2) = (2 − 1) +
A(3) = (3 − 1) +
A(4) = (4 − 1) +
A(5) = (5 − 1) +
2
1
2
2
2
3
2
4
2
5
·0
=0
·0
=1
8
3
8
29
· (0 + 1 + )
=
3
6
8 29
37
· (0 + 1 + + )=
3
6
5
· (0 + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 55 / 63
=
Eine Rekursionsformel
Umordnen und Ausnutzen von A(0) = 0 ergibt
n−1
A(n) = (n − 1) +
2X
A(i)
n
i =1
Man erhält
A(1) = (1 − 1) +
A(2) = (2 − 1) +
A(3) = (3 − 1) +
A(4) = (4 − 1) +
A(5) = (5 − 1) +
2
1
2
2
2
3
2
4
2
5
·0
=0
·0
=1
8
3
8
29
· (0 + 1 + )
=
3
6
8 29
37
· (0 + 1 + + )=
3
6
5
· (0 + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 55 / 63
=
Eine Rekursionsformel
Umordnen und Ausnutzen von A(0) = 0 ergibt
n−1
A(n) = (n − 1) +
2X
A(i)
n
i =1
Man erhält
A(1) = (1 − 1) +
A(2) = (2 − 1) +
A(3) = (3 − 1) +
A(4) = (4 − 1) +
A(5) = (5 − 1) +
2
1
2
2
2
3
2
4
2
5
·0
=0
·0
=1
8
3
8
29
· (0 + 1 + )
=
3
6
8 29
37
· (0 + 1 + + )=
3
6
5
· (0 + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 55 / 63
=
Eine Rekursionsformel
Umordnen und Ausnutzen von A(0) = 0 ergibt
n−1
A(n) = (n − 1) +
2X
A(i)
n
i =1
Man erhält
A(1) = (1 − 1) +
A(2) = (2 − 1) +
A(3) = (3 − 1) +
A(4) = (4 − 1) +
A(5) = (5 − 1) +
2
1
2
2
2
3
2
4
2
5
·0
=0
·0
=1
8
3
8
29
· (0 + 1 + )
=
3
6
8 29
37
· (0 + 1 + + )=
3
6
5
· (0 + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 55 / 63
=
Eine Rekursionsformel
Umordnen und Ausnutzen von A(0) = 0 ergibt
n−1
A(n) = (n − 1) +
2X
A(i)
n
i =1
Man erhält
A(1) = (1 − 1) +
A(2) = (2 − 1) +
A(3) = (3 − 1) +
A(4) = (4 − 1) +
A(5) = (5 − 1) +
2
1
2
2
2
3
2
4
2
5
·0
=0
·0
=1
8
3
8
29
· (0 + 1 + )
=
3
6
8 29
37
· (0 + 1 + + )=
3
6
5
· (0 + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 55 / 63
=
Eine Rekursionsformel
Um eine geschlossene Darstellung von A(n) zu erhalten, stellen wir zuerst
einen direkten Zusammenhang zwischen A(n) und A(n − 1) her.
Multiplikation mit n ergibt:
nA(n) = n(n − 1) + 2 ·
n−1
X
A(i)
i =1
und für n − 1:
(n − 1)A(n − 1) = (n − 1)(n − 2) + 2 ·
n−2
X
A(i)
i =1
Wie man sieht, kommen alle Terme für i ≤ n − 2 in beiden Ausdrücken vor.
Subtraktion führt daher zu
nA(n) − (n − 1)A(n − 1) = n(n − 1) − (n − 1)(n − 2) + 2 · A(n − 1)
= 2(n − 1) + 2 · A(n − 1).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 56 / 63
Eine Rekursionsformel
Um eine geschlossene Darstellung von A(n) zu erhalten, stellen wir zuerst
einen direkten Zusammenhang zwischen A(n) und A(n − 1) her.
Multiplikation mit n ergibt:
nA(n) = n(n − 1) + 2 ·
n−1
X
A(i)
i =1
und für n − 1:
(n − 1)A(n − 1) = (n − 1)(n − 2) + 2 ·
n−2
X
A(i)
i =1
Wie man sieht, kommen alle Terme für i ≤ n − 2 in beiden Ausdrücken vor.
Subtraktion führt daher zu
nA(n) − (n − 1)A(n − 1) = n(n − 1) − (n − 1)(n − 2) + 2 · A(n − 1)
= 2(n − 1) + 2 · A(n − 1).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 56 / 63
Eine Rekursionsformel
Um eine geschlossene Darstellung von A(n) zu erhalten, stellen wir zuerst
einen direkten Zusammenhang zwischen A(n) und A(n − 1) her.
Multiplikation mit n ergibt:
nA(n) = n(n − 1) + 2 ·
n−1
X
A(i)
i =1
und für n − 1:
(n − 1)A(n − 1) = (n − 1)(n − 2) + 2 ·
n−2
X
A(i)
i =1
Wie man sieht, kommen alle Terme für i ≤ n − 2 in beiden Ausdrücken vor.
Subtraktion führt daher zu
nA(n) − (n − 1)A(n − 1) = n(n − 1) − (n − 1)(n − 2) + 2 · A(n − 1)
= 2(n − 1) + 2 · A(n − 1).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 56 / 63
Eine Rekursionsformel
Um eine geschlossene Darstellung von A(n) zu erhalten, stellen wir zuerst
einen direkten Zusammenhang zwischen A(n) und A(n − 1) her.
Multiplikation mit n ergibt:
nA(n) = n(n − 1) + 2 ·
n−1
X
A(i)
i =1
und für n − 1:
(n − 1)A(n − 1) = (n − 1)(n − 2) + 2 ·
n−2
X
A(i)
i =1
Wie man sieht, kommen alle Terme für i ≤ n − 2 in beiden Ausdrücken vor.
Subtraktion führt daher zu
nA(n) − (n − 1)A(n − 1) = n(n − 1) − (n − 1)(n − 2) + 2 · A(n − 1)
= 2(n − 1) + 2 · A(n − 1).
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 56 / 63
Eine Rekursionsformel
n · A(n) − (n − 1) · A(n − 1) = 2(n − 1) + 2 · A(n − 1)
ist äquivalent zu
n · A(n) − (n + 1) · A(n − 1) = 2(n − 1)
Division durch n(n + 1) ergibt
A(n)
A(n − 1)
2(n − 1)
−
=
.
n+1
n
n(n + 1)
Mittels Z (n) :=
A(n)
n+1
erhält man
Z (0) = 0
Z (n) − Z (n − 1) =
2(n − 1)
n(n + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 57 / 63
für n ≥ 1.
Eine Rekursionsformel
n · A(n) − (n − 1) · A(n − 1) = 2(n − 1) + 2 · A(n − 1)
ist äquivalent zu
n · A(n) − (n + 1) · A(n − 1) = 2(n − 1)
Division durch n(n + 1) ergibt
A(n − 1)
2(n − 1)
A(n)
−
=
.
n+1
n
n(n + 1)
Mittels Z (n) :=
A(n)
n+1
erhält man
Z (0) = 0
Z (n) − Z (n − 1) =
2(n − 1)
n(n + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 57 / 63
für n ≥ 1.
Eine Rekursionsformel
n · A(n) − (n − 1) · A(n − 1) = 2(n − 1) + 2 · A(n − 1)
ist äquivalent zu
n · A(n) − (n + 1) · A(n − 1) = 2(n − 1)
Division durch n(n + 1) ergibt
A(n)
A(n − 1)
2(n − 1)
−
=
.
n+1
n
n(n + 1)
Mittels Z (n) :=
A(n)
n+1
erhält man
Z (0) = 0
Z (n) − Z (n − 1) =
2(n − 1)
n(n + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 57 / 63
für n ≥ 1.
Eine Rekursionsformel
n · A(n) − (n − 1) · A(n − 1) = 2(n − 1) + 2 · A(n − 1)
ist äquivalent zu
n · A(n) − (n + 1) · A(n − 1) = 2(n − 1)
Division durch n(n + 1) ergibt
A(n)
A(n − 1)
2(n − 1)
−
=
.
n+1
n
n(n + 1)
Mittels Z (n) :=
A(n)
n+1
erhält man
Z (0) = 0
Z (n) − Z (n − 1) =
2(n − 1)
n(n + 1)
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 57 / 63
für n ≥ 1.
Eine Rekursionsformel
Z (n) = Z (n − 1) +
2(n − 1)
;
n(n + 1)
Z (0) = 0
Für n ≥ 1 ergibt sich induktiv
Z (n) =
n
X
2(i − 1)
i(i + 1)
i =1
n
X
2(i + 1) − 4
=
i(i + 1)
i =1
n
X 2
4
.
−
=
i
i(i + 1)
i =1
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 58 / 63
Eine Rekursionsformel
Z (n) = Z (n − 1) +
2(n − 1)
;
n(n + 1)
Z (0) = 0
Für n ≥ 1 ergibt sich induktiv
Z (n) =
n
X
2(i − 1)
i(i + 1)
i =1
n
X
2(i + 1) − 4
=
i(i + 1)
i =1
n
X 2
4
.
−
=
i
i(i + 1)
i =1
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 58 / 63
Eine Rekursionsformel
Z (n) =
n X
2
i
i =1
Mit
Hn =
−
n
X
i =1
n
X
1
=
i(i + 1)
i =1
1
1
−
i
i +1
=
i
n
X
1
i =1
gibt dies
Z (n) = 2Hn − 4 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
n
X
1
i =1
und
4
i(i + 1)
Seite 59 / 63
i
−
4
.
n+1
n+1
X
1
i =2
i
=1−
1
n+1
Eine Rekursionsformel
Z (n) =
n X
2
i
i =1
Mit
Hn =
−
n
X
i =1
n
X
1
=
i(i + 1)
i =1
1
1
−
i
i +1
=
i
n
X
1
i =1
gibt dies
Z (n) = 2Hn − 4 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
n
X
1
i =1
und
4
i(i + 1)
Seite 59 / 63
i
−
4
.
n+1
n+1
X
1
i =2
i
=1−
1
n+1
Eine Rekursionsformel
Z (n) =
n X
2
i
i =1
Mit
Hn =
−
n
X
i =1
n
X
1
=
i(i + 1)
i =1
1
1
−
i
i +1
=
i
n
X
1
i =1
gibt dies
Z (n) = 2Hn − 4 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
n
X
1
i =1
und
4
i(i + 1)
Seite 59 / 63
i
−
4
.
n+1
n+1
X
1
i =2
i
=1−
1
n+1
Eine Rekursionsformel
Z (n) =
n X
2
i
i =1
Mit
Hn =
−
n
X
i =1
n
X
1
=
i(i + 1)
i =1
1
1
−
i
i +1
=
i
n
X
1
i =1
gibt dies
Z (n) = 2Hn − 4 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
n
X
1
i =1
und
4
i(i + 1)
Seite 59 / 63
i
−
4
.
n+1
n+1
X
1
i =2
i
=1−
1
n+1
Eine Rekursionsformel
Z (n) =
n X
2
i
i =1
Mit
Hn =
−
n
X
i =1
n
X
1
=
i(i + 1)
i =1
1
1
−
i
i +1
=
i
n
X
1
i =1
gibt dies
Z (n) = 2Hn − 4 +
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
n
X
1
i =1
und
4
i(i + 1)
Seite 59 / 63
i
−
4
.
n+1
n+1
X
1
i =2
i
=1−
1
n+1
Eine Rekursionsformel
Z (n) = 2Hn − 4 +
4
n+1
Mit der Definition von Z (n) ergibt sich
A(n) = 2(n + 1)Hn − 4(n + 1) + 4
Die erwartete mittlere Knotentiefe ist also
A(n)
Hn
= 2Hn − 4 + 2 .
n
n
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 60 / 63
Eine Rekursionsformel
Z (n) = 2Hn − 4 +
4
n+1
Mit der Definition von Z (n) ergibt sich
A(n) = 2(n + 1)Hn − 4(n + 1) + 4
Die erwartete mittlere Knotentiefe ist also
A(n)
Hn
= 2Hn − 4 + 2 .
n
n
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 60 / 63
Eine Rekursionsformel
Z (n) = 2Hn − 4 +
4
n+1
Mit der Definition von Z (n) ergibt sich
A(n) = 2(n + 1)Hn − 4(n + 1) + 4
Die erwartete mittlere Knotentiefe ist also
A(n)
Hn
= 2Hn − 4 + 2 .
n
n
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 60 / 63
Eine Rekursionsformel
A(n)
Hn
= 2Hn − 4 + 2
n
n
Aus der Übung wissen wir
ln(n) < ln(n + 1) ≤ Hn ≤ 1 + ln n
für n ≥ 2
und somit
2 ln n − 4 + 2
A(n)
1 + ln n
ln n
<
≤ 2(1 + ln n) − 4 + 2
.
n
n
n
Da für n → ∞ der letzte Term gegen 0 geht, ergibt sich
2 ln n − 4 + o(1) <
A(n)
≤ 2 ln n − 2 + o(1).
n
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 61 / 63
Eine Rekursionsformel
A(n)
Hn
= 2Hn − 4 + 2
n
n
Aus der Übung wissen wir
ln(n) < ln(n + 1) ≤ Hn ≤ 1 + ln n
für n ≥ 2
und somit
2 ln n − 4 + 2
A(n)
1 + ln n
ln n
<
≤ 2(1 + ln n) − 4 + 2
.
n
n
n
Da für n → ∞ der letzte Term gegen 0 geht, ergibt sich
2 ln n − 4 + o(1) <
A(n)
≤ 2 ln n − 2 + o(1).
n
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 61 / 63
Eine Rekursionsformel
A(n)
Hn
= 2Hn − 4 + 2
n
n
Aus der Übung wissen wir
ln(n) < ln(n + 1) ≤ Hn ≤ 1 + ln n
für n ≥ 2
und somit
2 ln n − 4 + 2
A(n)
1 + ln n
ln n
<
≤ 2(1 + ln n) − 4 + 2
.
n
n
n
Da für n → ∞ der letzte Term gegen 0 geht, ergibt sich
2 ln n − 4 + o(1) <
A(n)
≤ 2 ln n − 2 + o(1).
n
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 61 / 63
Eine Rekursionsformel
A(n)
Hn
= 2Hn − 4 + 2
n
n
Aus der Übung wissen wir
ln(n) < ln(n + 1) ≤ Hn ≤ 1 + ln n
für n ≥ 2
und somit
2 ln n − 4 + 2
A(n)
1 + ln n
ln n
<
≤ 2(1 + ln n) − 4 + 2
.
n
n
n
Da für n → ∞ der letzte Term gegen 0 geht, ergibt sich
2 ln n − 4 + o(1) <
A(n)
≤ 2 ln n − 2 + o(1).
n
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 61 / 63
Fazit
In zufällig erzeugten binären Suchbäumen ist die erwartete mittlere
Knotentiefe logarithmisch, d.h. A(n)
n ∈ Θ(log n).
Konsequenz
Die erwartete mittlere Laufzeit von lookup, insert und delete liegt in
Θ(log n).
Da die minimale Tiefe in Ω(log n) liegt, ist die erwartete Laufzeit
asymptotisch optimal.
In der Regel ist die Einfügereihenfolge nicht zufällig.
Ungünstig sind partiell geordnete Reihenfolgen, da dann tiefe Teilbäume
entstehen.
Häufiges Löschen mit deleteMin zerstört die Balancierung, da nur aus
dem linken Teilbaum Knoten entfernt werden.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 62 / 63
Fazit
In zufällig erzeugten binären Suchbäumen ist die erwartete mittlere
Knotentiefe logarithmisch, d.h. A(n)
n ∈ Θ(log n).
Konsequenz
Die erwartete mittlere Laufzeit von lookup, insert und delete liegt in
Θ(log n).
Da die minimale Tiefe in Ω(log n) liegt, ist die erwartete Laufzeit
asymptotisch optimal.
In der Regel ist die Einfügereihenfolge nicht zufällig.
Ungünstig sind partiell geordnete Reihenfolgen, da dann tiefe Teilbäume
entstehen.
Häufiges Löschen mit deleteMin zerstört die Balancierung, da nur aus
dem linken Teilbaum Knoten entfernt werden.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 62 / 63
Fazit
In zufällig erzeugten binären Suchbäumen ist die erwartete mittlere
Knotentiefe logarithmisch, d.h. A(n)
n ∈ Θ(log n).
Konsequenz
Die erwartete mittlere Laufzeit von lookup, insert und delete liegt in
Θ(log n).
Da die minimale Tiefe in Ω(log n) liegt, ist die erwartete Laufzeit
asymptotisch optimal.
In der Regel ist die Einfügereihenfolge nicht zufällig.
Ungünstig sind partiell geordnete Reihenfolgen, da dann tiefe Teilbäume
entstehen.
Häufiges Löschen mit deleteMin zerstört die Balancierung, da nur aus
dem linken Teilbaum Knoten entfernt werden.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 62 / 63
Fazit
In zufällig erzeugten binären Suchbäumen ist die erwartete mittlere
Knotentiefe logarithmisch, d.h. A(n)
n ∈ Θ(log n).
Konsequenz
Die erwartete mittlere Laufzeit von lookup, insert und delete liegt in
Θ(log n).
Da die minimale Tiefe in Ω(log n) liegt, ist die erwartete Laufzeit
asymptotisch optimal.
In der Regel ist die Einfügereihenfolge nicht zufällig.
Ungünstig sind partiell geordnete Reihenfolgen, da dann tiefe Teilbäume
entstehen.
Häufiges Löschen mit deleteMin zerstört die Balancierung, da nur aus
dem linken Teilbaum Knoten entfernt werden.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 62 / 63
Fazit
In zufällig erzeugten binären Suchbäumen ist die erwartete mittlere
Knotentiefe logarithmisch, d.h. A(n)
n ∈ Θ(log n).
Konsequenz
Die erwartete mittlere Laufzeit von lookup, insert und delete liegt in
Θ(log n).
Da die minimale Tiefe in Ω(log n) liegt, ist die erwartete Laufzeit
asymptotisch optimal.
In der Regel ist die Einfügereihenfolge nicht zufällig.
Ungünstig sind partiell geordnete Reihenfolgen, da dann tiefe Teilbäume
entstehen.
Häufiges Löschen mit deleteMin zerstört die Balancierung, da nur aus
dem linken Teilbaum Knoten entfernt werden.
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 62 / 63
Weiter geht es mit
Balancierten Suchbäumen
Algorithmen und Datenstrukturen SS09
M. Brinkmeier
TU Ilmenau
Seite 63 / 63