Teil 7: Bäume Beispiele (1)

Teil 7:
Bäume
•! Beispiele
•! Definition und Eigenschaften
•! Implementierungen
•! Durchlaufen von Bäumen
•! Binäre Suchbäume
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-1
Beispiele (1)
Bäume gehören zu den wichtigsten Datenstrukturen in der Informatik.
Entscheidungsbäume
Minimum von
3 Zahlen
x ! y
1 0
Entscheidungsknoten
x ! z
y ! z
1 0 1 0
min=x min=z min=y min=z
Aktionsknoten
Syntaxbäume
Syntaxbaum für den
arithmetischen Ausdruck
(a - b) * c
*
- c
a
b
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-2

Beispiele (2)
Verzeichnis-Strukturen
Ausschnitt aus einer
Unix-Verzeichnis-Struktur
/
Wurzelverzeichnis
bin
etc
usr
dev
ls date who passwd src bin tty00 tty01
date.c
who.c
Verzeichnisknoten
Dateiknoten
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-3
Bäume: Definition und Begriffe (1)
Bäume lassen sich am einfachsten rekursiv definieren:
(1)! Ein einzelner Knoten
ist ein Baum.
(2)! Falls B 1 , B 2 , …, B n (n " 1) Bäume sind, dann ist auch
B 1 B 2
B n
Wurzel
Teilbäume
ein Baum.
Hier hängen n Bäume an einem Knoten, der auch Wurzel genannt wird.
Die Verbindungslinien heißen Kanten.
Die Bäume B 1 , B 2 , …, B n werden auch Teilbäume genannt.
(In der Informatik wachsen also Bäume in anderer Richtung als in der Natur!)
(3)! Außerdem wollen wir auch die leere Menge als Baum (leerer Baum) definieren.
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-4

Bäume: Definition und Begriffe (2)
Beispiel:
Dieser Baum entsteht durch
•! mehrmaliges Anwenden der Regel (1) und
•! 2-maliges Anwenden der Regel (2)
Weitere Begriffe:
•!
•!
•!
•!
Die Knoten unterhalb eines Knoten k werden auch
Kindknoten und k Elternknoten genannt.
Knoten ohne Kinder werden Blätter genannt.
Ein Baum heißt geordnet, falls die Reihenfolge der
Kinder eine Rolle spielt
(s. Bsp. Syntaxbaum für arithm. Ausdruck)
Üblicherweise enthalten die Knoten Daten.
Man spricht dann von einem markierten Baum.
…
…
Elternknoten
Kindknoten
Blätter
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-5
Bäume: Definition und Begriffe (3)
Weitere Begriffe:
•!
Die Tiefe eines Knotens ist sein Abstand zur Wurzel,
d.h. die Anzahl der Kanten von der Wurzel zu dem Knoten.
•!
•!
Die Menge aller Knoten der Tiefe i wird auch i-te Ebene
(level) genannt.
Die Höhe eines Baums ist die maximale Tiefe,
die von einem Knoten erreicht werden kann.
Beispiel
Ein Baum der
Höhe 2.
Ebene 0
Ebene 1
Ebene 2
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-6

Definition
Binärbäume
Ein Binärbaum ist ein geordneter Baum, bei dem jeder Knoten maximal 2 Kinder hat.
Die beiden Kinder werden linkes und rechtes Kind genannt.
Hat ein Knoten nur ein Kind, dann muss es entweder ein linkes oder ein rechtes Kind sein.
Beispiele
a
b
B 1 B 2
B 3
Bäume B 2 und B 3 sind strukturell unterschiedlich:
in B 2 hat Knoten a einen linken Sohn während in
B 3 Knoten b nur einen rechten Sohn hat.
B 4
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-7
Definition
Vollständige Binärbäume
Ein vollständiger Binärbaum ist ein Binärbaum, bei der jeder Ebene (bis auf die letzte)
vollständig gefüllt und die letzte Ebene von links nach rechts gefüllt ist.
Beispiele
Ebene 0
Ebene 1
Eigenschaften:
•!
B 1
Ein vollständiger Binärbaum der Höhe h mit vollständig gefüllter letzter Ebene hat
n = 2 0 + 2 1 + … + 2 h = 2 h+1 – 1
viele Knoten (vergleiche Baum B 3 ). Damit gilt auch
h = log 2 (n+1)-1 = #log 2 n$ (abgerundet!)
B 2
B 3
Ebene 2
Ebene 3
•!
Ein beliebiger vollständiger Binärbaum mit n Knoten (vergleiche Baum B 2 ) hat die Höhe
h = #log 2 n$
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-8

Teil 7:
Bäume
•! Beispiele
•! Definition und Eigenschaften
•! Implementierungen
•! Durchlaufen von Bäumen
•! Binäre Suchbäume
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-9
Implementierung von Binärbäumen
Implementierung mit verketteten Knoten
Jeder Knoten hat jeweils einen Zeiger
für das linke bzw. rechte Kind.
root
A
A
B
C
B
C
D
E
F
D E F
G
H
I
G
H
I
struct Node
{
int data;
Node* left; // linkes Kind
Node* right; // rechtes Kind
};
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-10

Implementierung von beliebigen Bäumen
Implementierung mit verketteten Knoten
Jeder Knoten enthält 2 Zeiger:
•! Ein Zeiger auf das erste Kind
•! Ein Zeiger für den rechts liegenden
Geschwisterknoten (engl. sibling)
root
A
A
B
C
D
E
F
G
B
C
D E F G
H I J K
H
I
J
K
L
M
L
M
struct Node
{
int data;
Node* firstChild;
Node* nextSibling;
};
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-11
Implementierung von vollständigen Binärbäumen
Implementierung mit einem Feld
Die Knoten werden ebenenweise in einem Feld abgespeichert.
Ebene 0
Ebene 1
5
8 7
a [0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
5 8 7 1 3 9 2 12 10 6
Ebene 2
1 3 9 2
Ebene 3
12 10 6
Effizienter Zugriff auf Eltern und Kinder:
•! Kinder von a[i]: a[2*i+1] und a[2*i+2] für i " 0
•! Elternknoten von a[i]: a[(i-1)/2] für i " 1 und mit ganzzahliger Division
Beispiel:
•! Kinder von a[3] = 1: a[7] = 12 und a[8] = 10
•! Elternknoten von a[6] = 2: a[(6-1)/2] = a[2] = 7
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-12

Teil 7:
Bäume
•! Beispiele
•! Definition und Eigenschaften
•! Implementierungen
•! Durchlaufen von Bäumen
•! Binäre Suchbäume
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-13
Ziel
Überblick
Das Besuchen aller Knoten in einer bestimmten Reihenfolge
ist eine oft benötigte Operation.
Durchlaufreihenfolgen
•! PreOrder: besuche Wurzel, besuche linken Teilbaum; besuche rechten Teilbaum;
•! PostOrder: besuche linken Teilbaum; besuche rechten Teilbaum; besuche Wurzel;
•! InOrder: besuche linken Teilbaum; besuche Wurzel; besuche rechten Teilbaum;
•! LevelOrder: besuche Knoten ebenenweise
Bemerkungen
•!
•!
Die Präfixe Pre, Post bzw. In bedeuten vorher, nachher und dazwischen.
Gemeint ist damit der Zeitpunkt, an dem die Wurzel besucht wird.
Um die Darstellung zu vereinfachen, werden wir die Durchlaufalgorithmen nur für
Binärbäume behandeln.
Die Algorithmen lassen sich in einfacher Weise auf allgemeine Bäume übertragen.
Der InOrder-Durchlauf ist jedoch nur für Binärbäume sinnvoll.
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-14

PreOrder-Durchlauf für Binärbäume
Algorithmus
void preOrder(Node* p)
{
if (p != 0)
{
bearbeite(p->data);
preOrder(p->left);
preOrder(p->right);
}
}
Beispiel
*
- c
// Definition eines Baums:
struct Node
{
int data;
Node* left; // linkes Kind
Node* right; // rechtes Kind
};
Node* root;
…
// Aufruf von preorder
preOrder(root);
Durchlaufreihenfolge:
* - a b c
a
b
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-15
PostOrder-Durchlauf für Binärbäume
Algorithmus
void postOrder(Node* p)
{
if (p != 0)
{
postOrder(p->left);
postOrder(p->right);
bearbeite(p->data);
}
}
Beispiel
*
- c
Durchlaufreihenfolge:
a b – c *
(Entspricht der sog. Postfix-Notation für
arithmetische Ausdrücke)
a
b
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-16

InOrder-Durchlauf für Binärbäume
Algorithmus
void inOrder(Node* p)
{
if (p != 0)
{
inOrder(p->left);
bearbeite(p->data);
inOrder(p->right);
}
}
Beispiel
*
- c
Durchlaufreihenfolge:
a – b * c
a
b
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-17
LevelOrder-Durchlauf für Binärbäume
Algorithmus
Die Knoten werden ebenenweise in einer Schlange (Queue) gespeichert
und in einer while-Schleife abgearbeitet.
void levelOrder(Node* p)
{
Queue queue;
queue.push(p); // Ebene 0
}
while ( !queue.empty() )
{
Node* q;
// Schreibe vorderstes Element aus Schlange
// nach q und lösche Element aus Schlange:
queue.front(q);
queue.remove();
if (q != 0)
{
bearbeite(q->data);
queue.push(q->left);
queue.push(q->right);
}
}
Beispiel
*
- c
a b
Durchlaufreihenfolge:
* – c a b
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-18

Aufgabe 7.1
Aufgaben
Beschreiben Sie anhand eines Beispiels, wie Sie Verzeichnisstrukturen textuell ausgeben
würden. Welche Durchlaufreihenfolge wählen Sie dabei?
Schreiben Sie einen Algorithmus, um Verzeichnisstrukturen auszugeben.
Aufgabe 7.2
Schreiben Sie einen Algorithmus, um die Speicherplatzgröße einer gesamten
Verzeichnisstruktur zu berechnen.
Es kann davon ausgegangen werden, dass die Speichergröße von jedem
Unterverzeichnis und jeder Datei beim entsprechenden Knoten abgespeichert ist.
/
bin
etc
usr
dev
ls date who passwd src bin tty00 tty01
date.c
who.c
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-19
Teil 7:
Bäume
•! Beispiele
•! Definition und Eigenschaften
•! Implementierungen
•! Durchlaufen von Bäumen
•! Binäre Suchbäume
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-20

Knoten
Definition von binären Suchbäumen
Alle Knoten in einem Baum enthalten
einen Schlüssel (Key) und evtl. weitere Daten (Value).
Definition
Ein binärer Suchbaum ist ein Binärbaum, bei dem
für alle Knoten k folgende Eigenschaften gelten:
struct Node
{
KeyType key;
ValueType value;
Node* left; // linkes Kind
Node* right; // rechtes Kind
};
(1)! Alle Schlüssel im linken Teilbaum sind kleiner als der Schlüssel im Knoten k
(2)! Alle Schlüssel im rechten Teilbaum sind größer als der Schlüssel im Knoten k
Beachte: Die Schlüssel müssen hier eindeutig sein. Es ist aber auch möglich, dass gleiche
Schlüssel mehrfach vorkommen dürfen, was kleine Änderungen in den Algorithmen erfordert.
Beispiele
7
2 8
6
2 8
1
3
Degenerierter
Suchbaum
1 4
4
4
3 6
3
In den Bäumen sind nur
die Schlüssel dargestellt.
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-21
7
Suchen in binären Suchbäumen
Operation searchR
bool searchR(KeyType k, ValueType& v, const Node* p);
Suche nach einem Knoten mit Schlüssel k im Teilbaum p.
Falls gefunden, wird der im Knoten abspeicherte Datenwert v und
der Rückgabewert true zurückgeliefert.
Falls nicht gefunden, wird der Rückgabewert false zurückgeliefert.
Algorithmus
Beispiel
bool searchR(KeyType k, ValueType& v, const Node* p)
{
p 7
if (p == 0)
R steht für
return false;
rekursiv
else if (k < p->key)
2 8
return searchR(k, v, p->left);
else if (k > p->key)
return searchR(k, v, p->right);
else // k gefunden
{
1 4
v = p->value;
return true;
3 6
}
} searchR(3,v,p)
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-22

Idee
Einfügen in binären Suchbäumen (1)
Um einen Schlüssel k einzufügen, wird zunächst nach dem Schlüssel k gesucht.
Falls der einzufügende Schlüssel k nicht bereits im Baum vorkommt, endet die Suche
erfolglos bei einem 0-Zeiger.
An dieser Stelle wird dann ein neuen Knoten mit Schlüssel k eingefügt.
Beispiel 1: füge 6 ein
Beispiel 2: füge 8 ein
7
7
7
7
2 9
2
9
2
9
2
9
1 4
1
4
1
4
1
4
8
3
3
6
3
6
3
6
Suche von 6 endet
bei 0-Zeiger
Ersetzte 0-Zeiger durch
Zeiger auf Knoten 6
Suche von 8 endet
bei 0-Zeiger
Ersetzte 0-Zeiger durch
Zeiger auf Knoten 8
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-23
Einfügen in binären Suchbäumen (2)
Operation insertR
bool insertR(KeyType k, ValueType v, Node*& p);
Fügt im Teilbaum p neuen Knoten mit Schlüssel k und Datenwert v ein.
Falls Schlüssel schon vorhanden, wird kein neuer Knoten eingefügt.
Beachte:
Der Parameter p ist ein Ein/Ausgabeparameter und daher als Referenzparameter
realisiert. Der Teilbaum wird gelesen und geändert.
Algorithmus
bool insertR(KeyType k, ValueType v, Node*& p)
{
if (p == 0) {
p = new Node;
p->key = k; p->value = v;
return true;
}
else if (k < p->key)
return insertR(k,v,p->left);
else if (k > p->key)
return insertR(k,v,p->right);
else // k bereits vorhanden
return false;
}
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-24
p
3
7
2 9
1 4
p
1
insert(6, v, p)
2
3
7
4
9
6

Löschen in binären Suchbäumen (1)
Idee
Um einen Schlüssel k zu löschen, wird zunächst nach dem Schlüssel k gesucht.
Es sind dann 4 Fälle zu unterscheiden:
Fall „Nicht vorhanden“:
Schlüssel k kommt nicht vor:
dann ist nichts zu tun.
Fall „Keine Kinder“:
Der Schlüssel kommt in einem Blatt vor (keine Kinder):
dann kann der Knoten einfach entfernt werden.
Fall „Ein Kind“:
Der Knoten mit dem gefundenen Schlüssel hat genau ein Kind:
s. nächste Folie
Fall „Zwei Kinder“:
Der Knoten mit dem gefunden Schlüssel hat zwei Kinder
s. übernächste Folie
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-25
Löschen in binären Suchbäumen (2)
Fall „Ein Kind“
Der zu löschende Knoten k hat genau ein Kind.
Überbrücke den Knoten k, indem der Elternknoten von k auf Kind von k verzeigert wird
(Bypass) und lösche k.
Beispiel: lösche Knoten mit Schlüssel 4
7
7
7
2
9
2
9
2
9
1
4
1
4
1
3
3
3
Suche 4
Knoten 4 wird
überbrückt (Bypass)
Knoten 4 wird
gelöscht
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-26

Löschen in binären Suchbäumen (3)
Fall „Zwei Kinder“ :
Der zu löschende Knoten k hat zwei Kinder.
1. Ersetze den Knoten k durch den kleinsten Knoten k min im rechten Teilbaum von k.
2. Lösche dann k min . Da der kleinste Knoten k min im linken Teilbaum kein linkes Kind hat,
kann das Löschen von k min wie im Fall „Ein Kind“ bzw. „Keine Kinder“ behandelt werden.
Beispiel: lösche Knoten mit Schlüssel 2
7
7
7
7
2
9
2
9
3
9
3
9
1
5
1
5
1
5
1
5
3
6
3
6
3
6
6
4
4
4
4
Suche 2
Suche kleinsten Knoten in
rechten Teilbaum von 2
Knoten 2 wird durch
kleinsten Knoten ersetzt
kleinster Knoten
wird gelöscht
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-27
Löschen in binären Suchbäumen (4)
bool removeR(KeyType k, Node*& p)
{
if (p == 0) // k nicht vorhanden
return false;
else if (k < p->key)
return removeR(k,p->left);
else if (k > p->key)
return removeR(k,p->right);
else if (p->left == 0 || p->right == 0) {
Node* temp = p;
if (p->left != 0)
}
p = p->left; // Bypass zu linkes Kind
else
p = p->right; // Bypass zu rechtes Kind
delete temp;
return true;
}
else {
// Min. im rechten Teilbaum suchen:
Node* min = searchMinR (p->right);
// Zu löschender Knoten durch Min. ersetzen
p->data = min->data; p->key = min->key;
// Min. in rechtem Teilbaum löschen:
return removeR (min->key, p->right);
}
Operation removeR
Löscht im Teilbaum p Knoten mit Schlüssel k.
Der Parameter p ist ein Ein/Ausgabeparameter
und daher ein Referenzparameter.
Knoten hat ein Kind
oder kein Kind
Knoten hat
zwei Kinder
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-28

Löschen in binären Suchbäumen (5)
Operation searchMinR
Sucht im Teilbaum p nach dem kleinsten Knoten und
liefert Zeiger auf Minimum zurück.
Node* searchMinR(const Node* p)
{
if (p == 0) // Minimum nicht vorhanden
return 0;
else if (p->left == 0) // Minimum gefunden
return p;
else
return searchMinR (p->left);
}
Bemerkung
Beachten Sie, dass in der Operation removeR im Fall „Knoten hat zwei Kinder“ der
Aufruf von searchMinR und der rekursive Aufruf von removeR bedeuten, dass zweimal
vom rechten Kind p->right zum kleinsten Knoten gelaufen wird.
Diese Ineffezienz lässt sich jedoch beheben, indem searchMinR noch zusätzlich das
Löschen des kleinsten Elements übernimmt. Der rekursive Aufruf von removeR ist dann
überflüssig.
Diese Variante findet sich in der Quell-Code-Sammlung zur Vorlesung.
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-29
Worst-Case
Analyse
Da im schlechtesten Fall ein binärer Suchbaum mit n Knoten zu einem Baum der Höhe
n-1 entarten kann (Bsp?), haben die Operationen zum Suchen, Einfügen und Löschen
eine maximale Suchlänge von n.
Damit: T max (n) = O(n)
Average-Case
In [Ottmann und Widmayer 2002] wird gezeigt, dass die durchschnittliche Laufzeit um
eine Größenordnung besser ist. Es werden zwei Ergebnisse hergeleitet, die sich darin
unterscheiden, welche Verteilung der Bäume angenommen wird:
•!
Bäume mit n Knoten entstehen durch eine Folge von Einfüge-Operationen von n
unterschiedlichen Elementen. Es wird angenommen, dass jede der n! möglichen
Anordnungen der Elemente gleichwahrscheinlich ist. Gemittelt wird dann über die n!
viele auf diese Weise erzeugten Bäume. Man erhält dann für die Such-Operation eine
mittlere Suchlänge von ungefähr 1.4 log 2 n.
Damit: T mit (n) = O(log 2 n)
•!
Es wird angenommen, dass alle strukturell verschiedenen binären Suchbäume mit n
Knoten gleichwahrscheinlich sind. Man erhält dann für die Such-Operation eine
mittlere Suchlänge von ungefähr
Damit: T mit (n) = O( )
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-30

Aufgabe 7.3
Aufgabe 7.4
Aufgaben (1)
Geben Sie den binären Suchbaum an, nachdem mit einem leeren Baum
begonnen wurde und folgende Operationen durchgeführt worden sind:
•! Einfügen von: 10, 5, 3, 8, 2, 4, 1, 15, 12, 17, 6, 7, 9
•! Löschen von: 2, 3, 5, 12, 10
Beseitigen Sie die beiden endrekursiven Aufrufe in der Funktion searchR.
Aufgabe 7.5
Schreiben Sie eine Funktion, die das größte Element in einem binären Suchbaum
findet und zurückliefert.
Aufgabe 7.6
Schreiben Sie eine Funktion makeEmpty, die den Speicherplatz für einen binären
Suchbaum vollständig freigibt.
Aufgabe 7.7
Schreiben Sie eine Funktion copy, die eine Kopie eines binären Suchbaums erstellt und
zurückliefert.
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-31
Aufgabe 7.8
Aufgaben (2)
Schreiben Sie eine Funktion save, die einen binären Suchbaum auf eine Datei schreibt
und eine Funktion read, die einen binären Suchbaum von einer Datei einliest.
Es sind 2 Varianten vorzusehen:
a)! Die Funktionen save und read sollen strukturerhaltend sein. D.h. nach
Abspeichern und wieder Einlesen hat der binäre Suchbaum die gleiche Struktur
wie zuvor.
b)! Die Funktionen save und read müssen nicht strukturerhaltend sein. Vielmehr
wird gefordert, dass beim Einlesen ein binärer Suchbaum mit minimaler Höhe
erzeugt wird.
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-32

Klasse BinarySearchTree
Ziel
Klasse BinarySearchTree, mit der sich eine Menge von Elementen,
bestehend aus Schlüssel und Wert effizient verwalten lassen.
Implementierung als binärer Suchbaum.
Beispiel: Telefonbucheintrag mit Schlüssel = Name und Werte = Telefonnummer.
Schnittstelle
•! search(k, v) Sucht nach Schlüssel k und liefert zugehörigen Wert v
(Ausgabeparameter) zurück
•! insert(k,v) Fügt neues Element mit Schlüssel k und Wert v ein
•! remove(k) Löscht Element mit Schlüssel k
Flexibilität durch Schablonenmechanismus
Der Schlüsseltyp und der Typ der Elementwerte sind parametrisiert.
Damit lassen sich verschiedene Anwendungen einfach realisieren.
Beispiele:
// Telefonbuch:
typedef string FamName;
typedef string TelNr;
Schlüssel-Typ
Elementwerte-Typ
// Wörterbuch:
typedef string Deutsch;
typedef string Englisch;
BinarySearchTree < FamName, TelNr> telBuch;
BinarySearchTree wBuch;
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-33
Öffentlicher Teil der Klasse BinärySearchTree
template
// KeyType erfordert Vergleichsoperatoren . ValueType erfordert Zuweisungsoperator =
class BinarySearchTree
{
Schlüssel-Typ
public:
BinarySearchTree() {root = 0;}
Elementwerte-Typ
~BinarySearchTree() {makeEmptyR(root);}
void traverse() const { traverseR(root);}
// Travesiert über alle Schlüssel in sortierter Reihenfolge und gibt Daten aus.
bool search(const KeyType& k, ValueType& v) const { return searchR(k,v,root);}
// Sucht Schlüssel k und liefert Wert v falls gefunden.
// Gibt true zurück, falls Schlüssel k gefunden wird, und sonst false.
bool insert(const KeyType& k, const ValueType& v) { return insertR(k,v,root);}
// Fügt neuen Schlüssel k mit Wert v ein. Falls Schlüssel bereits vorhanden ist,
// wird nicht eingefügt und false zurückgeliefert, sonst true.
bool remove(const KeyType& k) { return removeR(k,root);}
// Löscht Schlüssel k. Falls Schlüssel gelöscht werden konnte wird true zurückgeliefert
// und sonst false (d.h. Schlüssel war nicht vorhanden).
private:
// …
};
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-34

Privater Teil der Klasse BinärySearchTree
template
class BinarySearchTree
{
public:
// …
private:
struct Node
{
KeyType key;
Deklaration eines
ValueType value;
Binärbaums
Node* left;
Node* right;
// Konstruktor
Node(const KeyType& k, const ValueType& v) : key(k), value(v), left(0), right(0) {}
};
Node* root;
};
void traverseR(const Node* p) const;
bool searchR(const KeyType& k, ValueType& v, const Node* p) const;
bool insertR(const KeyType& k, const ValueType& v, Node*& p);
bool removeR(const KeyType& k, Node*& p);
Rekursive, private
Methoden
void getRemoveMin(KeyType& k, ValueType& v, Node*& p); // Hilfsmethode für removeR
void makeEmptyR(Node* p);
O. Bittel; Sept. 2008 Programmiertechnik 2 - Bäume 7-35