Informatik I. Kapitel Rainer Schrader Elementare Zentrum für Angewandte Informatik Köln 8. Mai 008 / / bisher haben wir nur Arrays verwendet, Gliederung Einführung abstrakte Datentypen Listen Stacks und queues Anwendungsbeispiele Bäume effiziente Algorithmen brauchen geeignete Datenstruktur Beispiel: Suche im Telefonbuch gegeben: Name gesucht: Telefonnummer einfach gegeben: Telefonnummer gesucht: Name praktisch unmöglich 3 / 4 /
Nichttriviales Beispiel: Posamp-Problem gegeben: n Orte (Postämter) M = {p, p,..., p n } ihre kartesischen Koordinaten p i = (x i, y i ) zusätzlicher Ort p 0 = (x 0, y 0 ) gesucht: das zu p 0 nächstgelegene Postamt p k, d.h. d (p 0, p k ) d (p 0, p i ) für alle i {,..., n} mit d (p i, p j ) = p (x i x j ) + (y i y j ) (Euklidische Distanz) offensichtlich ist das Problem in der Zeit Θ(n) lösbar, aber es geht besser, wenn man viele Anfragen zu einem festen M hat Informelle Beschreibung einer geeigneten Datenstruktur sei VR(p j ) die Menge aller Punkte der Ebene, die näher an p j als an jedem anderen Punkt in M liegen, also VR(p j ) = n o q R d (q, p j ) d (q, p i ) i {,,... n}. VR(p j ) ist die Voronoi-Region von p j das Voronoi-Diagramm ist die Menge VD(M) = {VR(p j ) j {,,..., n}} 5 / 6 / Beispiel: Idee eines effizienten Verfahrens für eine beliebige Anfrage (AD) Aufbau der Datenstruktur: bestimme das Voronoi-Diagramm VD(M). (BA) Beantwortung einer Anfrage: für eine Anfrage p 0 : bestimme VR(p k ) mit p 0 VR(p k ). man kann zeigen: (evtl. Kapitel 0) (AD) benötigt O(n log n) Zeit. (BA) benötigt O(log n) Zeit. 7 / 8 /
Gliederung Einführung abstrakte Datentypen Listen Stacks und queues Anwendungsbeispiele Bäume sollen Operationen auf Objekten unterstützen evtl. verschiedene für verschiedene Operationen evtl. Verknüpfung von Objekten und Operationen (Klassen) Abstrakter Datentyp (ADT) besteht aus einer oder mehreren Mengen von Objekten und darauf definierten Operationen 9 / 0 / Beispiel Postamtproblem : Objekte: endliche Mengen M von Punkten in der Ebene ein Punkt p 0 in der Ebene Beispiel: Formulierung eines Algorithmus mit Hilfe von ADT Aufgabe: gegeben eine endliche Menge M von Punkten in der Ebene finde ein Paar p 0, q 0 von Punkten mit minimalem Abstand d (p 0, q 0 ) Operation nächster Nachbar : ordne dem Punkt p 0 Punkt aus M zu Mögliche zusätzliche Operationen: füge einen Punkt zu M hinzu entferne einen Punkt aus M Wir haben jedesmal einen anderen ADT. einen nächstgelegen ADT: Objekt: endliche Punktmenge M Operationen: nächster Nachbar Distanz zweier Punkte Kardinalität von M M := M {p} / /
Algorithmus nearest_neighbours(m) liefert p 0, q 0 M mit minimaler Distanz d (p 0, q 0 ) falls M = oder M =, so sind p 0 und q 0 nicht definiert falls M : Implementierung (Realisierung als Computerprogramm) wähle zwei Punkte p 0, q 0 M berechne die Distanz dist := d (p 0, q 0 ) Auswahl von für die Objektmengen Auswahl von Algorithmen für die Operationen for all p M do end do bestimme einen nächsten Nachbarn q M {p} berechne die Distanz d (p, q) falls d (p, q) < dist, so setze: p 0 := p; q 0 := q; dist := d (p, q). 3 / 4 / Lineare Liste Gliederung Einführung abstrakte Datentypen Listen Stacks und queues Anwendungsbeispiele Bäume Objekte: Menge aller endlichen Folgen eines gegebenen Grundtyps die Schreibweise für eine lineare Liste ist L = a, a,..., a n, hierbei ist L = die leere Liste verschiedene Operationen im Folgenden ist L eine lineare Liste, x vom Grundtyp und p eine Position 5 / 6 /
Füge_ein(x,p,L) falls L = a, a,..., a p, a p, a p+,..., a n = : Entferne(p,L) für L und p n gilt: L a, a,..., a p, x, a p, a p+,..., a n für < p n L x, a, a,..., a n für p = L a, a,..., a n, x für p = n + falls L = und p = : x undefiniert sonst aus wird undefiniert sonst a, a,..., a p, a p, a p+,... a n a, a,..., a p, a p+,... a n. 7 / 8 / Suche(x,L) liefert eine Position p in L = a, a,..., a n mit a p = x, falls diese existiert, sonst 0. Verkette(L,L,L) liefert für L = a, a,..., a n und L = b, b,..., b n Zugriff(p,L) liefert a p in L = a, a,..., a n, falls p n, sonst undefiniert. die Liste L = a, a,..., a n, b, b,..., b n. 9 / 0 /
Gliederung Darstellungen linearer Listen sequentielle Darstellung zusammenhängende Speicherung als Feld mit direktem Zugriff verkettete Listen verteilte Speicherung, durch Zeiger verknüpft Einführung abstrakte Datentypen Listen sequentielle Listen verkettete Listen Stacks und queues Anwendungsbeispiele Bäume / / Füge_ein(x,p,L) Sequentielle Listen Eine sequentiell gespeicherte Liste L besteht aus: einer (hinreichend großen) Konstanten maxelzahl einem Feld element[0,..., maxelzahl] der aktuellen Listengröße elzahl Ist 0 < L.elzahl L.maxelzahl, so ist in L.element(),..., L.element(elzahl) die aktuelle Liste abgelegt. \\ fügt x als neues Element an Stelle p ein, falls p zulässig, gibt andernfalls Fehlermeldung aus if (L.elzahl = L.maxelzahl or p < or p > L.elzahl + ) print Fehler else for i = L.elzahl down to p do L.element(i+) = L.element(i) end do L.element(p) = x L.elzahl = L.elzahl+ end if 3 / 4 /
Entferne(p,L) Suche(x,L) \\ entfernt das p. Element, falls p zulässig, gibt andernfalls Fehlermeldung aus if (L.elzahl = 0 or p < or p > L.elzahl) print Fehler else L.elzahl = L.elzahl - for i = p to L.elzahl do L.element(i) = L.element(i+) end do end if \\ liefert die höchste Position, an der x in L vorkommt, 0 sonst L.element(0) = x i = L.elzahl while (L.element(i) x) do i = i- end while return i 5 / 6 / Zugriff(p,L) Verkette(L,L,L) \\ gibt das p. Element aus, falls p zulässig, gibt andernfalls Fehlermeldung aus if (p < or p > L.elzahl) print Fehler else return L.element(p) end if \\ hänge L an L an, falls L ausreichend lang if (L.elzahl + L.elzahl > L.maxelzahl) print Fehler else if (L.elzahl > 0) then do for i = to L.elzahl do L.element(L.elzahl + i) = L.element(i) end do end if L.elzahl = L.elzahl + L.elzahl end if 7 / 8 /
Laufzeiten Sei n die Länge der Liste Operation Zeit suche O(n) füge_ein O(n) entferne O(n) Zugriff O() verkette O(n ) Gliederung Einführung abstrakte Datentypen Listen sequentielle Listen verkettete Listen Stacks und queues Anwendungsbeispiele Bäume 9 / 30 / eine mögliche Implementation von verketteten Listen eine Liste L = a, a,..., a n lässt sich wie folgt darstellen: eine verkettete Liste wird kreuz und quer im Speicher abgelegt eine Liste ist gegeben als eine Folge von Knoten a a... a n jeder Knoten besteht aus (a) einem Listenelement dat head DUMMY-Elemente tail (b) einem Zeiger next auf das nächste Listenelement zwei Dummy-Elemente als Kopf und Schwanz der Liste einem Zeiger head auf das Kopfelement eine leere Liste sieht dann wie folgt aus: einem Zeiger tail auf das Schwanzelement der Zeiger des Schwanzelements zeigt auf das vorangehende Element head tail 3 / 3 /
Vereinbarung: Die Position p ist gegeben durch einen Zeiger auf den Knoten, dessen Zeiger auf das p.te Listenelement zeigt: Füge_ein(x,p,L) Zeiger von x := Zeiger von Element p Zeiger von Element p := Zeiger auf x Skizze für Füge_ein: a p vorher: a p a p p p nachher: a p a p Die Listenoperationen lassen sich wie folgt durchführen: x Wir überprüfen hier nicht, ob p ein legaler Zeiger ist. 33 / 34 / Entferne(p,L) Zeiger von p := Zeiger von Element p (entferne Knoten p) Suche(x,L) liefert die Position des ersten Listenelements mit dem Schlüssel x, falls es existiert, sonst NULL. Skizze für Entferne(p,L): vorher: nachher: a p a p a p+ p a p a p+ Suche(x,L) kopiere x in das Datumsfeld des Schwanzes beginnend mit dem Kopfelement suche nach x wird x in einem Element p gefunden: ist p nicht das Schwanzelement: gib Zeiger auf p zurück andernfalls gib Null zurück Wir überprüfen hier nicht, ob p ein legaler Zeiger ist. 35 / 36 /
Verkette(L,L,L) tail zeigt auf das Schwanzelement von L der Zeiger dieses Schwanzelements zeigt auf das letzte Element von L biege dessen Zeiger auf den Zeiger des Kopfelements von L um entferne das Schwanzelement von L und das Kopfelement von L Skizze für Verkette: head Doppelte Verkettung manchmal ist es hilfreich, eine Kette auch rückwärts durchlaufen zu können wir verwenden einen zusätzlichen Zeiger auf den jeweiligen Vorgänger hier können wir die Position p durch einen Zeiger auf den Knoten mit dat-komponente a p definieren head... a p a p a p+ tail Beispiel für Entferne: p... tail a p a p+ head tail 37 / 38 / Zusammenfassung: Operation sequentiell verkettet suche Θ(n) Θ(n) füge_ein Θ(n) Θ() entferne Θ(n) Θ() Zugriff Θ() Θ() verkette Θ(n ) Θ() Gliederung Einführung abstrakte Datentypen Listen Stacks und queues Anwendungsbeispiele Bäume 39 / 40 /
Stapel ist eine spezielle Liste Einfügen und Entfernen nur am Anfang der Liste erlaubt LIFO : last-in-first-out Operationen: empty(l): teste, ob L leer ist push(l,x): füge x am Anfang von L ein pop(l,x): setze x := a ; entferne a Schlange ist eine spezielle Liste Einfügen nur am Ende, Entfernen nur am Anfang der Liste FIFO : first-in-first-out Operationen: enqueue(l,x): füge x am Ende von L ein dequeue(l,x): setze x = a, entferne a aus L empty(l): teste, ob L leer ist top(l,x): setze x := a (ohne zu entfernen) top(l,x): setze x := a (ohne zu entfernen) 4 / 4 / Doppelschlangen beide push- und pop-operationen sowie empty(l), top(l,x), bottom(l,x) alle Stapel-, Schlangen- und Doppelschlangen-Operationen können mit konstanter Laufzeit implementieren werden sowohl sequentiell als auch verkettet Anwendung als Warteschlangen und Vorrangwarteschlangen sequentiell implementierte Schlangen sollten zyklisch verwaltet werden 43 / 44 /
Skizzen für sequentielle Speicherung Stapel (Doppel )Schlange maxn 0000 0000 0000 0000 0000 0000 frei Stapel 0000000000 0000000000000 000000000000000 Anfang00000000000000000 000000000000000000 0000000000000000000 0000000000000000000 frei 0000000000000000000 0000000000000000000 maxn 0000000000000000000 0000000000000000000 0000000000000000000 0 0000000000000000000 Ende000000000000000000 00000000000000000 000000000000000 0000000000000 00000000000 0000000 Gliederung Einführung abstrakte Datentypen Listen Stacks und queues Anwendungsbeispiele Bäume 45 / 46 / Anwendung eines Stapels: wohlgeformte Klammerausdrücke Test, ob Klammerfolgen wohlgeformt sind Beispiel: (()()) Beispiel: ((())( Definition eines wohlgeformten Klammerausdrucks () () ist ein wohlgeformter Klammerausdruck () sind w und w wohlgeformte Klammerausdrücke, so ist auch w w ein wohlgeformter Klammerausdruck (3) mit w ist auch (w ) ein wohlgeformter Klammerausdruck (4) nur die nach () bis (3) gebildeten Zeichenketten sind wohlgeformte Klammerausdrücke 47 / 48 /
Anwendung eines Stapels: Test von Klammerausdrücken durchsuche Zeichenkette von links nach rechts wird ( gefunden: lege sie auf Stapel wird ) gefunden: ist Stapel leer nicht wohlgeformt andernfalls entferne obere Klammer vom Stapel am Ende: ist Stapel nicht leer nicht wohlgeformt andernfalls wohlgeformt Anwendung von Listen: Datenstruktur für Projektplanungen gegeben: n Teilprojekte eines Projekts (Bauprojekt, Kfz-Fertigung, ) mit Zeitangaben über die Dauer der Teilprojekte Reihenfolgebedingungen zwischen einzelnen Teilprojekten bestimme: Gesamtdauer Pufferzeiten kritische Pfade 49 / 50 / Beispiel mit 4 Teilprojekten 6 TP : Dauer: TP : Dauer: 6, muss warten auf Beendigung von TP, TP 3 TP 3 : Dauer: 9, muss warten auf Beendigung von TP 3 4 9 7 TP 4 : Dauer: 7, muss warten auf Beendigung von TP, TP 3 Darstellung mit verketteten Listen 6 3 4 3 4 3 4 9 7 4 NIL 5 / 5 /
gerichteter Graph G = (V, E ) besteht aus: einer endlichen Menge V von Knoten einer endlichen Menge E von gerichteten Kanten jeder Kante e E entspricht ein Paar u, v von Knoten u Startknoten, v Endknoten von e wir identifizieren e und das Knotenpaar, d.h. e = (u, v ) Veranschaulichung wie vorher: Knoten als Kreise Kanten als Pfeile Darstellung z.b. durch Adjazenzlisten (ungerichteter) Graph G = (V, E ) besteht aus: einer endlichen Menge V von Knoten einer endlichen Menge E von Kanten jeder Kante e E entspricht ein Paar u, v von Knoten u, v sind die Endknoten von e wir identifizieren e und das Knotenpaar, d.h. e = {u, v } Veranschaulichung: Knoten als Kreise Kanten als Verbindungen, Strecken, Darstellung z.b. durch Adjazenzlisten 53 / 54 / 3 4 Darstellung mit verketteten Listen 3 3 3 4 4 Gliederung Einführung abstrakte Datentypen Listen Stacks und queues Anwendungsbeispiele Bäume 4 3 55 / 56 /
Bäume wir werden im Laufe der Vorlesung immer wieder auf graphentheoretische Modelle und Fragestellungen stoßen insbesondere kann die nächste Datenstruktur als gerichteter Graph aufgefasst werden sie stellt ebenso eine Verallgemeinerung von Listen dar bestehen aus: einer endlichen Menge V von Knoten ein Knoten ist als Wurzel ausgezeichnet jeder Knoten hat eine endliche Menge von direkten Nachfolgern (Söhnen) die Wurzel hat keinen direkten Vorgänger (Vater) jeder andere Knoten hat genau einen direkten Vorgänger 57 / 58 / Sprechweisen Bäume (rekursive Definition) bestehen aus einer endlichen Menge V von Knoten, so dass gilt: Sei T ein Baum mit Wurzel r und Unterbäumen T,..., T k. Ferner sei r i die Wurzel des Baumes T i. es gibt einen ausgezeichneten Knoten r (Wurzel) die restlichen Knoten sind partitioniert in Teilmengen T,..., T k, die selbst wieder Bäume sind r zeigt auf die Wurzeln der Teilbäume r,..., r k r i ist i-ter Sohn von r, r ist Vater der r,... r k, r j ist Bruder von r i, u ist Nachfolger von r i, falls u im Unterbaum T i ein Knoten ohne Nachfolger heißt Blatt, liegt, Knoten von T, die nicht Blatt sind, heißen innere Knoten, 59 / 60 /
Bezeichnungen Sprechweisen T T Niveau Sei T ein Baum mit Wurzel r und Unterbäumen T,..., T k. 5 Wurzel 0 Ferner sei r i die Wurzel des Baumes T i. eine Folge von Knoten v 0, v,..., v k heißt Weg, falls v i+ Nachfolger von v i ist für alle 0 i k, der Weg v 0, v,..., v k hat die Länge k, 3 5 linker Unterbaum 5 von 7 Knoten 8 3 Kanten Tiefe(7)= 7 Tiefe(v, T ) = Länge des Weges von Knoten v zur Wurzel r, Höhe(v, T ) = Länge des längsten Weges von v zu einem Blatt, Höhe(T ) = Höhe (Wurzel, T ). 3 ist Vater von 3 ist Vater von 5 ist linker Sohn von 3 5 ist rechter Sohn von 3 5 5 Blatt 8 3 4 6 / 6 / In der Informatik werden Bäume stets so dargestellt, dass die Wurzel oben und die Blätter unten liegen. Darstellungen von Bäumen verkettete Liste mit variabler Zeigerzahl Wurzel Daten Anzahl der Söhne Pointer zu Sohn Bäume können aufgefasst werden als: spezielle gerichtete Graphen, verallgemeinerte Listen, in denen ein Knoten mehr als einen Nachfolger haben kann. Nachteil: variable Zeigerzahl 63 / 64 /
verkettete Liste mit 3 Datentypen jedes Element der Liste besteht aus 3 Teilen: Beispiel: 0 Indikator Datum Zeiger 0 4 3 4 0 0 0 3 7 5 6 7 Indikator = 0: Datum ist eine zu speichernde Größe Indikator = : Datum ist ein Zeiger auf eine Liste mit Unterbaum 0 5 0 6 wir betrachten überwiegend Bäume mit spezieller Struktur etwa durch Beschränkung der Anzahl der Söhne ( einfachere Speicherung). 65 / 66 / Binäre Bäume Ein Baum, in dem jeder Knoten höchstens Söhne hat, heißt binär. Darstellung binärer Bäume durch Felder Leftson i und Rightson i dazu ggf. Informationen über: Inhalt der Knoten, Väter, # Nachfolger in zusätzlichen Feldern Lemma Ein binärer Baum der Höhe h hat höchstens h+ Knoten und h Blätter. Beweis: (per Induktion): h = 0 : sei T ein Baum der Höhe h 3 4 5 6 R L 4-3 3 - - 4 6 5 5 - - 6 - - T hat höchstens Söhne r und r r, r sind Wurzeln von Unterbäumen der Höhe höchstens h per Induktion haben T und T jeweils höchstens h Knoten und h Blätter damit hat T höchstens ( h ) + = h+ Knoten und ( h ) = h Blätter. 67 / 68 /
Satz Die maximale und die mittlere Tiefe eines Blattes in einem Binärbaum mit k Blättern beträgt mindestens log k. Beweis: haben alle Blätter die Tiefe höchstens t, so hat T höchstens t die maximale Tiefe ist mindestens log k. Beweis des zweiten Teils per Induktion: k = :. sei T ein Baum mit k Blättern Blätter seien T, T die Teilbäume unter der Wurzel mit k bzw. k Blättern per Induktion gilt: mittlere Tiefe(T ) log k, mittlere Tiefe(T ) log k per Induktion gilt: mittlere Tiefe(T ) log k, mittlere Tiefe(T ) log k die Tiefe in T ist um größer als in T bzw. T somit: mittlere Tiefe(T ) = k mittlere Tiefe(T ) + k k k (log k + ) + k k (log k + ) = k (k log k + k log k ) := f (k, k ) + k mittlere Tiefe(T ) + k Die Funktion f (k, k ) nimmt ihr Minimum unter der Bedingung k + k = k im Punkt k = k = k an. Somit: mittlere Tiefe(T ) k ( k log k + k log k ) = log k. 69 / 70 / Definition Ein binärer Baum der Höhe h heißt voll, wenn er h+ Knoten hat. Sequentielle Darstellung Die Knoten des vollen binären Baums werden beginnend in der Wurzel auf jedem Tiefenniveau von links nach rechts durchnumeriert. Definition Ein binärer Baum mit n Knoten heißt vollständig, wenn seine Knoten den ersten n Knoten eines sequentiell dargestellten vollen binären Baumes entsprechen. 3 4 5 6 3 4 5 6 7 7 / 7 /
Lemma Für einen vollständigen binären Baum T mit n Knoten gilt Höhe(T ) = log(n + ). Kompakte Darstellung vollständiger binärer Bäume Vollständige binäre Bäume haben eine kompakte sequentielle Darstellung der Relationen Vater, linker Sohn und rechter Sohn (ohne Zeiger): Beweis (per Induktion): sei h die Höhe von T die Knotenanzahl von T liegt zwischen denen der vollen Bäume der Höhe h und h h < n h+ h < log(n + ) h + h < log(n + ) h + (da h N) h + = log(n + ). Vater (i) = Leftson (i) = Rightson (i) = j i/ : für i > : für i = (Wurzel) j i : für i n : für i > n j i + : für i + n : für i + > n 73 / 74 / j i/ : für i > Vater (i) = : für i = (Wurzel) j i : für i n Leftson (i) = : für i > n j i + : für i + n Rightson (i) = : für i + > n 3 4 5 6 7 diese Numerierung ist eine spezielle Aufzählung der Knoten eines Baums in einigen Anwendungen müssen wir die Knoten eines Baumes systematisch durchsuchen: zum Ausgeben der Einträge zum Aufsummieren der Einträge zur Bildung eines Mittelwerts über die Einträge,... wir wollen somit die Knoten in einer bestimmten Reihenfolge durchlaufen die gebräuchlichsten Reihenfolgen: Präordnung Postordnung symmetrisches Durchmustern (nur für Binärbäume) 75 / 76 /
Sei T ein Baum mit Wurzel r und Söhnen r,..., r k. Präordnung () Durchmustere die Wurzel () Durchmustere in Präordnung nacheinander T,..., T k Postordnung () Durchmustere in Postordnung nacheinander T,..., T k () Durchmustere die Wurzel Eigenschaften der Durchmusterungen Wir identifizieren Knoten mit ihrer Nummer. Präordnung () Durchmustere die Wurzel () Durchmustere in Präordnung nacheinander T,..., T k Sei r die Wurzel des Teilbaums T r. Dann ist v T r r v r + T r. symmetrisches Durchmustern von Binärbäumen () Durchmustere in symmetrischer Ordnung T links (falls er existiert) () Durchmustere die Wurzel (3) Durchmustere in symmetrischer Ordnung T rechts (falls er existiert) Folgerung Ist T r bekannt, so kann in O() Schritten entschieden werden, ob v Nachfolger von r ist. 77 / 78 / Postordnung () Durchmustere in Postordnung nacheinander T,..., T k () Durchmustere die Wurzel Sei r die Wurzel des Teilbaums T r. Dann ist Folgerung v T r r T r + v r. Ist T r bekannt, so kann in O() Schritten entschieden werden, ob v Nachfolger von r ist. symmetrisches Durchmustern von Binärbäumen () Durchmustere in symmetrischer Ordnung T links (falls er existiert) () Durchmustere die Wurzel (3) Durchmustere in symmetrischer Ordnung T rechts (falls er existiert) Die Knoten im linken Teilbaum von r tragen kleinere Nummern als r, die im rechten größere. Folgerung Wir können (auch nach dem Löschen von Knoten) in O(Höhe(T )) entscheiden, ob ein Knoten mit der Nummer p vorkommt. 79 / 80 /
Rekursiver Algorithmus zur symmetrischen Durchmusterung begin count = SymmOrd(Wurzel) end //Hauptprogramm procedure SymmOrd(v) end if (leftson(v) leer) then SymmOrd(leftson(v)) Number(v) = count count = count + if (rightson(v) leer) then SymmOrd(rightson(v)) Nichtrekursiver Algorithmus zur symmetrischen Durchmusterung begin count = v = root Top = 0 left: while (leftson(v) leer) then push (Stack, v) v = leftson(v) end while Center: Number(v) = count count = count + if (rightson(v) leer) then v = rightson(v) goto left end if if (top 0) then Pop(Stack, v) goto center end if end 8 / 8 / Stichwortsuche gegeben: ein Lexikon mit n Stichworten Frage: ist ein gegebener Begriff im Lexikon enthalten? Durch Einfügen und Löschen von Stichworten kann der Suchbaum wie folgt aussehen: a g b Zwei möglich Ansätze: verkettete Listen: O(n) im worst-case binärer Baum als Suchbaum organisiert: Folgerung Wörter im linken Unterbaum sind alphabetisch größer als das Wort in der Wurzel Wörter im rechten Unterbaum sind alphabetisch kleiner als das Wort in der Wurzel Wir können in O(Höhe(T )) entscheiden, ob das gesuchte Wort im Lexikon vorkommt. c d j Wir werden versuchen, diese Situation zu verhindern, und balancierte Bäume verwenden. d b f h j a c e Wir verschieben daher die Laufzeituntersuchungen der Operationen Füge_ein, Entferne, Suche und Zugriff auf Bäumen auf ein späteres Kapitel. i 83 / 84 /