Claudio Moraga; Gisbert Dittrich

Präsentation zum Thema: "Claudio Moraga; Gisbert Dittrich"—  Präsentation transkript:

1 Claudio Moraga; Gisbert Dittrich
EINI-I Einführung in die Informatik für Naturwissenschaftler und Ingenieure I Kapitel 8 Claudio Moraga; Gisbert Dittrich FBI Unido

2 Gliederung Kapitel 8 Motivation Binärer Suchbaum
Suchen in einfach verketteter Liste + deren Nachteile Binärer Suchbaum Grobideen: Suchen, Suchstruktur Idee Baum Binärer Baum, Knotenmarkierung, Implementierung knotenmarkierter bin. Bäume, Suchbaum Suchen Einfügen Analyse

3 Suchen in einer Liste Ist L die leere Liste: i kann nicht in L sein.
Ist L nicht leer entweder i == L->Element oder i wird in L->weiter gesucht

4 Suchen in einer Liste bool Suchen (int i, Liste * L) { if (L == NULL)
return false; else return (L->Element == i? true: Suchen(i, L->weiter)); } Die Lösung des Problems, ein Element in einer Liste zu suchen, variiert die bisher zu Listen entwickelten Ideen: Um ein Element zu entfernen, muß man es bekanntlich erst finden. Die Grundidee ist wie folgt: Wenn in einer Liste L eine ganze Zahl i gesucht wird, dann ergibt die Suche das Resultat falsch, falls die leere Liste vorliegt, und den Wert wahr, falls das erste Element der Liste bereits unsere Zahl i enthält. Ist dies nicht der Fall, so wird als Resultat der Suche (in der gesamten Liste) das Ergebnis der Suche i (im Rest der Liste) zurückgegeben. Auch hier ergibt sich eine sehr natürliche Art der rekursiven Formulierung.

5 Suchen in einer Liste Problem: langsame Suche
jedes Element muß bei einer erfolglosen Suche betrachtet werden also: Suchzeit proportional zur Anzahl der Elemente in der Liste (lineare Suchzeit) Der vorgestellte Suchalgorithmus für das Suchen in einer linearen Liste ist einfach und elegant. Er hat allerdings ein Problem: Falls wir in der Liste erfolglos suchen und falls die Liste nicht geordnet ist, müssen wir die gesamte Liste durchlaufen. Die Anzahl der Vergleichsoperationen ist dann also proportional zur Anzahl der Elemente in dieser Liste. Das hört sich zunächst einmal recht unverbindlich an, daher soll ein Beispiel durchgerechnet werden.

6 Suchen in einer Liste Beispiel
erfolglose Suche bei 105 Elementen braucht 105 Vergleiche, also (pro Vergleich 10-1 sec.) 104 sec =~ 2,7 h Bei geschickter Anordnung der Daten geht´s mit ~ 35 Vergleichen, also in ~ 3.5 sec. Nehmen wir an, wir haben eine Milliarde Elemente, die durchsucht werden müssen, so benötigen wir eine Milliarde Vergleiche für eine erfolglose Suche. Wenn wir eine Zehntausendstel Sekunde für jeden Vergleich brauchen, so benötigen wir etwa 2 Std. 45 Min. für die Suche. Das ist ziemlich lang, wenn man bedenkt, daß die Suche auch viel schneller vor sich gehen könnte, nämlich in etwa einer Dreitausendstel Sekunde. Das wiederum geht natürlich nur dann, wenn wir die Daten geschickt anordnen, und darüber werden wir uns jetzt Gedanken machen.

7 Suche „in einer Hälfte“
Grobidee: Suchen in geordneter "Liste" durch Überprüfen des "mittleren" Elementes + Fortsetzung in einer Hälfte Beispiel: k: k:5 Seien die neun Zahlen 2,4,6,7,8,17,19,36,40 sortiert , d.h. der Größe nach angeordnet, gegeben. Sei eine Zahl i gegeben . Ist i in der angeordneten Menge der gegebenen Zahlen enthalten? Die Suche nach einer Zahl gestaltet sich dann effizient folgendermaßen: • Prüfe das "mittlere" Element. • Ist dies das gesuchte Element, so ist die Suche erfolgreich beendet. • Ist dies dort gefundene Element größer als das gesuchte, suche nach diesem Verfahren in der unteren Hälfte, ansonsten in der oberen Hälfte weiter. • Wird die zu untersuchende Hälfte "leer", so ist die Suche erfolglos. Dies wird für zwei Zahlen, 19 und 5, auf der Folie durchgespielt. Um dies Verfahren anzuwenden, haben wir die Elemente als sortiert vorausgesetzt. Wie können wir diese Anordnung bei willkürlicher Reihenfolge der angelieferten Zahlen mit wenig Aufwand erreichen? Ein Art ist, eine spezielle Datenstruktur, sog. binäre Suchbäume, zu verwenden. Auf der nächsten Folie bauen wir einen solchen beispielhaft für die oben verwendete Menge von Zahlen auf. OK : nicht vorhanden

8 Suchstruktur Aufgabe: Trage die Zahlen 17, 4, 36, 2, 8, 19, 40, 6, 7 in eine baumförmige Struktur so ein: 17 4 36 Dieses Beispiel nimmt an, daß die oben angegebenen Zahlen in der aufgeschriebenen Reihenfolge eingegeben werden. Die Schlüsselidee besteht darin, die Daten nicht linear, wie in einer linearen Liste anzuordnen, sondern in einer baumförmigen Struktur. Wenn Sie die Animation der Folie betrachten, so sehen Sie, daß jede Zahl einen wohlüberlegten Platz im Baum findet. Wenn Sie etwa 17 betrachten, so ist 17 größer als 4, aber kleiner als 36. Diese baumförmigen Strukturen werden den Namen binäre Suchbäume tragen. Die Entwicklung dieses Begriffs erfolgt in mehreren Schritten. 2 8 19 40 6 7

9 Ziel: Binärer Suchbaum
Zu diesem Ziel nacheinander definieren: (Binärer) Baum Knotenmarkierter binärer Baum Binärer Suchbaum

10 Idee von Baum Die Informatiksicht: Abstrahiert 2 Künstlerisch

11 Binärer Baum Definition: (Binärer Baum)
1.) Der "leere" Baum  ist ein binärer Baum mit der Knotenmenge . 2.) Seien Bi binäre Bäume mit den Knotenmengen Ki , i = 1,2. Dann ist auch B = (w, B1, B2) ein binärer Baum mit der Knotenmenge K = {w}  K1  K2. ( bezeichnet disjunkte Vereinigung.) . Die Definition eines binären Baums geschieht wieder rekursiv: 1. ein leerer Baum ist ein binärer Baum 2. sind L und R binäre Bäume, so ist auch die Struktur ein binärer Baum, die sich aus einer Wurzel zusammen mit L als linkem umd R als rechtem Unterbaum zusammensetzt. Eine mathematisch saubere Formulierung findet sich auf obiger Folie. Üblicher Weise wird jedoch mit bildhaften Darstellungen operiert, wie wir es auch im nachfolgenden tun werden. 3.) Jeder binäre Baum B läßt sich durch endlich häufige Anwendung von 1.) oder 2.) erhalten.

12 Binärer Baum Sprech-/Darstellungsweisen (im Falle 2.)): Wurzel w B1 B2
Sei B = (w, B1, B2) binärer Baum w heißt Wurzel, B1 linker und B2 rechter Unterbaum. Wurzel w B1 B2 linker Unterbaum rechter Unterbaum

13 Binärer Baum Darstellung eines Beispiels nach Definition: B1 = (k1, , (k2, (k3, , ), )). k1 k2 k3

14 Terminologie Binäre Bäume
Wurzel innerer Knoten Blatt Mit binären Bäumen sind einige einfache Begriffe verbunden, die auf dieser Folie zu finden sind. Den Begriff der Wurzel haben wir ja schon vorher eingeführt. Die Wurzel (des Gesamt-)Baumes ist dadurch charakterisiert, daß sie nicht Sohn eines anderen Knotens ist. Umgekehrt gibt es Knoten, die keine Söhne haben: Derartige Knoten heißen Blätter. Sie sind auf der Folie blau wiedergegeben. Dann gibt es Knoten, die Söhne anderer Knoten sind und selbst wieder mindestens einen Sohn haben, solche Knoten heißen innere Knoten. Es ist bemerkenswert, daß die Bäume in der Informatik, die Wurzeln oben tragen. Dies hat wohl einen pragmatischen Grund: Dadurch lassen sich Bäume in der Regel leichter zeichnen. Vgl. dazu auch die Folie "Idee von Baum"

15 Knotenmarkierter binärer Baum
Definition: Sei M eine Menge. (B, km) ist ein knotenmarkierter binärer Baum (mit Markierungen aus M) :¤ 1.) B ist binärer Baum (mit Knotenmenge K = K(B)) 2.) km: K --> M Abbildung. (Markierung/Beschriftung der Knoten k  K mit Elementen m  M) Wird zu einem binären Baum eine Knotenmarkierung durch eine Abbildung von der Knotenmenge in eine Menge von Markierungen hinzugenommen, so erhalten wir einen knotenmarkierten binären Baum.

16 Knotenmarkierter binärer Baum
Beispiel: (M := Menge der ganzen Zahlen) damit existiert auf M eine Ordnung ! "Übliche" Darstellung der Knotenbeschriftung km durch "Anschreiben" der Beschriftung an/in die Knoten. k1 16 Für unseren weiteren Entwicklungen setzen wir voraus, daß die Markierungs-menge eine lineare Ordnung aufweist. Speziell ziehen wir uns zunächst auf die Menge der linear geordneten Menge der ganzen Zahlen mit der üblicherweise darauf definierten Ordnung zurück. Die Markierungsabbildung wird üblicherweise durch An-/Einschreiben der Bildwerte an resp. in die Knoten dargestellt, wie im Beispiel auf der Folie auch vorgemacht. 24 k2 18 k3

17 Datentyp BinBaum Implementierung knotenmarkierter binärer Bäume durch eine struct mit Zeigern: Inhalt, (hier z. B.) ganzzahlig (Später allgemeiner möglich) Zeiger jeweils auf den linken und den rechten Unterbaum Damit können wir knotenmarkierte binäre Bäume insbesondere so als Datenstrukturen darstellen: Weil diese Bäume rekursiv definiert sind, können wir auch eine rekursive Definition des entsprechenden Datentyps angeben. Wir nehmen an, daß ganze Zahlen in einzelnen Knoten gespeichert sind, es könnten jedoch auch andere Typen sein (was wir später benutzen werden). Die Deklaration der entsprechenden Struktur finden Sie auf dieser Folie. Es ist dabei zu beachten, daß wir Zeiger auf die jeweiligen Unterbäume haben (genauer: auf die Wurzeln der Unterbäume). Damit können wir bei der Konstruktion eines Baums auf unseren Grundvorrat von Techniken, den wir bei der Manipulation von Zeigern erworben haben, zurückgreifen. Es wird sich natürlich zeigen, daß hier noch einiges an zusätzlichen Überlegungen notwendig ist. struct BinBaum { int Element; BinBaum *Lsohn, *Rsohn; }

18 Binäre Suchbäume Definition: (B, km) ist ein binärer Suchbaum (über M)
:¤ 1.) (B, km) ist ein binärer, knotenmarkierter Baum. 2.) Ist w die Beschriftung der Wurzel w, so ist die Wurzelmarkierung im linken Unterbaum kleiner als w, die Wurzelmarkierung im rechten Unterbaum größer als w. (Jeweils, sofern diese vorhanden.) 3.) Ist (B, km) mit B  , B = (w, B1, B2), so sind (Bi,kmi) mit kmi := km|Bi (i= 1,2) binäre Suchbäume. Wir werden jetzt binäre Suchbäume definieren. Ein binärer Suchbaum ist dadurch charakterisiert, daß • jeder Knoten eine Beschriftung trägt. Die Beschriftung ist einer geordneten Menge entnommen (wie oben etwa den ganzen Zahlen). • die Beschriftung der Wurzel größer als die Beschriftung der Wurzel des linken Unterbaums und kleiner als die Beschriftung der Wurzel des rechten Unterbaums ist. • der linke und der rechte Unterbaum selbst wieder binäre Suchbäume sind. Bitte beachten Sie, daß der leere Baum auch ein binärer Suchbaum ist. Die Rolle des leeren Baums soll kurz kommentiert werden: Viele der vorgestellten Algorithmen sind rekursiv. Der Aufruf einer solchen Prozedur spielt sich typischerweise folgendermaßen ab: Die Prozedur wird für einen Baum aufgerufen, die rekursiven Aufrufe erfolgen für Teilbäume. Damit werden die Argumente für die rekursive Funktion immer kleiner, sie stoppen meist dann, wenn der kleinste aller möglichen Bäume erreicht ist. Und das ist eben der leere Baum. Techniken zur Manipulation binärer Bäume sind meist sehr ähnlich zu denen binärer Suchbäume, so daß sie gleichsam als Abfallprodukt dieser Techniken auch hier eingeführt werden.

19 Binäre Suchbäume Beispiel:
Aufgaben im Zusammenhang mit (binären) Suchbäumen: Suchen nach Markierungen/Elementen im Suchbaum Aufbau solcher Bäume Abbau, z. B. Entfernen eines Knotens mit Markierung Durchlaufen aller Knoten Den oben angeführten Teilaufgaben werden wir der Reihe nach nachgehen.

20 Binäre Suchbäume: Suchen
Gegeben: ein binärer Suchbaum (durch Zeiger B darauf), ganze Zahl k Problem: Ist k in durch B bezeichneten Baum gespeichert? Lösungsidee: Stimmt B->Element mit k überein: Antwort ja Gilt B->Element < k: suche in B->Rsohn Gilt B->Element > k: suche in B->Lsohn Ist B leer, Antwort nein Aus der Definition eines binären Suchbaums ergibt sich jetzt leicht die Möglichkeit der Suche in einem solchen Baum. Es ist eine Variation der Grobidee, die wir unter dem Stichwort "Binäre Suche" vorn schon eingeführt haben. Wir nehmen an, daß wir (einen Zeiger auf (!!) ) einen binären Suchbaum B gegeben haben und suchen in dem dadurch bezeichneten Baum die Zahl k. Die Frage, ob k in *B zu finden ist, läßt sich wie folgt beantworten: Ist k in der Wurzel von *B zu finden, so lautet die Antwort: Ja. Ist k kleiner als der Wert, der in der Wurzel von *B gespeichert ist, so lautet die Antwort: Schaue im linken Unterbaum nach. Analog: ist k größer als die Zahl, die in der Wurzel gespeichert ist, so lautet die Antwort: Schaue im rechten Unterbaum nach. Wurde der leere Baum übergeben, so lautet die Antwort: Nein. Diese Suchprozedur ist ein typisches Beispiel für die Vorgehensweise bei rekursiven Aufrufen für binäre Bäume: Die Aufrufe innerhalb einer Funktion verkleinern den Baum so weit, bis er zum leeren Baum degeneriert ist (natürlich nur, wenn das gewünschte Ergebnis noch nicht vorliegt und die Unterbäume betrachtet werden müssen).

21 Binäre Suchbäume: Suchen
Suche nach dem Element 19 Suche nach dem Element 5 17 4 36 2 8 6 7 19 40 Die Suche in einem binären Suchbaum wird an unseren leicht modifizierten alten Bekannten an zwei Beispielen durchexerziert: an der erfolglosen und an der erfolgreichen Suche. Sie sollten sich die Vorgehensweise in beiden Fällen genau anschauen, um zu einem Verständnis der rekursiv geprägten Vorgehensweise zu kommen.

22 Binäre Suchbäume: Suchen
bool Suche (BinBaum * B, int k) { if (B == NULL) return false; else { if (B->Element == k) return true; else if (B->Element < k) return Suche(B->Rsohn, k); else if (B->Element > k) return Suche(B->Lsohn, k); } Der Programmcode für die Such-Operation folgt diesem Schema sehr eng, es wird lediglich angemerkt, daß wir den Fall eines leeren Baums zu Beginn abfangen müssen: Würden wir versuchen, den linken oder den rechten Teilbaum eines leeren binären Suchbaums anzusprechen oder gar den Inhalt, so würden wir eine Fehlermeldung reinsten Wassers erhalten, da wir in diesem Falle auf undefinierte Speicherbereiche zugreifen. Beim Studium des Texts fällt Ihnen auf, daß wir - wie vorher hier geschildert - die rekursiven Aufrufe von den Größenvergleichen zwischen der zu suchenden Zahl k und dem Inhalt der Wurzel des gerade vorliegenden Baums abhängig machen.

23 Binäre Suchbäume: Einfügen
Aufbau durch wiederholtes Einfügen in einen leeren binären Suchbaum Einfügeoperation für binären Suchbaum *B und eine ganze Zahl k B == NULL: erzeuge neuen Knoten, weise ihn B zu und setze B->Element = k B != NULL B->Element < k: Einfügen von k in B->RSohn B->Element > k: Einfügen von k in B->LSohn Das Einfügen in einen binären Suchbaum folgt der gleichen Philosophie wie das Suchen in einem solchen Baum. Wir wenden uns dem Einfügen zu: Zunächst stellen wir fest, daß, wenn wir die ganze Zahl k in den binären Suchbaum, auf den B zeigt, einfügen wollen und *B der leere Baum ist, wir nichts anderes zu tun haben, als einen neuen Knoten zu erzeugen, das Inhaltsfeld des Knotens auf die Zahl k zu setzen und diesen neuen Knoten als Resultat der Einfügeoperation zurückzugeben. Nehmen wir nun an, daß k im linken Unterbaum eingefügt werden soll (, weil k kleiner als die Beschriftung der Wurzel von *B ist). Dann fügen wir k in den linken Unterbaum ein, indem wir die Einfügefunktion mit den beiden entsprechenden Parameter aufrufen. Hierdurch ergibt sich ein modifizierter binärer Suchbaum, der dann als linker Teilbaum in unseren Baum *B eingefügt wird. Völlig analog argumentiert man im Fall der Einfügung in den rechten Teilbaum. Diese Überlegungen setzen natürlich voraus, daß k noch nicht in *B enthalten ist. Im Fall, daß k schon im Suchbaum enthalten ist, wird keine Einfüge-Operation vorgenommen.

24 Binäre Suchbäume: Einfügen
Rekursion wichtiger Bestandteil der Funktion Idee: suche den Unterbaum, in den eingefügt werden soll, füge in den Unterbaum ein, weise diesem Unterbaum das Resultat der Einfügung zu.

25 Binäre Suchbäume: Einfügen
BinBaum *Einfuegen (BinBaum * B, int k) { if (B == NULL){ Binbaum *Hilf = new BinBaum; Hilf->Element = k; Hilf->Lsohn = Hilf->Rsohn = NULL; B = Hilf; Hilf = NULL; } else { if (B->Element < k) B->Rsohn = Einfuegen(B->Rsohn, k); else if (B->Element > k) B->Lsohn = Einfuegen(B->Lsohn, k); return B; Der Code für diese Einfügung ist hier angegeben. Es soll erneut auf die rekursiven Aufrufe hingewiesen werden: Wird in dem linken Teilbaum eingefügt, so entsteht ein modifizierter Baum, der dann linker Teilbaum des ursprünglich gegebenen Teilbaums wird. Dieser Gedanke ist ein wenig trickreich und sollte noch einmal reflektiert werden. Die beiden folgenden Folien gehen dann auch noch einmal auf diesen Sachverhalt ein.

26 B->Lsohn = Einfuegen(B->Lsohn, k);
BinBaum *Einfuegen(BinBaum * B, int k){ if (B == NULL){ Binbaum *Hilf = new BinBaum; Hilf->Element = k; Hilf->Lsohn = Hilf->Rsohn = NULL; B = Hilf; Hilf = NULL; }; return B;} B Hilf k else {if (B->Element > k) B->Lsohn = Einfuegen(B->Lsohn, k); else if (B->Element < k) B->Rsohn = Einfuegen(B->Rsohn, k); }; Return B; } k

27 Kommentar: Einfügen Suche den Unterbaum, in den eingefügt wird
if (B->Element < k) B->Rsohn = Einfuegen(B->Rsohn, k); else if (B->Element > k) B->Lsohn = Einfuegen(B->Lsohn, k); return B; weise dem Unterbaum das Resultat der Einfügung zu

28 Analyse: Einfügen Wie schnell geht das eigentlich?
Maß für die Güte eines Algorithmus: Anzahl von Operationen und Speicherplatz-Verbrauch hier: Speicherplatz: pro Knoten eines Exemplars von BinBaum, also relativ uninteressant. Operationen sind hier Vergleiche: interessant Erinnern Sie sich: Wir hatten die Behauptung aufgestellt, daß die Einfügung in eine lineare Liste vergleichsweise ineffizient gegenüber der Einfügung in eine neu zu erfindende Struktur sei. Nun, wir haben diese Struktur erfunden, haben uns mit dieser Struktur vertraut gemacht, und jetzt müssen wir sehen, wie wir die Behauptung denn tatsächlich auch verifizieren können. Dazu dienen die nächsten Überlegungen. Die Frage ist, wie schnell die Einfügeoperation durchgeführt werden kann. Um dies quantitativ faßbar zu machen, müssen wir uns überlegen, was wir als quantitatives Maß heranziehen. Es hat sich herausgestellt, daß die Anzahl von Operationen und der Speicherplatzbedarf ein geeignetes Maß für die Güte der Algorithmen ist. Als Operationen kommen im wesentlichen Vergleiche in Frage, die Anzahl der anderen Operationen (Neuaufrufe der Einfügeoperation, Erzeugung von Knoten) ist proportional zur Anzahl der Vergleiche. Daher wollen wir uns, was die Operationen betrifft, auf Vergleiche konzentrieren. Der Speicherplatzbedarf für unsere Algorithmen ist einfach zu ermitteln: Pro eingefügter Zahl ist ein Knoten einzulegen, der Knoten selbst hat das Inhaltsfeld und zwei Zeiger-Komponenten, so daß der Speicherplatzbedarf proportional zur Anzahl der Elemente ist (übrigens ist dies vergleichbar zum Speicherplatzbedarf für lineare Listen).

29 Analyse: Einfügen Frage: wieviele Vergleiche sind beim Einfügen (oder bei der erfolglosen Suche) notwendig? Antwort: nicht so leicht zu geben: ist der günstigste Fall gemeint? (klar: 1) ist der ungünstigste Fall gemeint? (auch ziemlich klar: längster Pfad im Baum) ist der durchschnittliche Fall gemeint? (völlig unklar) Damit haben wir die Überlegungen auf die Frage reduziert, wieviel Vergleiche beim Einfügen (oder, was praktisch dasselbe ist, bei der erfolglosen Suche) notwendig sind. Die Antwort läßt sich nicht so einfach geben, wie die Frage gestellt werden kann. Im günstigsten Fall brauchen wir nur einen Vergleich durchzuführen, hier muß lediglich mit der Wurzel verglichen werden. Der ungünstigste Fall ist auch recht klar: Hier müssen wir den längsten Pfad im Baum durchlaufen, also den längsten Weg, der von der Wurzel zu einem Blatt führt. Der durchschnittliche Fall, also der Fall, den man als normaler Mensch erwartet, erfordert ebenfalls einiges an Überlegungen: Hier wird ein gerüttelt Maß höherer Mathematik erforderlich sein, so daß wir darauf hier nicht eingehen.

30 Suchen: ungünstigster Fall
Erfolglose Suche: suche von der Wurzel zu einem Blatt, jeder Knoten entspricht einem Vergleich. Höhe eines Baums: gibt den längsten Pfad von der Wurzel zu einem Blatt an. Ist rekursiv definiert Höhe des leeren Baums ist 0, Höhe eines nicht-leeren Baums ist 1 + max{Höhe Lsohn, Höhe Rsohn} Die erfolglose Suche ist offenbar der Fall, bei dem wir die meiste Zeit verbringen, hierbei müssen wir von der Wurzel zu einem Blatt laufen, jeder Knoten entspricht einem Vergleich. Um diese in den Griff zu bekommen, erweist es sich als hilfreich, die Höhe eines Baums zu definieren. Unter der Höhe eines Baums versteht man, wie auf der Folie angegeben, den längsten Pfad von der Wurzel zu einem Blatt. Auch das läßt sich rekursiv definieren, die Definition ist auf der Folie angegeben. Es ist plausibel, daß diese Definition der anschaulichen Definition der Höhe eines Unterbaums entspricht.

31 Höhe eines binären Baums
17 4 36 2 8 6 7 19 40 37 Der Baum hat die Höhe 5

32 Suchen: ungünstigster Fall
Es gilt der Satz: Ein binärer Baum der Höhe n hat zwischen n und 2 n- 1 Knoten. Daraus folgt: k Knoten können in einem binären Baum gespeichert werden, der eine Höhe zwischen ~log2 k und k hat Also: der schlechteste Fall bei der erfolglosen Suche in einem binären Suchbaum mit k Elementen liegt bei k Vergleichsoperationen Man kann sich jetzt überlegen, daß, wenn man einen binären Baum der Höhe n hat, man zwischen n und 2 n- 1 Knoten in diesem Baum speichern kann. (Ein-facher Beweis durch Induktion.) Durch Umkehrung der Rechnung (also Auflösen nach den Exponenten) kann man daraus herleiten, daß k Knoten in einem binären Suchbaum gespeichert werden können, dessen Höhe zwischen k und log k und liegt. Dieses Ergebnis erhält man recht einfach dadurch, daß man sich überlegt, innerhalb welcher Grenzen die Höhe eines Baums zu wählen ist, um die k Knoten abzuspeichern. Daraus können wir nun ableiten, daß der schlechteste Fall, also die Anzahl von Vergleichen in dem Fall, daß das Element nicht im Baum vorhanden ist, k Vergleichsoperationen erfordert. Damit sind binäre Suchbäume offensichtlich nicht so gut, wie wir am Anfang überlegt haben. Allerdings muß hinzugefügt werden, daß dieser schlechteste Fall in der Praxis sehr selten auftritt. Daher geben wir auf der nächsten Folie kurz ein weiteres Ergebnis an, das wesentlich realistischer ist und die praktische Arbeit mit binären Suchbäumen rechtfertigt.

33 Suchen: zu erwartender Fall
Die erfolglose Suche in einem binären Suchbaum mit k Elementen erfordert im Durchschnitt proportional zu log k Vergleichsoperationen. Recht kompliziert herzuleiten. Die Höhe eines Baums ist im Durchschnitt logarithmisch in der Anzahl der im Baum vorhandenen Knoten. Daraus folgt, daß die erfolglose Suche in einem binären Suchbaum im Durchschnitt etwa logarithmisch viele Schritte erfordert.