Einfache Datenstrukturen

Transkript

1 Kapitel 2 Einfache Datenstrukturen Bis vor einigen Jahren hat es für das Telefonieren ausgereicht, neben dem Telefon ein Telefonbuch zur Hand zu haben. Das im wesentlichen auftretende Problem, daß man einen Namen und eine grobe Adresse, nicht aber die Telefonnummer des Anzurufenden hatte, konnte damit effizient gelöst werden. Seitdem aber auch Telefonnummern übermittelt und sichtbar gemacht werden, stellt sich bisweilen das Problem, daß man zu einer Telefonnummer den zugehörigen Namen finden möchte. Dazu taugt das Telefonbuch nur wenig. Mit anderen Worten: auf ein und derselben Datenmenge hängt die Effizienz von Operationen, die man auf den Daten ausüben will, sehr stark von der Art und Weise ab, in der die Daten aufbereitet sind bzw. zur Verfügung gestellt werden. Wir werden uns in diesem Kapitel mit einfachen Datenstrukturen befassen. 2. Speichern und Streichen von Daten an festgelegten Stellen In vielen Fällen reicht es aus lediglich zuzulassen, daß eine Datenmenge nur an festgelegten Stellen durch Einfügen neuer Daten bzw. Löschen von vorhandenen Daten verändert werden dürfen. Als Beispiele für diese Datenstrukturen dienen uns Warteschlangen und Tellerstapel. 2.. Stacks (last-in-first-out: LIFO) Die Konzeption des Stacks beinhaltet sie folgenden Eigenschaften: Daten können nur oben eingefügt werden (mit der Operation push). Ein Datum kann nur oben gelesen werden (mit pop). Mit dem Lesen des Datums wird gleichzeitig der oberste Eintrag im Stack gelöscht. Realisierung eines Stacks durch ein Array S : S S 2... S n und Zeiger top auf das oberste Element 8

2 KAPITEL 2. EINFACHE DATENSTRUKTUREN 9 push(s, top, x) top := top S(top) := x pop(s, top, x) x := S(top) top := top + push(s, top, x) liest das Datum x in den Stack S ein. pop(s, top, x) liest das Datum, das im Stack ganz oben liegt, in die Variable x ein und setzt den Zeiger eine Position nach unten. Auf die Stelle im Stack, in der der Inhalt von x stand, kann nun nicht mehr zugegriffen werden: sie ist gelöscht. Bemerkung 2.. Bei der Realisierung ist es notwendig, Abfragen auf leer und auf Überlauf zu implementieren, damit man nicht aus einem leeren Stack liest oder in einen schon vollen Stack Daten einliest. Lesen und Schreiben in Stacks benötigen konstante Zeit (also unabhängig von der jeweiligen Größe). Wir drücken diesen Sachverhalt durch die Notation O() aus. Beispiel 2.2. Wir wollen schnell erkennen, ob in einem Text (etwa einem Programmteil) die Klammerregeln eingehalten werden, d.h. die Anzahl der öffnenden Klammern muß gleich der Anzahl der schließenden Klammern sein und zu keinem Zeitpunkt werden mehr Klammern geschlossen als geöffnet worden sind. Dazu gehen wir den Text linear durch und legen die öffnenden Klammern auf einen Stack. Wenn wir auf eine schließende Klammer treffen, entfernen wir eine Klammer von dem Stack. Der Text hält die Klammerregeln genau dann ein, wenn wir zu jeder schließenden Klammer stets ein Element im Stack finden und der Stack am Ende leer ist Queues (first-in-first-out : FIFO) Queues stellen Datenstrukturen dar, die Daten in Form einer Warteschlange verwalten. Daten werden am Ende eingefügt (mit schreiben) und am Anfang ausgelesen (mit lesen) Typisches Beispiel: Kunden vor Kasse Um eine speichereffiziente Verwaltung der Daten zu ermöglichen, ist einen Realisierung durch ein zirkuläres Feld Q... Q n und Zeigern Anfang (head) und Ende (tail) sinnvoll. Mit diesen legt man die Stelle fest, an der ausgelesen, bzw. eingelesen werden darf. Folgende Situationen können eintreten: Anfang = Ende = Queue leer oder voll Anfang < Ende = Felder der Queue: Q Anfang,..., Q Ende - Anfang > Ende = Felder der Queue: Q Anfang... Q n, Q,..., Q Ende -

3 KAPITEL 2. EINFACHE DATENSTRUKTUREN 20 Q n Q n Q Q 2 Abbildung 2.: Eine Queue als zirkuläre Liste lesen(q, Anf ang, Ende, x) x := Q(Anfang) Anfang := (Anfang + )mod n schreiben(q, Anf ang, Ende, x) Q(Ende) := x Ende := (Ende + )mod n Abfrage auf leer bzw. Überlauf Lesen und Schreiben in Queues und benötigen ebenfalls nur konstante Zeit. Natürlich sind auch Kombinationen von Stacks und Queues denkbar. In den sogenannten Doppelschlangen sind Einfüge- und Löschoperationen sowohl am Ende als auch am Anfng zugelassen. 2.2 Speichern und Streichen von Daten an beliebiger Stelle Die Ablage von Daten in einem Array bringt den Vorteil mit sich, daß wir auf das i- te Datum direkt über ihre Adresse i zugreifen können. Sobald wir aber zulassen, daß Daten nicht nur am Anfang oder Ende eingefügt bzw. entnommen werden dürfen, wird der Aufwand für das Einfügen/Löschen deutlich größer, da die verbleibenden Daten verschoben werden müssen Einfach-verkettete Listen Statt die Daten so in einem zusammenhängenden Speicherbereich abzulegen, daß man den Speicherplatz des i-ten Datums durch eine Adreßberechnung leicht bestimmen kann, speichert man hier ein Datum mit einem Verweis auf das jeweils nächste Datum ab. Die Daten können also beliebig über den Speicher verstreut sein; insbesondere ist es nicht mehr erforderlich, vorab einen Bereich hinreichender Größe zur Aufnahme aller Listenelemente zu reservieren. Der belegte Speicherplatz paßt sich vielmehr dynamisch der jeweiligen aktuellen Größe der Liste an.

4 KAPITEL 2. EINFACHE DATENSTRUKTUREN 2 Realisierung: als Folge von Knoten (Listenelementen) Jeder Knoten enthält eine Datum-Komponente (zur Aufnahme des Datums) und einen Zeiger auf den jeweils nächsten Knoten. Kennzeichnung des Listenendes durch Definition des letzten Zeigers als NIL Kennzeichnung des Listenanfangs durch einen Zeiger auf den ersten Knoten (z.b. Kopf oder Anfang ) Eine einfach verkettete Liste ist gegeben durch den Zeiger auf den ersten Knoten. Eine Liste, die durch einen Zeiger Anfang gegeben ist, nennt man leer, wenn Anfang = NIL. Kopf Datum Next Datum Next Datum Next 2 n 2 n Abbildung 2.2: Einfach-verkettete Liste Doppelt-verkettete Listen Im Vergleich zu einfach-verketteten Listen hat man hier in jedem Knoten noch einen weiteren Zeiger, der auf den jeweils vorhergehenden Knoten weist (zum Rückwärtshangeln ). Dadurch wird das Einfügen und Entfernen von Listenelementen vereinfacht. Listenanfang, bzw. Listenende werden wiederum durch Zeiger Anfang, bzw. Zeiger Ende markiert. Eine doppelt-verkettete Liste ist gegeben durch den Anfangs- und/oder Endezeiger Operationen auf Listen Test auf leere Liste Aufbau einer Liste der Länge n : Füge n Listenelemente in die leere Liste ein. Entfernen von Listenelementen: Gegeben ist ein Zeiger auf das k-te Listenelement. Lösche Element k +, indem der Zeiger des k-ten Listenelements auf das k + 2-te Listenelement verbogen wird. Einfügen von Elementen: Gegeben ist wieder ein Zeiger auf das k-te Listenelement und ein weiterer Zeiger auf das einzufügende Listenelement. Füge es zwischen dem k und k + -ten Listenelement ein, indem der Zeiger des einzufügenden Elements auf das k + -te Element und danach der Zeiger des k-ten Element auf das einzufügende Element verbogen wird.

5 KAPITEL 2. EINFACHE DATENSTRUKTUREN 22 Durchsuchen einer einfach-verketteten Liste: Gesucht wird ein Datum x in der durch den Kopf-Zeiger gegebenen Liste. Gehe die Liste durch, bis ein Knoten mit Datum-Komponente x gefunden wurde und liefere einen Zeiger auf diesen Knoten zurück Eigenschaften verketteter Listen Die Laufzeiten der oben beschriebenen Operationen mit Listen sind: Test auf leer : O() Aufbau einer Liste der Länge n : O(n) Einfügen und Löschen eines Elements mit Zeiger: O() Durchsuchen einer einfach-verketteten Liste: O(n) im worst-case Bemerkung 2.3. Was passiert, wenn wir ein Element direkt vor dem k-ten Element einfügen wollen? Verfahre wie oben und vertausche die Inhalt von Element k und dem neuen Element. Wie sieht es aus, wenn wir das k-te Element löschen wollen? Anwendungsbeispiel für einfach-verkettete Listen Gegeben sei ein azyklischer, gerichteter Graph (Netzplan) mit n Knoten und m Kanten Abbildung 2.3: Beispiel eines gerichteten Graphen Wir stellen die Kanten durch Nachfolgerlisten, in denen zu jedem Knoten sie Liste seiner Nachfolger abgelegt ist. 2.3 Bäume (geordnete Wurzelbäume) Bäume lassen sich rekursiv wie folgt definieren. Ein Baum besteht aus einer endlichen Menge von Knoten, so daß gilt: Es existiert ein ausgezeichneter Knoten r (Wurzel, root) Die restlichen Knoten sind partitioniert in Mengen T,..., T k, die selbst wieder Bäume sind (Unterbäume) r zeigt auf die Wurzeln r,..., r k der Unterbäume

6 KAPITEL 2. EINFACHE DATENSTRUKTUREN NIL Abbildung 2.4: Darstellung über des gerichteten Graphen über Nachfolgerlisten Bemerkung 2.4. In der Informatik werden Bäume stets so dargestellt, daß die Wurzel oben und die Blätter unten liegen. Wurzel Blatt Abbildung 2.5: Veranschaulichung eines Baumes Definition 2.5. Sei T ein Baum mit Wurzel r und Unterbäumen T,..., T k. Ferner sei r i = W urzel(t i ), i =, k a) r i ist i-ter Sohn von r, r ist Vater der r,... r k, b) r j ist Bruder von r i, c) Entsprechend: Nachfolger, Vorgänger, d) Ein Knoten ohne Nachfolger heißt Blatt, e) Knoten von T, die weder Wurzel noch Blatt sind, heißen innere Knoten, f) Tiefe(v, T ) = Länge des Weges (in # Kanten) von Knoten v zur Wurzel r, g) Höhe (v, T ) = Länge des längsten Weges von v zu einem Blatt, h) Höhe (T ) = Höhe (Wurzel, T ) Mögliche Realisierung von Bäumen (a) Verkettete Listen mit variabler Zeigerzahl Nachteil: variable Zeigeranzahl (b) Verkettete Listen mit 3 Datentypen Wir benutzen eine verkettete Liste aus Elementen, die aus drei Datentypen besteht. Ist Indikator = 0, so enthält Datum die zu speichernde Größe, ist Indikator =, so enthält Datum einen Zeiger auf eine Liste mit Unterbaum.

7 KAPITEL 2. EINFACHE DATENSTRUKTUREN 24 Daten Anzahl der Söhne Pointer zu Sohn Abbildung 2.6: Baum als verkette Liste mit variabler Zeigerzahl Indikator Datum Zeiger Abbildung 2.7: verkettete Liste mit 3 Datentypen Abbildung 2.8: Darstellung als verkettete Liste mit 3 Einträgen

8 KAPITEL 2. EINFACHE DATENSTRUKTUREN 25 Wir werden jedoch überwiegend Bäume mit spezieller Struktur betrachten (etwa indem wir die Anzahl der Söhne beschränken), für die die Speicherung kanonisch sein wird. Definition 2.6. Ein Baum T heißt binär, falls jeder Knoten höchstens 2 Söhne hat. Binäre Bäume können z.b. durch 2 Felder Leftson i und Rightson i dargestellt werden. Dazu ggf. Informationen über: Inhalt der Knoten, Väter, # Nachfolger in zusätzlichen Feldern, z.b. R L Lemma 2.7. Ein binärer Baum der Höhe h hat höchstens 2 h+ Knoten und 2 h Blätter. Beweis: Induktion über h. Die Aussage ist richtig für h = 0. Sei nun T ein Baum der Höhe h. Dann hat die Wurzel höchstens zwei Söhne r und r 2, die Wurzeln von Unterbäumen T und T 2 sind. T und T 2 haben eine Höhe von höchstens h. Per Induktion haben dann T und T 2 jeweils höchstens 2 h Knoten und 2 h Blätter. Damit hat T höchstens 2 (2 h ) + = 2 h+ Knoten und 2 h Blätter. Definition 2.8. Ein binärer Baum T der Höhe h heißt voll, wenn er 2 h+ Knoten hat. Wir werden gelegentlich die Knoten eines vollen binären Baums sequentiell darstellen, indem wir beginnend mit der Wurzel alle Knoten auf einem Tiefenniveau von links nach rechts durchnumerieren Abbildung 2.9: Ein voller Baum mit 7 Knoten Definition 2.9. Ein binärer Baum T mit n Knoten heißt vollständig, wenn seine Knoten den ersten n Knoten eines sequentiell dargestellten vollen binären Baums entsprechen.

9 KAPITEL 2. EINFACHE DATENSTRUKTUREN Abbildung 2.0: Ein vollständiger Baum mit 6 Knoten Lemma 2.0. Sei T ein vollständiger und binärer Baum mit T = n. Dann gilt: Höhe (T ) = log(n + ). Beweis: Sei h die Höhe von T. Die Anzahl n der Knoten von T liegt zwischen der Knotenzahl der vollen Bäume mit den Höhen h und h. Somit: 2 h < n 2 h+ h < log(n + ) h +. Da h N, folgt h < log(n + ) h + und somit h log(n + ) h. Vollständige binäre Bäume haben eine kompakte sequentielle Darstellung der Relationen Vater, linker Sohn und rechter Sohn (ohne Zeiger): Vater (i) = Leftson (i) = Rightson (i) = { i/2 : für i > : für i = (Wurzel) { 2i : für 2i n : für 2i > n { 2i + : für 2i + n : für 2i + > n Durchmusterung von Bäumen Oft müssen die Knoten eines Baumes systematisch durchsucht werden, etwa um die in den Knoten enthaltenen Einträge auszugeben, sie aufzusummieren oder sie zu mitteln. Das bedeutet, daß wir die Knoten in einer bestimmten Reihenfolge durchlaufen wollen. Die drei gebräuchlichsten Reihenfolgen, in denen sämtliche Knoten eines Baumes durchlaufen werden, sind die Präordnung, die Postordnung und die symmetrische Durchmusterung, wobei die leetztere nur für Binärbäume definiert ist. Diese Reihenfolgen lassen sich über rekursive (d.h. sich selbst aufrufende) Algorithmen definieren: Sei T ein Baum mit Wurzel r und Söhnen r,..., r k Präordnung () Durchmustere die Wurzel (2) Durchmustere in Präordnung nacheinander T,..., T k

10 KAPITEL 2. EINFACHE DATENSTRUKTUREN Postordnung () Durchmustere in Postordnung nacheinander die T,..., T k (2) Durchmustere die Wurzel Symmetrische Durchmusterung von binären Bäumen () Durchmustere den linken Teilbaum der Wurzel (falls ex.) (2) Durchmustere die Wurzel (3) Durchmustere den rechten Teilbaum (falls ex.) jeweils in symmetrischer Ordnung. Nach dem Durchsuchen identifizieren wir die Knoten mit ihrer Numerierung Präordnung Postordnung symmetr. Ordnung Abbildung 2.: Ergebnisse der Durchmusterungen eines Baumes Eigenschaften der Durchmusterungen Formal korrekt müssten wir zwischen einem Knoten v und seiner Nummer N um(v) unterscheiden. Da wir aber Knoten mit ihrer durch die Durchmusterung vergebenen Numerierung identifizieren, stehen im folgenden (etwas verwirrend, aber kurz und daher gebräuchlich) v oder r sowohl für Knoten als auch für natürliche Zahlen v, r N. Präordnung: r + T r. Sei r Wurzel des Teilbaums T r. Dann gilt v T r r v Folgerung 2.. Ist T r bekannt, so kann in O() Schritten entschieden werden, ob v Nachfolger von r ist. Postordnung: Sei r Wurzel des Teilbaums T r. Dann gilt v T r r T r + v r. Damit gilt die Folgerung 2. für die Postordnung analog.

11 KAPITEL 2. EINFACHE DATENSTRUKTUREN 28 Symmetrische Ordnung: Die Knoten im linken Teilbaum von r tragen kleinere Nummern als r, die im rechten größere. Folgerung 2.2. Wir können u.a. in O(Höhe(T)) entscheiden, ob ein Knoten mit der Nummer p vorkommt. (Vgl. Suchbäume) Zur Veranschaulichung rekursiver Algorithmen und ihrer nichtrekursiven Varianten formulieren wir einen Algorithmus zur symmetrischen Durchmusterung in der Pseudo-Programmiersprache Algorithmus zur symmetrische Durchmusterung () begin { Hauptprogramm } (2) count := (3) SymmOrd(Wurzel) (4) end (5) procedure SymmOrd(v) (6) if Leftson (v) then SymmOrd(Leftson(v)) (7) Number (v) := count (8) count := count + (9) if Rightson (v) then SymmOrd(Rightson(v)) (0) end Rekursive Algorithmen werden üblicherweise mit Hilfe von Stacks realisiert. Jedem Aufruf wird ein Block des Kellers zugewiesen, der die Informationen enthält: ) Werte der aktuellen Parameter 2) Rücksprungadresse 3) lokale Variablen Nichtrekursive Version der symmetrischen Durchmusterung () begin (2) count := (3) v := root (4) top := 0 (5) left: while leftson (v) then (6) push (Stack, top, v) (7) v := leftson (v) (8) endwhile (9) Center: Number (v) := count (0) count := count + () if rightson (v) then (2) v := rightson (v)

12 KAPITEL 2. EINFACHE DATENSTRUKTUREN 29 (3) goto left (4) endif (7) if top 0 then (6) Pop (Stack, top, v) (7) goto center (8) endif (9) end Diskurs: Prozeduren und Rekursionen Das obige Besipiel illustriert, daß rekursive Formulierungen von Algorithmen häufig einfacher zu verstehen sind. Hinzu kommt, daß auch Aussagen über Eigenschaften wie Korrektheit und Laufzeitverhalten bei einer rekursiven Formulierung leichter zu zeigen sind als bei nichtrekursiven Ansätzen. Am obigen Beispiel haben wir auch gesehen, wie wir Prozeduren und rekursive Aufrufe mit Hilfe von Stacks in ein sequentielles Programm überführen können. Da zur Verwaltung eines Prozeduraufrufs im wesentlichen nur die Parameter und die lokalen Variablen im Stack abgelegt werden müssen, können wir annehmen, daß der Verwaltungsaufwand nicht größer ist als der Aufwand für die Ausführung der Prozedur selbst (da die Parameter und lokalen Variablen mindestens einmal benutzt werden müssten). Formal werden wir den Aufwand für die Ausführung der Rekursion und ihrer Verwaltung dem Prozeduraufruf anschreiben. Im weiteren Verlauf der Vorlesung werden wir sehen, wie wir mit diesem Ansatz die Laufzeiten rekursiver Programme abschätzen Eine Anwendung von binären Bäumen: Stichwortsuche Gegeben ein Lexikon mit n Stichworten. Frage: Ist ein gegebener Begriff im Lexikon enthalten? Zur Beantwortung sind zwei verschiedene Ansätze denkbar:. Man könnte eine verkettete Liste benutzen, in der die Stichwörter alphabetisch sortiert sind. jede Abfrage O(n) im worst-case. 2. Verwende binären Baum, der als Suchbaum organisiert ist: ein Stichwort, das in einem Knoten v abgespeichert ist, ist alphabetisch größer als alle Wörter im linken Unterbaum alphabetisch kleiner als alle Wörter im rechten Unterbaum Vorteil: Für den Fall, daß das gesuchte Stichwort nicht im Wurzelknoten steht, weiß man bei Suchbäumen immer, in welchem Teilbaum man weitersuchen muß und erspart sich damit jeweils das Durchsuchen eines gesamten Teilbaums. Im Extremfall erhält man hier wieder eine lineare Liste. Extremfall: lineare Liste mit Suchzeit O(n) Dies kann verhindert werden durch die Verwendung von sogenannten balancierten Bäumen. Ohne an dieser Stelle auf eine formale Definition einzugehen, werden wir versuchen zu erreichen, daß in jedem Knoten der linke und rechte Teilbaum etwa gleiche Größe hat. Dies führt zu einer Suchzeit von O(log n).

13 KAPITEL 2. EINFACHE DATENSTRUKTUREN 30 a b c d j Abbildung 2.2: Suchbaum als lineare Liste g d i b f h j a c e Abbildung 2.3: balancierter Suchbaum

14 KAPITEL 2. EINFACHE DATENSTRUKTUREN Heaps Es seien Daten gegeben, auf denen eine lineare Ordnung gegeben ist (Wörter eines Alphabets, natürliche Zahlen usw.). Wir suchen eine Datenstruktur, die es erlaubt, effizient neue Daten einzufügen und das jeweilige Maximum zu bestimmen. Für das Sortierproblem, das im nächsten Kapitel behandelt werden wird, sollte auch das Löschen des jeweiligen Maximums effizient möglich sein. Implementierung als Einfügen Maximum bestimmen Stack oder Queue O() O(n) sortierte verkettete Liste O(n) O() Definition 2.3. Ein (Max-) Heap ist ein vollständiger binärer Baum, in dem für jeden Knoten gilt, daß der in ihm abgelegte Wert mindestens so groß ist, wie die in seinen Söhnen abgelegten Werte. Ein Min-Heap wird analog definiert. Wir benutzen eine sequentielle Darstellung als Feld: Daten(),..., Daten(n). Dabei geht die Struktur des Baumes nicht verloren (kompakte sequentielle Darstellung der Relationen Vater, Söhne, s. Kapitel 2.3) Einfügen eines neuen Datums in einen Heap Idee: Füge einen neuen Knoten zum Heap hinzu, so daß wieder ein vollständiger binärer Baum entsteht (also Blatt einfügen) und speichere das neue Datum in diesem Knoten Dieser Baum ist i.a. kein Heap mehr. Wende die Prozedur insert an, um wieder einen Heap zu erhalten: procedure insert (Daten,n) { n ist die Größe des binären Baums Daten nach Einfügen } j := n i := n 2 item := Daten(n) while i > 0 und Daten(i) < item Daten(j) := Daten(i) { Sohn übernimmt Daten vom Vater } j := i { gehe zum Vater } i := i 2 {betrachte dessen Vater } enddwhile { j ist die Stelle, an die das neue Datum paßt } Daten(j) := item end Lemma 2.4. (i) Das Einfügen eines Datums in einen Heap der Größe n benötigt O(log n) Schritte.

15 KAPITEL 2. EINFACHE DATENSTRUKTUREN 32 (ii) Der Aufbau eines Heaps mit n Elementen benötigt O(n log n) Schritte (iii) Das Maximum in einem Heap kann in O() Schritten gefunden werden. Beweis: (i) Das neue Element wandert höchstens Höhe (T ) = log(n+) = O(log n) Positionen nach oben mit O() Operationen pro Austausch. (ii) Wir verwenden die Prozedur Insert, um die Knoten nacheinander in einen anfänglich leeren Heap einzufügen. Da jede einzelne Einfüge-Operation höchstens O(log n) Schritte benötigt, folgt die Behauptung. (iii) klar, da das Maximum in der Wurzel abgelegt ist. Bemerkung 2.5. Die Eingabe in der Reihenfolge, 2, 3,..., n zeigt, daß die Laufzeit dieses Verfahrens auch Θ(n log n) beträgt. Dieses Laufzeitverhalten läßt sich dadurch erklären, daß in einem vollständigen binären Baum fast alle Knoten tief unten im Baum liegen. So sind bereits die Hälfte aller Knoten Blätter: Lemma 2.6. Ein vollständiger binärer Baum mit n Knoten hat n 2 Blätter. Beweis: Per Induktion: ein vollständiger binärer Baum besteht aus einer Wurzel, einigen Tiefenniveaus mit jeweils gerader Anzahl von Knoten und den restlichen Blättern. Ist somit n gerade, so hat er eine ungerade Anzahl von Blättern auf dem untersten Niveau. Damit gibt es genau einen inneren Knoten v, der nur einen linken und keinen rechten Knoten hat. Fügen wir einen neuen Knoten hinzu, so wird er rechter Sohn von v. Dann hat sich die Anzahl der Blätter erhöht und es ist auch n+ 2 = n +. Ist n ungerade, so wird ein neues linkes Blatt an einen Knoten 2 angefügt, der vorher selbst ein Blatt war und nun innerer Knoten wird. Damit bleibt die Anzahl der Bläter konstant und es gilt n+ 2 = n Reparieren in einem Heap Gegeben sei ein vollständiger binärer Baum mit n Knoten {k,, k n } in sequentieller Darstellung. Weiter sei k i ein Knoten mit der Eigenschaft, daß die Teilbäume unter seinen Söhnen bereits Heaps sind. Erzeuge daraus einen vollständigen binären Baum mit der Eigenschaft, daß der Teilbaum unter k i einen Heap bildet. Algorithmus: { versickere k i im Bereich k i bis k n } Solange k i einen linken Sohn k j hat, wiederhole: falls k i einen rechten Sohn hat, so sei k j der größere Sohn von k i ; falls k i < k j, so vertausche k i mit k j und setze i:=j, sonst halte an { Teilbaum ist schon Heap }.

16 KAPITEL 2. EINFACHE DATENSTRUKTUREN 33 Lemma 2.7. Das Reparieren eines Heaps an der Stelle i benötigt O(Höhe(i)) Schritte Löschen des Maximums in einem Heap Idee: Lösche den Wert des (Wurzel-) Knotens (das Maximum) Knoten ist jetzt überflüssig Speichere den Inhalt des Knotens n im Knoten. Lösche Knoten n. Repariere den Baum an der Stelle. Lemma 2.8. Das Löschen des Maximums in einem Heap benötigt O(log n) Schritte Aufbau eines Heaps in linearer Zeit Das obige Verfahren des iterativen Einfügens in einen anfangs leeren Heap benötigt O(n log n) Schritte. Die Tatsache, daß die meisten Knoten tief unten im Baum liegen, machen wir uns bei der folgenden Vorgehensweise zu Nutze. Sie erlaubt den Aufbau eines Heaps in linearer Zeit. Idee: Speichere in einem ersten Schritt die Daten in einem vollständigen binären Baum Die Teilbäume unter den Blättern sind bereits Heaps. Beginnend mit dem rechtesten inneren Knoten rückwärts bis zur Wurzel, repariere den Baum an der jeweiligen Stelle. Lemma 2.9. Der Aufbau eines Heaps mit n Elementen benötigt O(n) Schritte. Beweis: (i) Da wir den binären Baum rückwärts gehend reparieren, ist er am Schluß Heap-geordnet. (ii) Sei 2 h < n 2 h+ mit h = Höhe(T ). Für k = 0,..., h ist die Anzahl der Knoten der Höhe k höchstens 2 h k. Repariert wird an allen inneren Knoten i mit Höhe(i). Nach Lemma 2.7 beträgt die Laufzeit jeweils O(Höhe(i)). Somit beträgt die Gesamtlaufzeit höchstens (s. Lemma A.):

17 KAPITEL 2. EINFACHE DATENSTRUKTUREN 34 h 2 h k k = 2 h k=0 n n n h k=0 h k=0 h k=0 k=0 k 2 k k 2 k ( 3 4 )k ( 3 4 )k = n ( 3) 4 = O(n). Somit hat man mit Heaps eine effiziente Datenstruktur gefunden, mit der im Vergleich zum Stack oder zur sortierten Liste die Laufzeiten für die Prozeduren Einfügen, Maximum bestimmen kleiner sind und für die Prozedur Aufbau gleich bleiben.