Binärer Suchbaum

Abb. 1: Binärer Suchbaum der Höhe 5 mit Wurzel H und 13 Knoten, die Schlüssel tragen

Abb. 2: Derselbe binäre Suchbaum derselben Höhe 5 in anderer Sichtweise:
Wurzel H, 14 äußere und 13 innere Knoten, letztere mit denselben Schlüsseln

In der Informatik ist ein binärer Suchbaum eine Kombination der abstrakten Datenstrukturen Suchbaum und Binärbaum. Ein binärer Suchbaum, häufig abgekürzt als BST (von englisch Binary Search Tree), ist ein binärer Baum, bei dem die Knoten „Schlüssel“ tragen, und die Schlüssel des linken Teilbaums eines Knotens nur kleiner (oder gleich) und die des rechten Teilbaums nur größer (oder gleich) als der Schlüssel des Knotens selbst sind.

Was die Begriffe „kleiner gleich“ und „größer gleich“ bedeuten, ist völlig dem Anwender überlassen; sie müssen nur eine Totalordnung (genauer: eine totale Quasiordnung siehe unten) etablieren. Am flexibelsten wird die Ordnungsrelation durch eine vom Anwender zur Verfügung zu stellende 3-Wege-Vergleichsfunktion realisiert. Auch ob es sich um ein einziges Schlüsselfeld oder eine Kombination von Feldern handelt, ist Sache des Anwenders; ferner ob Duplikate (unterschiedliche Elemente, die beim Vergleich aber nicht als „ungleich“ herauskommen) zulässig sein sollen oder nicht. Über Suchfunktionen für diesen Fall siehe unten.

Ein in-order-Durchlauf durch einen binären Suchbaum ist äquivalent zum Wandern durch eine sortierte Liste (bei im Wesentlichen gleichem Laufzeitverhalten). Mit anderen Worten: ein binärer Suchbaum bietet unter Umständen wesentlich mehr Funktionalität (zum Beispiel Durchlauf in der Gegenrichtung und/oder einen „direkten Zugriff“ mit potenziell logarithmischem Laufzeitverhalten – erzielt durch das Prinzip „Teile und herrsche“, das durch die Fernwirkung des Transitivitätsgesetzes ermöglicht wird) bei einem gleichen oder nur unwesentlich höheren Speicherbedarf.

Motivation

Suchbäume sind Lösungen des sogenannten „Wörterbuchproblems“. Angenommen ist eine große Anzahl von Schlüsseln, denen jeweils ein Wert beigegeben ist. In einem Wörterbuch deutsch–englisch ist das deutsche Wort der Schlüssel und englische Wörter sind der gesuchte Wert. Ähnlich verhält es sich bei einem Telefonbuch mit Namen und Adresse als Schlüssel und der Telefonnummer als dem gesuchten Wert.

Mathematisch gesehen realisiert ein Wörterbuch eine (endliche) Funktion mit Paaren (Schlüssel, Wert). Bei der Suche wird ein Suchbegriff (Argument der Funktion) mit einem der Schlüssel zur Deckung gebracht. Hat dies Erfolg, wird dem Suchbegriff der beigegebene Wert als Funktionswert zugeordnet.

In beiden Beispielen sind üblicherweise die Schlüssel sortiert. Das ist sehr zweckmäßig, denn es erlaubt, das Buch in der Mitte aufzuschlagen und zu überprüfen, ob der Suchbegriff gefunden ist. Ist er nicht gefunden und liegt er beispielsweise alphabetisch vor dem Buchstaben »K«, weiß man zusätzlich, dass man nicht weiter hinten mit »L«, »M« oder »Z« vergleichen muss. Der zur Untersuchung übrig bleibende Teil ist immer ein zusammenhängendes Segment, welches wie das ganze Buch am Anfang wieder halbiert wird – und so weiter bis zum Fund oder bis festzustellen ist, dass der Suchbegriff nicht vorkommt.

Diese Vorgehensweise hat in der Informatik den Namen „binäres Suchen“. Sie wird auf naheliegende Weise durch das sehr bekannte Suchverfahren „binäre Suche im Array“ nachgebildet. Ihr Verhalten ist informationstheoretisch optimal, nämlich logarithmisch, genauer: Bei n Schlüsseln benötigt man maximal ⌈log₂(n+1)⌉ Vergleiche.

Anders als beim binären Suchen muss beim „sequentiellen Suchen“ der Suchbegriff potentiell mit allen Schlüsseln verglichen werden. (Dafür braucht allerdings die Eingabe nicht sortiert zu sein.) Der Unterschied zwischen den beiden Verfahren kann erheblich sein: In einem Telefonbuch mit n = 2²⁰–1 = 1'048'575 Einträgen, müssen beim sequentiellen Suchen im Mittel (1048575+1)/2 = 524'288 Vergleiche durchgeführt werden. Beim binären Suchen gelangt man nach maximal log₂(2²⁰–1+1) = 20 Vergleichen zum selben Ergebnis.

Änderungen, Zugänge und Abgänge bei Wörter- und Telefonbüchern können sporadisch, bei Softwaresystemen müssen sie in der Regel unmittelbar reflektiert werden. Zugänge und Abgänge erfordern in einem Array Datentransporte, deren Aufwand proportional zur Länge des Arrays, also linear in n, ist. Ein solcher Aufwand macht die Effizienz des binären Suchens völlig zunichte.

Die Vorgehensweise beim binären Suchen lässt sich auch mit einem Binärbaum nachbilden. Der erste Schlüssel, mit dem der Suchbegriff zu vergleichen ist, wird in die Wurzel des Binärbaums platziert. Der beim Vergleichsergebnis »kleiner« aufzusuchende nächste Schlüssel wird in den linken Kindknoten platziert und entsprechend der Schlüssel für »größer« in den rechten Kindknoten. So fährt man fort, bis alle Schlüssel im Binärbaum untergebracht sind. (Dadurch wird der Binärbaum zu einem binären Suchbaum.)

Durch das Herauslösen der einzelnen Elemente aus dem Array wird große Flexibilität gewonnen: Der Aufwand beim Einfügen für das Zuweisen von Speicherplatz und Beschicken der Felder mit Werten sowie beim Löschen für die Rückgabe des Speicherplatzes ist unabhängig von der Anzahl n der Elemente. Verloren geht beim Binärbaum allerdings ein Maß für die Balance, das beim Array durch das Bilden des Mittelwerts zwischen zwei Indizes gegeben ist. Darüber hinaus kann ein Binärbaum, der einmal hervorragend balanciert war, durch Einfügungen und Löschungen seine Balance verlieren und im Extremfall, wenn nämlich jeder Knoten nur noch einen Kindknoten hat (statt zwei), zu einer linearen Liste degenerieren – mit dem Ergebnis, dass eine Suche einer sequentiellen Suche gleichkommt.

Die Informatiker haben verschiedene Balance-Kriterien für Binärbäume entwickelt. Bei den meisten sind die Aufwände für das Suchen, Einfügen und Löschen logarithmisch, wenn auch mit unterschiedlichen konstanten Faktoren. Einige Lösungsprinzipien zur Problematik der Entartung bei dynamischen Binärbäumen finden sich im

→ Hauptartikel: Balancierter Baum

Terminologie

Die Begriffe Knoten und Kante, letztere definitionsgemäß als gerichtete Kante (oder auch Bogen und Pfeil), werden von den allgemeinen Graphen übernommen. Wenn die Gerichtetheit aus dem Kontext klar genug hervorgeht, genügt Kante.

Bei gerichteten Graphen kann man einem Knoten sowohl Ausgangsgrad wie Eingangsgrad zuordnen. Üblicherweise werden Binärbäume als Out-Trees aufgefasst. In einem solchen gewurzelten Baum gibt es genau einen Knoten, der den Eingangsgrad 0 hat. Er wird als die Wurzel bezeichnet. Alle anderen Knoten haben den Eingangsgrad 1. Der Ausgangsgrad ist die Anzahl der Kindknoten und ist beim Binärbaum auf maximal 2 beschränkt. Damit ist seine Ordnung als Out-Tree ≤ 2.

Knoten mit Ausgangsgrad ≥ 1 bezeichnet man als interne (innere) Knoten, solche mit Ausgangsgrad 0 als Blätter oder externe (äußere) Knoten. Bei Binärbäumen – und nur dort – findet sich gelegentlich die Bezeichnung Halbblatt für einen Knoten mit Ausgangsgrad 1 (englisch manchmal: non-branching node). Dann ist ein Blatt ein doppeltes Halbblatt.

Unterschiedliche Sprechweisen

Den Knoten des Binärbaums in der Abb. 1 sind Schlüssel zugewiesen. Da bei der in-order-Traversierung die (alphabetische) Sortierordnung befolgt wird, ist der Baum ein binärer Suchbaum.

In der Abb. 2 ist derselbe binäre Suchbaum – nun aber mit expliziten „NIL-Knoten“ – dargestellt. Hier tragen nur die internen Knoten Schlüssel, wogegen die externen Knoten NIL-Knoten sind und als Platzhalter für die Intervalle zwischen den Schlüsseln (so beispielsweise in der Abb. 4), also als Einfügepunkte des binären Suchbaums fungieren. Knoten mit Ausgangsgrad 1 gibt es nicht. Der schlüssellose Suchbaum besteht aus genau einem Knoten, der extern und Wurzel zugleich ist. Da bei dieser Sichtweise die Höhe des „wirklich leeren“ Baums (der kein Suchbaum ist) zu –1 definiert ist, somit dem schlüssellosen Baum die Höhe 0 zukommt, stimmen die Höhenbegriffe überein, wenn in der Sichtweise der Abb.1 dem leeren und zugleich schlüssellosen Baum die Höhe 0 zugeteilt wird.

Knotenorientierte und blattorientierte Speicherung

Man nennt die Art der Speicherung knotenorientiert, wenn die Inhalte der Menge in den Knoten abgespeichert und die externen Blätter leer sind (so in den Abbildungen 1 und 2). Gegensatz dazu ist die blattorientierte Speicherung, bei der die Inhalte der Menge in den Blättern abgespeichert sind und die Knoten nur Hinweisschilder für die Navigation darstellen, die möglicherweise mit den Schlüsseln der Menge wenig zu tun haben.

Begriffsklärung

Zur Beachtung

1. Der Begriff „Nachbar“ (und „Nachbarschaft“ etc.) wird in diesem Artikel (und bei den Suchbäumen generell) anders als sonst in der Graphentheorie verwendet, nämlich ausschließlich im Sinn der eingeprägten Ordnungsrelation: „rechter“ Nachbar meint den nächsten Knoten in aufsteigender Richtung, „linker“ in absteigender.
2. Muss in diesem Artikel auf die Hierarchiestruktur des Baumes eingegangen werden, so werden Begriffe wie „Elter“ oder „Vorfahr“ bzw. „Kind“ oder „Nachfahr“ verwendet.
3. Die hierarchische Anordnung der Knoten in der Baumstruktur des binären Suchbaums wird als sekundär und mehr oder minder zufällig angesehen – ganz im Vordergrund steht die korrekte Darstellung der Reihenfolge.
4. Ähnlich sekundär ist die Frage, welcher Knoten gerade die Rolle der Wurzel spielt, insbesondere wenn es sich um einen selbst-balancierenden Baum handelt. Insofern eignet die Adresse der Wurzel sich nicht zur Identifizierung des Baumes.
5. Dagegen kann die feste Adresse eines Zeigers zur Wurzel als Identifikation genommen werden, der dann aber auch von den Operationen des Baums zu pflegen ist.

Ordnungsrelation

Damit binäres Suchen, Sortieren etc. funktionieren kann, muss die Ordnungsrelation eine totale Quasiordnung, im Englischen „total preorder“, sein. Die Bezeichnungen für die induzierte Duplikatrelation $\sim$ und die induzierte strenge Halbordnung $<\$ seien wie dort.

Die Trichotomie einer entsprechenden 3-Wege-Vergleichsfunktion $\operatorname {compare}$ – von ihrem Ergebnis ist nur das Vorzeichen $\operatorname {sgn}$ relevant – ergibt sich folgendermaßen:

$\operatorname {sgn} (\operatorname {compare} (x,y)):={\begin{cases}\\\\\end{cases}}$	$-1$,	falls   $x<y$		(x kleiner als y),
	$0$,	falls   $x\sim y$		(x Duplikat von y),
	$+1$,	falls   $y<x$		(x größer als y).

Nach Vertauschung von $x$ und $y$ und einer Umordnung erkennt man, dass

$\forall x,y:\ \operatorname {sgn} (\operatorname {compare} (y,x))=-\operatorname {sgn} (\operatorname {compare} (x,y))$.

Die induzierte Ordnungsrelation $<\$ ist eine strenge schwache Ordnung, im Englischen strict weak ordering. Sie induziert auf den Äquivalenzklassen dieser Relation, genauer: den Äquivalenzklassen der Duplikatrelation, eine strenge Totalordnung.

Offensichtlich lässt sich jede solche Ordnung spiegeln, d. h. $+1$ mit $-1$ vertauschen, das Ergebnis ist wieder eine strenge schwache Ordnung. Nachbarschaftsbeziehungen bleiben bestehen, es wird nur „größer“ mit „kleiner“ bzw. „rechts“ mit „links“ vertauscht.

Anmerkungen:

• Zum reinen Aufsuchen genügt im Grunde eine 2-Wege-Vergleichsfunktion, die angibt, ob zwei „Schlüssel“ gleich sind oder nicht. Mit einer solchen Vergleichsfunktion sind aber effiziente, zum Beispiel im Mittel logarithmische, Suchzeiten nicht erreichbar.
• Für das Funktionieren des Sortierens und binären Suchens ist es unerheblich, ob das Aufspalten des Ungleich-Weges einer 2-Wege-Vergleichsfunktion in einen Kleiner- und einen Größer-Weg ein Artefakt ist, wie zum Beispiel die Anordnung der Buchstaben in einem Alphabet, oder ob eine Näher-/Ferner- oder logische Beziehung (mit) im Spiel ist.
• Spiegelt die Ordnungsrelation auch Nachbarschaft wider, kann diese für ein effizientes „unscharfes Suchen“ ausgenutzt werden.
• Die Binarität der Binärbäume passt exakt zur Suche mit der 3-Wege-Vergleichsfunktion.
• Wie im folgenden Abschnitt „Suchen“ näher ausgeführt, ist die Behandlung von Duplikaten unabhängig davon, ob die Ordnungsrelation Duplikate zulässt (totale Quasiordnung bzw. strenge schwache Ordnung) oder nicht (Totalordnung bzw. strenge Totalordnung). Einerseits kann es unerwünscht sein, auch wenn sie Duplikate zulässt, diese im Baum zu haben. Andererseits kann es durchaus angebracht sein, auch bei einer Totalordnung Duplikate in den Baum aufzunehmen, zum Beispiel aus dem Eingabestrom. Es kommt in der praktischen Anwendung also nur darauf an, ob es im Baum Duplikate geben soll oder nicht. Konsequenterweise wird hier von vornherein von totalen Quasiordnungen ausgegangen.

Suchen

Die Suche nach einem Eintrag verläuft derart, dass der Suchschlüssel zunächst mit dem Schlüssel der Wurzel verglichen wird. Sind beide gleich, so ist der Eintrag (oder ein Duplikat) gefunden.

Andernfalls (bei „ungleich“) wird überprüft, ob der Suchschlüssel kleiner (größer) ist als der Schlüssel im Knoten: dann wird die Suche rekursiv im linken (rechten) Teilbaum der Wurzel fortgeführt; gibt es keinen linken (rechten) Teilbaum, so existiert der gesuchte Eintrag im binären Suchbaum nicht.

Der auf diese Weise erhaltene finale „ungleich“-Knoten stellt zusammen mit der letzten Vergleichsrichtung den sog. Einfügepunkt für das gesuchte Element dar. (In der Sichtweise der Abb. 2 genügt der externe Knoten, der die Richtung mitenthält.) Wird es hier eingefügt, dann stimmt die in-order- mit der Sortier-Reihenfolge überein. Der finale „ungleich“-Knoten hat einen Schlüssel, der entweder der kleinste unter den größeren ist oder der größte unter den kleineren. Dasselbe gilt spiegelbildlich für seinen Nachbarknoten in der letzten Vergleichsrichtung, sofern es einen solchen gibt. (Allerdings ist dieser kein „Einfügepunkt“, sondern ein Vorfahr desselben.)

Suchen duplikatfrei

Der folgende Pseudocode Find illustriert die Arbeitsweise des Algorithmus für eine Suche, bei der in keinem Fall Duplikate in den Baum aufgenommen werden sollen. (Das ist letztlich unabhängig davon, ob die Ordnungsrelation Duplikate zulässt oder nicht.)

Die Funktion gibt einen Knoten und ein Vergleichsergebnis zurück. Dieses Paar stellt – außer beim Vergleichsergebnis „Equal“ – einen Einfügepunkt dar.

Find(t, s) {
  t: binärerSuchbaum
  s: Suchschlüssel

  return Find0(t, s, t.root, Empty)
  // zurück kommt ein Knoten und ein Vergleichsergebnis

Find0(t, s, x, d)
  t: Teilbaum
  s: Suchschlüssel
  x: Knoten
  d: Vergleichsergebnis (Equal, LessThan, GreaterThan oder Empty)

  if x ≠ null then {
     if s = x.key then return (x, Equal)       // Suchschlüssel s gefunden
     if s < x.key
        then return Find0(x, s, x.left,  LessThan)
        else return Find0(x, s, x.right, GreaterThan)
  }
  return (t, d)                                // Suchschlüssel s nicht gefunden
  // zurück kommt  (Baum,Empty)  oder  (Knoten,Vergleichsergebnis)
}

Bei dem in der Abbildung gewählten Beispiel gibt Find beim Suchschlüssel s den ersten Treffer „F“ als Ergebnis zurück.

Suchen mit Duplikaten

Sollen Einträge von Duplikaten in den Baum zugelassen sein, ist es vorteilhaft, die Suche nicht beim ersten besten gefundenen Knoten abzubrechen, sondern entweder auf der kleineren oder auf der größeren Seite bis zu den Blättern weiter zu suchen. Dies unterstützt eine gezielte Einfügung von Duplikaten und ist insbesondere dann interessant, wenn im Suchbaum nicht nur gesucht und gefunden werden soll, sondern u. U. auch traversiert wird. Der Einsatz der nachfolgenden Suchfunktionen beim Sortierverfahren Binarytreesort macht dieses Verfahren zu einem „stabilen“ (s. Stabilität (Sortierverfahren) mit erklärenden Beispielen).

Beim folgenden Pseudocode FindDupGE gibt der Benutzer die Richtung rechts vor, auf welcher Seite der Duplikate ein ggf. neues eingefügt werden soll.

FindDupGE(t, s, c) {
  t: binärerSuchbaum
  s: Suchschlüssel        // FindDupGE: falls s ein Duplikat ist,
                          // soll es rechts eingefügt werden.
  c: Cursor {             // Dieser Cursor enthält am Ende:
     c.d: Richtung        // (1) Left, Right oder Empty
     c.n: Knoten          // (2) Knoten oder Baum (nur bei Empty)
  }

  c.n = t                 // Für den leeren Baum
  return FindDupGE0(t.root, s, c, Empty)
  // zurück kommt ein Einfügepunkt im Cursor c
}

FindDupGE0(x, s, c, d) {
  x: Knoten
  s: Suchschlüssel
  c: Cursor
  d: Richtung

  if x ≠ null then {
     c.n = x
     if s ≥ x.key         // Suchschlüssel s ≥ Knoten.Schlüssel ?
        then return FindDupGE0(x.right, s, c, Right)  // ≥ (GE)
        else return FindDupGE0(x.left,  s, c, Left)   // <
  }
  c.d = d                 // Setzen Einfüge-Richtung
  return c
  // zurück kommt ein Einfügepunkt im Cursor c
}

Abb. 3: Einfügepunkt beim rechtesten Duplikat von s

Das Paar (Knoten, Richtung) des vorigen Beispiels Find ist hier zu dem einen Objekt, genannt Cursor, zusammengefasst. Es ist ein reiner Ausgabeparameter, der den Einfügepunkt spezifiziert.

FindDupGE ist so gehalten, dass im Ergebnis-Cursor immer ein unmittelbarer Einfügepunkt geliefert wird. Aus dem Ergebnis ist aber nicht ohne Weiteres erkennbar, ob es sich um ein Duplikat handelt, da der Einfügepunkt nicht den gesuchten Schlüssel haben muss, selbst wenn dieser im Baum vorkommt. Dies hängt von der mehr oder minder zufälligen Anordnung der Knoten im Baum ab. Ist nämlich das rechteste Duplikat (im Beispiel der Abb. 3 „R“) ein rechtes Halbblatt, dann stellt es zusammen mit der Richtung „rechts“ den Einfügepunkt dar; ist es das nicht, dann ist es in der Hierarchie des Binärbaums ein Vorfahr des rechten Nachbarn von „R“, der nun ein linkes Halbblatt ist und zusammen mit der Richtung „links“ denselben Einfügepunkt spezifiziert und also in diesem Fall das Resultat von FindDupGE darstellt.

Während bei Find alle 3 Wege der Vergleichsfunktion abgefragt werden, begnügt sich FindDupGE mit der Abfrage von deren 2.

Der nachfolgende Pseudocode FindDup kombiniert die Fähigkeiten von Find und FindDupGE, indem er sowohl ein Ergebnis über das Vorhandensein eines Suchschlüssels als auch einen Einfügepunkt für Duplikate liefert. Hierzu gibt der Benutzer eine Richtung d (links oder rechts) vor, auf welcher Seite der Duplikate ein ggf. neues eingefügt werden soll. Als Ergebnis kommt ein Paar (Knoten, Cursor) zurück, wobei Knoten angibt, ob und wo der Suchschlüssel gefunden wurde.

Der Vorschlag baut beispielhaft ein Objekt auf, das (in Analogie zum Beispiel zu den Datenbanken) Cursor genannt wird. Der #Cursor enthält den ganzen Pfad vom Ergebnisknoten bis zur Wurzel. Damit passt er zur nachfolgenden in-order-Traversierfunktion Next, eine Version, die ohne Zeiger zum Elterknoten auskommt. Die passende Datenstruktur für den Pfad ist der Stapelspeicher, engl. Stack, mit den Operationen push und pop.

Der etwas einfacheren Version der Funktion, bei der ein Zeiger zum Elter in jedem Knoten vorausgesetzt wird und deshalb der Cursor ohne Stack auskommt, entfallen die push- und clear-Aufrufe. Der Speicherbedarf für den Baum erhöht sich allerdings um einen festen Prozentsatz.

FindDup(t, s, c, d) {
  t: binärerSuchbaum
  s: Suchschlüssel
  c: Cursor {               // Dieser Cursor enthält am Ende:
     c.d: Richtung          // (1) Left, Right oder Empty
     c.n: Knoten            // (2) Knoten oder Baum (nur bei Empty)
     c.t: Baum              // (3) Baum (enthält den Zeiger zur Wurzel)
     c.p: Pfad              // (4) Pfad vom Elter des Knotens zur Wurzel
  }
  d: Richtung               // Falls s ein Duplikat ist, soll es ...

  c.d = d                   // ... auf dieser Seite eingefügt werden.
  c.t = t                   // initialisiere den Cursor
  clear(c.p)                // initialisiere den Stack
  c.n = t                   // für den leeren Baum
  return FindDup0(t.root, s, c, Empty)
  // zurück kommt ein Knoten und ein Einfügepunkt im Cursor c
}

FindDup0(x, s, c, d) {
  x: Knoten
  s: Suchschlüssel
  c: Cursor
  d: Richtung

  if x ≠ null then {
     push(c.p, c.n)                            // Elter von x in den Stack
     c.n = x                                   // setze neuen Knoten im Cursor
     if s = x.key then return FindDup1(x, s, c, c.d)
     if s < x.key
        then return FindDup0(x.left,  s, c, Left)
        else return FindDup0(x.right, s, c, Right)
  }
  c.d = d                                      // Setzen Einfüge-Richtung
  return (null, c)                             // Suchschlüssel s nicht gefunden
  // zurück kommt null und ein Einfügepunkt im Cursor c
}

FindDup1(q, s, c, d) {
  q: Knoten                                    // letzter Knoten mit Equal
  s: Suchschlüssel
  c: Cursor
  d: Richtung
  x: Knoten

  x = c.n.child[d]
  if x ≠ null then {
     push(c.p, c.n)                            // Elter von x in den Stack
     c.n = x                                   // setze neuen Knoten im Cursor
     if s = x.key
        then return FindDup1(x, s, c, c.d)     // x ist neuer Knoten mit Equal
        else return FindDup1(q, s, c, 1 - c.d) // bei ≠ weiter in der Gegen-Richtung
  }
  c.d = d                                      // Setzen Einfüge-Richtung
  return (q, c)
  // zurück kommt ein Duplikat und ein Einfügepunkt im Cursor c
}

FindDup ist so gehalten, dass im Ergebnis-Cursor immer ein unmittelbarer Einfügepunkt geliefert wird. Wenn der Suchschlüssel nicht gefunden wurde, wird im Feld Knoten der Nullzeiger zurückgegeben. Wenn der Suchschlüssel gefunden wurde, gibt FindDup das linkeste oder rechteste Duplikat, im Beispiel der Abb. 3 das rechteste Duplikat „R“, als gefundenen Knoten zurück. Der Einfügepunkt kann mit dem gefundenen Knoten zusammenfallen; er kann aber auch sein unmittelbarer (im Beispiel der Abbildung rechter) Nachbar sein, in welchem Fall er einen anderen Schlüssel hat.

Im ersten Teil, FindDup0, werden alle 3 Wege der Vergleichsfunktion abgefragt; im zweiten Teil, FindDup1, wenn das Vorhandensein des Suchschlüssels positiv geklärt ist, nur noch deren 2.

Komplexität

Da die Suchoperation entlang eines Weges von der Wurzel zu einem Blatt verläuft, hängt die aufgewendete Zeit im Mittel und im schlechtesten Fall linear von der Höhe h des Suchbaums ab (Komplexität O(h)); im asymptotisch vernachlässigbaren besten Fall ist die Laufzeit bei Find konstant, bei FindDupGE und FindDup jedoch immer O(h).

Die Höhe h ist im entarteten Fall so groß wie die Anzahl der vorhanden Elemente n. Beim Aufbau eines Baumes, was einem Sortierlauf entspricht, muss im Extremfall jedes Element mit jedem verglichen werden – ergibt in summa ${\tbinom {n}{2}}\in {\mathcal {O}}\left(n^{2}\right)$ Vergleiche.

Gewichtsbalancierte Suchbäume können im Mittel auf konstante Laufzeit kommen, verhalten sich jedoch linear im schlechtesten Fall. Höhen-balancierte Suchbäume haben eine Höhe von O(log n) und ermöglichen so die Suche in garantiert logarithmischer Laufzeit. Der Aufbau eines Baumes kommt dann auf O(n log n) Vergleiche – das entspricht den besten Sortieralgorithmen.

Logarithmische Höhe gilt sogar im Durchschnitt für zufällig erzeugte Suchbäume, wenn die folgenden Bedingungen erfüllt sind:

• Alle Permutationen der einzufügenden und zu löschenden Elemente sind gleich wahrscheinlich.
• Bei Modifikationen des Baumes wird auf „asymmetrische“ Löschoperation verzichtet, d. h. die Abstiege bei den Löschungen nach links und die nach rechts halten sich im Mittel die Waage.

Suchtiefen und Pfadlängensummen

Abb. 4: (Optimaler) binärer Suchbaum mit Gewichten (rot).

Sei $\scriptstyle X:=\left\{x_{1}<x_{2}<...<x_{n}\right\}$ eine Schlüsselmenge aus einem total (quasi)geordneten Reservoir $\scriptstyle R$ von Schlüsseln, seien ferner $\scriptstyle p_{i}$ bzw. $\scriptstyle q_{j}$ Häufigkeiten, mit denen auf das Element $\scriptstyle x\in R$ (oder Äquivalenzklasse resp. Intervall) zugegriffen wird, wobei $\scriptstyle x\in {\overline {x_{i}}}$ für $\scriptstyle 1\leqq i\leqq n$ resp. $\scriptstyle x_{j}<x<x_{j+1}$ für $\scriptstyle 0\leqq j\leqq n$. (Dabei seien $\scriptstyle x_{0}:=-\infty$ und $\scriptstyle x_{n+1}:=+\infty$ zusätzliche nicht zu $\scriptstyle R$ gehörende Elemente mit der üblichen Bedeutung.) Das $\scriptstyle (2n+1)$-Tupel

${\mathfrak {z}}:=\left({\begin{smallmatrix}&p_{1}&&p_{2}&&\cdots &&p_{n}&\\q_{0}&&q_{1}&&q_{2}&&\cdots &&q_{n}\end{smallmatrix}}\right)$

heißt Zugriffsverteilung für die Menge $\scriptstyle X$, wenn alle $\scriptstyle p_{i},q_{j}\geqq 0$ sind. ${\mathfrak {z}}$ wird zur Zugriffswahrscheinlichkeitsverteilung, wenn $\scriptstyle \sum p_{i}+\sum q_{j}=1$ ist.

Sei nun $\scriptstyle T$ ein Suchbaum für die Menge $\scriptstyle X$ mit einer Zugriffsverteilung ${\mathfrak {z}}$, ferner sei $\scriptstyle a_{i}^{T}$ die Tiefe des (inneren) Knotens $\scriptstyle x_{i}$ und $\scriptstyle b_{j}^{T}$ die Tiefe des Blattes $\scriptstyle (x_{j},x_{j+1})$ (s. Abb. 4; jeweils #Terminologie der Abb. 2). Wir betrachten die Suche nach einem Element $\scriptstyle x\in R$. Wenn $\scriptstyle x=x_{i}$, dann vergleichen wir $\scriptstyle x$ mit $\scriptstyle a_{i}^{T}+1$ Elementen im Baum. Wenn $\scriptstyle x_{j}<x<x_{j+1}$, dann vergleichen wir $\scriptstyle x$ mit $\scriptstyle b_{j}^{T}$Elementen im Baum. Also ist

$S_{\mathfrak {z}}^{T}:=\sum _{i=1}^{n}p_{i}(a_{i}^{T}+1)+\sum _{j=0}^{n}q_{j}b_{j}^{T}$

die (mit der Zugriffsverteilung ${\mathfrak {z}}$) gewichtete Pfadlängensumme des Baumes $\scriptstyle T$; ist ${\mathfrak {z}}$ eine Wahrscheinlichkeitsverteilung, dann ist $\scriptstyle S_{\mathfrak {z}}^{T}$ die gewichtete Pfadlänge, die gewichtete Suchtiefe oder die mittlere Anzahl der benötigten Vergleiche. Die Abb. 4 zeigt einen Suchbaum $\scriptstyle T$, der mit einem Wert von $\scriptstyle S_{\mathfrak {z}}^{T}=2$ optimal für die Zugriffsverteilung ${\mathfrak {z}}:={\tfrac {1}{24}}\left({\begin{smallmatrix}&1&&3&&3&&0&\\4&&0&&0&&3&&10\end{smallmatrix}}\right)$ ist.

Sind alle $\scriptstyle p_{i}=1$ und alle $\scriptstyle q_{j}=0$, dann ist $\scriptstyle S_{\mathfrak {e}}^{T}$ mit ${\mathfrak {e}}:=\left({\begin{smallmatrix}&1&&1&&\cdots &&1&\\0&&0&&0&&\cdots &&0\end{smallmatrix}}\right)$ die Summe der erforderlichen Vergleiche, wenn ein jeder der $\scriptstyle n$ Knoten gesucht wird ($\scriptstyle {\mathfrak {e}}$ für erfolgreiche Suche). Sie steht zur so genannten internen Pfadlänge I in der Beziehung

$I:=\sum _{i=1}^{n}a_{i}^{T}=S_{\mathfrak {e}}^{T}-n$.

Für alle binären Suchbäume $\scriptstyle T$ ist:

${\underline {S}}_{\mathfrak {e}}(n)\leq S_{\mathfrak {e}}^{T}\leq n(n+1)/2$,

wobei die obere Grenze von der linearen Kette kommt und die untere $\scriptstyle {\underline {S}}_{\mathfrak {e}}(n)$ von den vollständig balancierten Binärbäumen. Die Funktion $\scriptstyle {\underline {S}}_{\mathfrak {e}}(n)$ ist stückweise linear, streng monoton steigend und konvex nach unten; in Formeln: Ist $\scriptstyle k\in \mathbb {N}$ mit $\scriptstyle 2^{k-1}\leq n+1\leq 2^{k}$, dann ist $\scriptstyle {\underline {S}}_{\mathfrak {e}}(n)=1+(n+1)k-2^{k}$.

Übrigens ist $\scriptstyle {\underline {S}}_{\mathfrak {e}}(n)=A001855(n+1)$ mit der Folge A001855 in OEIS.

Sind dagegen alle $\scriptstyle p_{i}=0$ und alle $\scriptstyle q_{j}=1$, dann ist $\scriptstyle S_{\mathfrak {f}}^{T}$ mit ${\mathfrak {f}}:=\left({\begin{smallmatrix}&0&&0&&\cdots &&0&\\1&&1&&1&&\cdots &&1\end{smallmatrix}}\right)$ die Summe der notwendigen Vergleiche, um alle $\scriptstyle n+1$ Blätter aufzusuchen ($\scriptstyle {\mathfrak {f}}$ für fehlend). $\scriptstyle S_{\mathfrak {f}}^{T}$ wird auch als externe Pfadlänge E bezeichnet:

$E:=\sum _{j=0}^{n}b_{j}^{T}=S_{\mathfrak {f}}^{T}$.

Es gilt für alle Bäume $\scriptstyle T$:

$S_{\mathfrak {f}}^{T}=S_{\mathfrak {e}}^{T}+n$.

Beweis

Die Behauptung ist richtig für n=1.
Sei T ein Baum mit n Knoten. Bei einem Knoten auf der Höhe h fügen wir eine neue Kante und einen neuen Knoten hinzu. $\scriptstyle S_{\mathfrak {e}}^{T}$ erhöht sich um h+1 und $\scriptstyle S_{\mathfrak {f}}^{T}$ um 2(h+1)–h=h+2, also wächst die Differenz $\scriptstyle S_{\mathfrak {f}}^{T}-S_{\mathfrak {e}}^{T}$ um (h+2)–(h+1)=1. ■

Die vollständig balancierten Binärbäume sind auch für die Zugriffsverteilung $\scriptstyle {\mathfrak {f}}$ optimal, und es gilt für alle binären Suchbäume $\scriptstyle T$:

${\underline {S}}_{\mathfrak {f}}(n)\leq S_{\mathfrak {f}}^{T}\leq n(n+3)/2$

mit $\scriptstyle {\underline {S}}_{\mathfrak {f}}(n):={\underline {S}}_{\mathfrak {e}}(n)+n$.

Übrigens ist $\scriptstyle {\underline {S}}_{\mathfrak {f}}(n)=A003314(n+1)$ mit der Folge A003314 in OEIS, und $\scriptstyle n+1$ ist die Anzahl der externen Knoten (Blätter).

Traversierung

Traversierung (Querung) bezeichnet das systematische Erforschen der Knoten des Baumes in einer bestimmten Reihenfolge.

Es gibt verschiedene Möglichkeiten, die Knoten von Binärbäumen zu durchlaufen. Beim binären Suchbaum sind jedoch die sog. in-order- oder reverse in-order-Traversierungen die eindeutig bevorzugten, da sie mit der eingeprägten Totalordnung korrespondieren.

Traversierung (Einzelschritt)

Der folgende Pseudocode Next gibt ausgehend von einem Knoten das nächste Element in ab- oder aufsteigender Reihenfolge zurück – eine iterative Implementierung. Der Vorschlag kommt ohne Zeiger zum Elterknoten aus. Dafür muss das Eingabeobjekt, hier #Cursor genannt, den ganzen Pfad vom aktuellen Knoten bis zur Wurzel enthalten, und dieser muss von der Next-Funktion auch entsprechend gepflegt werden, wenn Next in einer Schleife verwendet wird. Die passende Datenstruktur für den Pfad ist der Stapelspeicher, engl. Stack, mit den Operationen push und pop.

Die etwas einfachere Version der Funktion, bei der ein Zeiger zum Elter in jedem Knoten vorausgesetzt wird und deshalb der Cursor ohne Stack auskommt, ist beim Binärbaum aufgeführt. Der Speicherbedarf für den Baum erhöht sich allerdings um einen festen Prozentsatz.

Bei einer längeren Traversierung (mehreren Aufrufen von Next) wechseln sich Halbblätter und höherrangige Vorfahren ab.

Next(c) {
  c: Cursor {               // Dieser Cursor enthält:
     c.d: Richtung          // (1) Left, Right oder EndOfTree
     c.n: Knoten            // (2) Knoten oder Baum (nur bei EndOfTree)
     c.t: Baum              // (3) Baum (enthält den Zeiger zur Wurzel)
     c.p: Pfad              // (4) Pfad vom Elter des Knotens zur Wurzel
  }
  x,y: Knoten

  x = c.n                   // Ausgangsknoten dieses Einzelschritts
  d = c.d                   // gewünschte Richtung der Traversierung
  y = x.child[d]
  if y ≠ null then {        // 1 Schritt in die gegebene Richtung
     push(c.p, x)           // Elter von y in den Stack
     d = 1 - d              // spiegele  Left <-> Right
     // Abstieg in Richtung Blätter über Kinder in der gespiegelten Richtung
     x = y.child[d]
     while x ≠ null do {
        push(c.p, y)        // Elter von x in den Stack
        y = x
        x = y.child[d]
     }
     c.n = y                // Ergebnis: das nächste Halbblatt in Richtung c.d
     return c               // (Es ist Halbblatt auf seiner (1-c.d)-Seite.)
  }
  // Am Anschlag, deshalb Aufstieg zur Wurzel über die Vorfahren in der ...
  do {                      // ... c.d-„Linie“ (nur linke oder nur rechte)
     y = x
     x = pop(c.p)           // Elter von y aus dem Stack
     if x = c.t then {      // y ist die Wurzel.
        // Somit gibt es kein Element mehr in dieser Richtung.
        c.n = c.t           // Ergebnis: der Baum als Elter der Wurzel
        c.d = EndOfTree     // signalisiere das Ende der Traversierung
        return c
     }
  } until y ≠ x.child[d]
  // Es gab beim Aufsteigen einen Richtungswechsel:
  c.n = x                   // Ergebnis: der erste Vorfahr in der gespiegelten Richtung
  return c
}

Die Traversierung über den ganzen Baum umfasst pro Bogen einen Abstieg und einen Aufstieg; der Aufwand bei n Knoten ist also 2·n ∈ Θ(n) . Daher ist der Aufwand für eine Einzel-Traversierung im Mittel O(1). Im schlechtesten Fall ist er O(h) mit h als der Höhe des Baums.

Für rekursive Implementierungen siehe Binärbaum.

Proximitäts-Suche

Zusammen mit der Suchfunktion lässt sich mit der oben gezeigten Einzelschritt-Traversierung eine „Proximitäts“-Suche realisieren. (Proximitäts-Suche ist ein Arbeitstitel. Der Sachverhalt ist nichts Besonderes und kommt in der Literatur sicherlich vor, ist aber jetzt nicht gefunden worden. „Unscharfe Suche“ als Fuzzy-Suche ist schon vergeben und bedeutet etwas wesentlich Anderes.) Gemeint ist eine Suche in der Nähe eines bestimmten Schlüssels, zum Beispiel auf „größer gleich“ (bzw. „kleiner gleich“). Die obigen Suchfunktionen Find, FindDupGE und FindDup liefern nämlich im „ungleich“-Fall einen Einfügepunkt. Dieser enthält, wenn der Baum nicht leer ist, ein Element, das entweder das kleinste unter den größeren ist oder das größte unter den kleineren. Im ersteren Fall können wir den Wunsch „größer gleich“ direkt befriedigen. Im letzteren Fall gehen wir zum nächsten Element in aufsteigender Reihenfolge, wenn es noch eines gibt, und geben dieses zurück, denn es muss ein größeres sein. Die Logik für die gespiegelte Version liegt auf der Hand.

Eine ähnliche Vorgehensweise findet sich bei der Index Sequential Access Method.

Einfügen

Es sei angenommen, dass die Navigation zum Einfügepunkt bereits erledigt ist. Einfügepunkt bedeutet einen Knoten und eine Richtung (rechts bzw. links). Ein unmittelbarer Einfügepunkt in einem binären Baum ist immer ein rechtes (bzw. linkes) Halbblatt (d. i. ein Knoten ohne rechten (bzw. linken) Kindknoten) zusammen mit dieser Richtung. (In der Sichtweise der Abb. 2 entspricht dies genau einem externen Knoten.) Ein mittelbarer ist der unmittelbare Nachbar in der angegebenen Richtung und spezifiziert zusammen mit der Gegenrichtung dieselbe Stelle im Binärbaum – zum echten Einfügen muss aber die Einfügefunktion noch bis zu dem Halbblatt hinabsteigen, welches den unmittelbaren Einfügepunkt darstellt. Die obigen Funktionen Find, FindDupGE und FindDup liefern als Ergebnis einen (unmittelbaren) Einfügepunkt (Find nicht bei „Equal“).

Zum Einfügen lässt man den unmittelbaren Einfügepunkt (das Kind in der entsprechenden Richtung) auf das neue Element zeigen, damit ist dieses korrekt entsprechend der totalen Quasiordnung eingefügt. Die Komplexität der Einfügeoperation ist somit konstant. Wird allerdings ein Suchvorgang mit hinzugerechnet, dominiert dieser die Komplexität.

Nach dem Einfügen ist das neue Element ein Blatt des Suchbaums.

Durch wiederholtes Einfügen von aufsteigend (oder absteigend) sortierten Schlüsseln kann es dazu kommen, dass der Baum zu einer linearen Liste entartet.

Löschen

Das Löschen im binären Suchbaum unterscheidet sich nicht vom Löschen in einem binären Baum. Gegeben ist der zu löschende Knoten.

Durch wiederholtes Löschen kann es dazu kommen, dass der Baum zu einer linearen Liste entartet.

Wegen der unvermeidlichen Abstiege bis zu den Halbblättern ist die Komplexität der Löschoperation im schlechtesten Fall O(h), wobei h die Höhe des Baumes ist.

Implementierung

Darstellung eines Binärbaums im Speicher

Die Abbildung zeigt eine naheliegende Art der Speicherung. Sie entspricht in etwa den C-Strukturen:

struct node { // 1 Objekt = 1 Knoten
  char key;
  struct node * Kind_links;
  struct node * Kind_rechts;
} object;
struct node * Kopf; // Zeiger auf die Wurzel

Zur besseren Unterscheidung der Objekte sind diese beziehentlich mit den Schlüsseln „F“, „G“, „J“ und „P“ versehen. Diese Schlüssel sind auch der Einfachheit halber als Ziel der Verweise genommen worden (anstelle von echten Speicheradressen). Wie üblich soll ein Zeigerwert 0 ausdrücken, dass auf kein Objekt verwiesen wird, es also kein Kind an dieser Stelle gibt.

Kopf

Da die Wurzel einer Löschung oder einer Rotation anheim fallen, somit den Baum nicht repräsentieren kann, muss diese Rolle von einer anderen Datenstruktur übernommen werden, die in der Literatur Kopf genannt wird. Sie enthält den Zeiger zur Wurzel und fungiert als eine Art Elter der Wurzel.

Iterative Programmierung

In der Literatur werden die Operationen häufig in rekursiver Programmierung vorgestellt. Der Anwender hat aber mehrere Vorteile davon, wenn der Implementierer die vom Aufschreiben her eleganten Rekursionen durch simple Iterationen ersetzt hat, da dadurch h (Höhe) Prozeduraufrufe und -rücksprünge eingespart werden und der Speicherbedarf für den Programm-Stapelspeicher konstant gehalten wird. Es geht aber nicht nur um Ressourcenschonung. Bei der Traversieroperation wird dadurch beispielsweise die Programmierung der Anwendung wesentlich vereinfacht. Für das Aufbewahren des Rückwegs zu Wurzel und Kopf, der beim Traversieren, aber auch häufig bei Modifikationen zur Aufrechterhaltung der Bauminvarianten (AVL- oder Rot-Schwarz-Kriterium), gebraucht wird und der bei der rekursiven Programmierung neben anderem im Programmstapelspeicher steckt, muss dann ein anderes, explizites Konstrukt gewählt werden, welches sich im Cursor (siehe unten) subsumieren lässt.

Dadurch wird eine Trennung der modifizierenden Operationen von der Navigation möglich.

Trennung der navigierenden von den modifizierenden Operationen

Einfüge- und Löschoperation sind sinnvollerweise von der Suchoperation zu trennen, wenn zum Einfügepunkt beziehungsweise Knoten auch auf andere Weise als mit der Standardsuchoperation navigiert werden soll, beispielsweise mittels eines Querschritts oder mithilfe einer zweiten Suchstruktur für dasselbe Element wie in der #Anwendung mit mehreren Zugriffspfaden.

Diese Modularisierung der Navigations- von den modifizierenden Operationen setzt einen gegebenenfalls unterlogarithmischen (sprich: konstanten) Aufwand der letzteren frei, denn ein Aufstieg bis zur Wurzel ist beispielsweise bei AVL-Baum und Rot-Schwarz-Baum nur in Ausnahmefällen erforderlich. In Anwendungen mit starkem sequentiellem Anteil kann sich das positiv auf die Laufzeit auswirken.

Cursor

Beim Suchen wird ein Paar (Knoten, Richtung) erzeugt, welches geeignet ist, beim Einfügen den Einfügepunkt zu spezifizieren. Beim Löschen wird der zu löschende Knoten durch die Komponente Knoten bezeichnet, und die Komponente Richtung kann angeben, wohin der Cursor nach der Löschung fortschreiten soll. Beim Traversieren gibt Knoten den Ausgangspunkt und Richtung die gewünschte Richtung der Navigation an, um im Ergebnis wieder bei einem solchen Paar anzukommen. Damit erzeugen und/oder verbrauchen alle wichtigen Operationen ein Konstrukt, das (in Analogie zum Beispiel zu den Datenbanken) Cursor genannt wird.

Die Größe des Cursors hängt entscheidend davon ab, ob die Knoten einen Zeiger zum Elter enthalten oder nicht.

1. Elterzeiger vorhanden: Ein Paar (Knoten, Richtung) stellt einen vollwertigen Cursor dar.
   Ein Cursor wird nach einer Operation dann und nur dann ungültig, wenn es sich um eine Löschung handelt, und der Knoten des Cursors das Ziel der Löschung ist.
   Mit dem prozentualen Aufschlag auf den Speicherbedarf für die Datenstruktur erkauft man sich auf jeden Fall eine prozentuale Einsparung an Laufzeit, da der Rückweg zu Wurzel und Kopf immer schon gesichert ist.
2. Zeiger zum Elterknoten nicht vorhanden („Cursor mit Stapel“): Zusätzlich zum Paar (Knoten, Richtung) muss der Pfad vom Knoten zu Wurzel und Kopf im Cursor gehalten werden. Die Länge des Cursors entspricht damit der maximalen Höhe des Baums. Diese ist entweder von sich aus ausreichend beschränkt (vorgerechnetes Beispiel AVL-Baum), oder der Stapelüberlauf löst eine Reorganisation des Baums oder ein abnormales Ende aus.
   Bei allen Operationen ist der Zugriff zum Elterknoten über den Stapel im Cursor geringfügig teurer als über den Elterzeiger. Soll der Pfad im Cursor auch nach einer modifizierenden Operation gültig gehalten werden (beispielsweise für sequentielle Einfügungen oder Löschungen), kommt noch ein zusätzlicher prozentualer Aufschlag hinzu. Dies kann so aber nur für einen Cursor, den Eingabecursor, erbracht werden.

Benötigt eine Anwendung mehrere Cursor für ein und denselben Suchbaum und über Änderungen an ihm hinweg, dann kann das Aufrechterhalten der Konsistenz der Cursor mit Stapel (zum Beispiel durch erneutes Suchen) so aufwändig werden, dass es wirtschaftlicher ist, dem Baum Elterzeiger zu spendieren.

Anwendung mit mehreren Zugriffspfaden

Als Beispiel für eine Anwendung mit 2 Zugriffspfaden sei ein klassisches Speichermanagement gebracht. Elemente der Datenstruktur sind die freien Speicherblöcke mit den Attributen (Feldern) Größe und Ort. Für jedes der beiden Felder gebe es eine Suchstruktur. Beim Akquirieren wird ein Block von Mindestgröße gesucht, ausgetragen und ein eventueller Rest wieder eingetragen. Bei der Speicherrückgabe wird nach Ort gesucht, auf Konfliktfreiheit mit den Nachbarblöcken geprüft (ebenfalls ein Beispiel für die Nützlichkeit der Querschritts) und der zurückzugebende Block gegebenenfalls mit diesen verschmolzen. Alle Veränderungen müssen auf beiden Suchstrukturen durchgezogen werden. Sind Elterzeiger vorhanden, dann erspart das Hangeln von der einen Suchstruktur zur anderen einen Suchvorgang.

Anwendungen

Wie Ben Pfaff zeigt, decken die dynamischen Suchbaumstrukturen AVL-Baum, Rot-Schwarz-Baum und Splay-Baum dieselben wesentlichen Funktionen ab. Große Unterschiede stellt er im Laufzeitverhalten fest, wobei der AVL-Baum in Median und Mittelwert am besten abschneidet.

In der Informatik haben die dynamischen Suchbaumstrukturen einen großen Einsatzbereich als grundlegende Hilfsmittel bei:

• Duplikatunterdrückung, Deduplikation, Duplikaterkennung
• Elementare Mengenoperationen wie Durchschnittsbildung und Vereinigung
• Standard Template Library (STL)

Bei Ben Pfaff finden sich systemnahe Anwendungen (alle unter x86-based Linux):

• Verwaltung von Virtual Memory Areas (VMAs) unter Einschluss von range queries zur Feststellung des Überlappens von existierenden VMAs (S. 4)
• Eindeutige Kennzeichnung von IP-Paketen (S. 7)

Ferner:

• Liste der Variablen in einem Programm, die ein Interpreter zu pflegen hat: der Interpreter muss jederzeit in der Lage sein zu entscheiden, ob einer Programmvariablen momentan ein Wert zugewiesen ist und gegebenenfalls welcher. Ähnliches gilt für einen Compiler.
• Binarytreesort (Sortieren durch Einfügen)
• In #Anwendung mit mehreren Zugriffspfaden ein klassisches Speichermanagement.

Auswahlkriterien

Das binäre Suchen im Array kann als eine Art Vorläufer der binären Suchbäume angesehen werden. Da es sich bei Einfügungen und Löschungen linear verhält und dann auch die Speicherverwaltung seines Arrays sorgfältig überlegt werden muss, wird es in der Praxis fast nur für statische, vorsortierte Tabellen eingesetzt. Sind also Einfügungen oder Löschungen für die Anwendung wichtig, sind die Binärbäume geeigneter. Bezüglich Suchzeit und Speicher verhalten sich binäres Suchen im Array und höhenbalancierte binäre Suchbäume asymptotisch gleich.

Obwohl rein zufällige binäre Suchbäume sich im Mittel logarithmisch verhalten, garantiert ein binärer Suchbaum ohne irgendeine Vorkehrung, die einer Entartung entgegenwirkt, keineswegs eine unterlineare Laufzeit. Entartungen können systematisch vorkommen, zum Beispiel wenn ein Programmierer massenhaft nahe benachbarte Sprungmarkennamen vergibt.

Es gibt jedoch sehr viele Konzepte, die dazu entwickelt wurden, eine ausreichende Ausgeglichenheit sicherzustellen. Hierbei stehen sich immer Aufwand und Ertrag gegenüber. Zum Beispiel ist der Aufwand, einen binären Suchbaum ständig vollständig balanciert zu halten, so hoch, dass sich das nur bei Anwendungen lohnen dürfte, deren Laufzeit in extremer Weise vom Suchen dominiert wird.

Ein wichtiges Kriterium für die Auswahl ist, ob der Binärbaum statisch ist, und so ein einmaliger optimaler Aufbau ausreicht, oder ob verändernde Operationen wie Einfügen und Löschen wichtig sind. Für erstere kommen gewichtete Suchbäume in Betracht, worunter auch der Bellman-Algorithmus. Bei letzteren sind höhen-balancierte Suchbäume wie der AVL-Baum und der Rot-Schwarz-Baum, aber auch Splay-Bäume von Interesse.

Eine Gegenüberstellung von Komplexitäten verschiedener Suchalgorithmen finden sich im Artikel Suchbaum; Laufzeitmessungen anhand realistischer Beispiele sind zu finden bei Pfaff 2004b.

Bei diesen Überlegungen wurde generell angenommen, dass der ganze Baum im Arbeitsspeicher (Hauptspeicher) untergebracht ist. Spielen Zugriffe zu externen Medien eine Rolle, kommen ganz andere Kriterien hinzu. Schon der B-Baum, der solche Gesichtspunkte berücksichtigt, ist zwar ein Suchbaum, aber nicht mehr binär.

Historisches

Die im Abschnitt Motivation erwähnte, sehr bekannte Suchstruktur Binäre Suche im Array gilt als Vorläufer der dynamischen Suchbaumstrukturen. Als naheliegende Umsetzung des Nachschlagens in einem (sortierten) Wörterbuch, dürfte sie mehrfach und ohne Kenntnis anderer Implementierungen entwickelt und implementiert worden sein. Im dynamischen Anwendungsfall kann sie aber mit den neueren Entwicklungen nicht mithalten, obwohl sie im statischen Fall eine hervorragende Lösung ist. Es gibt Makros, die einen Compiler veranlassen, zu einer gegebenen (sortierten) Tabelle von (Schlüssel, Werte)-Paaren Quelltext für eine iterierende oder schleifenlose binäre Suche zu erzeugen.

Im Jahr 1962 erschien zum ersten Mal eine dynamische Suchbaumstruktur in Form des AVL-Baums. Seine Erfinder sind die genannten sowjetischen Mathematiker Georgi Adelson-Welski und Jewgeni Landis. Ihr Beitrag im Journal Doklady Akademii Nauk SSSR wurde noch im selben Jahr ins Englische übersetzt. Die Übersetzung trägt (wie entsprechend das Original) den sehr ehrgeizigen Titel „An algorithm for the organization of information“. Die Bezeichnung AVL-Baum findet sich in dieser Übersetzung nicht.

Im Jahr 1970 veröffentlichte Rudolf Bayer seine erste Arbeit über den B-Baum. Er ist kein Binärbaum, unterstützt heterogene Speicher, beispielsweise Hauptspeicher und Hintergrundspeicher, und wird bei Datenbanksystemen eingesetzt.

Danach folgte im Jahr 1972 zunächst unter dem Namen „symmetric binary B-tree“ der Rot-Schwarz-Baum von Rudolf Bayer. Ihm war die Balance-Regel des AVL-Baums zu streng. Eine Umbenennung erfolgte 1978 von Leonidas Guibas und Robert Sedgewick in das heute übliche „red–black tree“, später auch „RB tree“.

Splay-Bäume wurden im Jahr 1985 von Daniel Sleator und Robert Tarjan unter dem Namen „Self-Adjusting Binary Search Trees“ vorgestellt. Sie sind noch dynamischer als die vorgenannten, indem sie sich auch bei Suchoperationen verändern.

Eine grobe Gegenüberstellung dynamischer Suchbäume findet sich im

→ Hauptartikel: Suchbaum

Siehe auch

• B-Baum
• Balancierter Baum
• Binäre Priorisierung
• gewichteter binärer Suchbaum
• Suchbaum

Literatur

• Donald Knuth. The art of computer programming Volume 3, Sorting and Searching, Dritte Auflage. Addison-Wesley, 1997. ISBN 0-201-89683-4.
• Kurt Mehlhorn: Datenstrukturen und effiziente Algorithmen. Teubner Stuttgart 1988, ISBN 3-519-12255-3.
• Kurt Mehlhorn, Peter Sanders: Algorithms and Data Structures. The Basic Toolbox. Springer, Berlin / Heidelberg 2008, ISBN 978-3-540-77977-3, doi:10.1007/978-3-540-77978-0. 

Weblinks

• Ben Pfaff 2004a „An Introduction to Binary Search Trees and Balanced Trees“, (englisch, PDF, 1675 kB).
• Ben Pfaff 2004b „Performance Analysis of BSTs in System Software“, (englisch, PDF, 316 kB). Stanford University