Informatik I 2. Kapitel

Elementare Datenstrukturen Rainer Schrader Zentrum für Angewandte Informatik Köln

28. Mai 2008

1/1

2/1

Datenstrukturen

Datenstrukturen • bisher haben wir nur Arrays verwendet, • effiziente Algorithmen brauchen geeignete Datenstruktur

Gliederung

• Einführung • abstrakte Datentypen

• Beispiel: Suche im Telefonbuch • gegeben: Name • gesucht: Telefonnummer

• Listen • Stacks und queues • Anwendungsbeispiele • Bäume

•

; einfach

• gegeben: Telefonnummer • gesucht: Name •

3/1

; praktisch unmöglich

4/1

Datenstrukturen

Datenstrukturen • offensichtlich ist das Problem in der Zeit Θ(n) lösbar, • aber es geht besser, wenn man viele Anfragen zu einem festen M hat

Nichttriviales Beispiel: Posamp-Problem

• gegeben:

Informelle Beschreibung einer geeigneten Datenstruktur

• n Orte (Postämter) M = {p1 , p2 , . . . , pn } • ihre kartesischen Koordinaten pi = (xi , yi )

• sei VR(pj ) die Menge aller Punkte der Ebene, die näher an pj als an

• zusätzlicher Ort p0 = (x0 , y0 )

• also

jedem anderen Punkt in M liegen, n o VR(pj ) = q ∈ R2 | d (q, pj ) ≤ d (q, pi ) ∀i ∈ {1, 2, . . . n} .

• gesucht: • das zu p0 nächstgelegene Postamt pk , d.h. • d (p0 , pk ) ≤ d (p0 , pi ) für alle i ∈ {1, . . . , n} mit p • d (pi , pj ) = (xi − xj )2 + (yi − yj )2 (Euklidische Distanz)

• VR(pj ) ist die Voronoi-Region von pj • das Voronoi-Diagramm ist die Menge VD(M ) = {VR(pj ) | j ∈ {1, 2, . . . , n}}

5/1

6/1

Datenstrukturen

Datenstrukturen

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 p0 : bestimme VR(pk ) mit p0 ∈ VR(pk ). man kann zeigen: (evtl. Kapitel 10)

• (AD) benötigt O(n log n) Zeit. • (BA) benötigt O(log n) Zeit.

7/1

8/1

Datenstrukturen

Datenstrukturen

• Datenstrukturen sollen Operationen auf Objekten unterstützen • evtl. verschiedene Datenstrukturen für verschiedene Operationen

Gliederung

• Einführung • abstrakte Datentypen

• evtl. Verknüpfung von Objekten und Operationen (Klassen)

• Listen • Stacks und queues • Anwendungsbeispiele • Bäume

Abstrakter Datentyp (ADT) besteht aus

• einer oder mehreren Mengen von Objekten • und darauf definierten Operationen

10 / 1

9/1

Datenstrukturen

Datenstrukturen

Beispiel Postamtproblem :

Beispiel: Formulierung eines Algorithmus mit Hilfe von ADT

• Objekte:

Aufgabe:

• endliche Mengen M von Punkten in der Ebene

• gegeben eine endliche Menge M von Punkten in der Ebene • finde ein Paar p0 , q0 von Punkten mit minimalem Abstand d (p0 , q0 )

• ein Punkt p0 in der Ebene

• Operation

ADT:

• „nächster Nachbar“: ordne dem Punkt p0 einen nächstgelegen Punkt aus M zu

• Objekt: endliche Punktmenge M • Operationen:

• Mögliche zusätzliche Operationen: • füge einen Punkt zu M hinzu

• nächster Nachbar • Distanz zweier Punkte

• entferne einen Punkt aus M

• Kardinalität von M • M := M r {p}

Wir haben jedesmal einen anderen ADT.

11 / 1

12 / 1

Datenstrukturen

Datenstrukturen

Algorithmus nearest_neighbours(M) liefert p0 , q0 ∈ M mit minimaler Distanz d (p0 , q0 ) falls M = ∅ oder |M | = 1, so sind p0 und q0 nicht definiert Implementierung (Realisierung als Computerprogramm)

falls |M | ≥ 2:

• wähle zwei Punkte p0 , q0 ∈ M • berechne die Distanz dist := d (p0 , q0 )

• Auswahl von Datenstrukturen für die Objektmengen • Auswahl von Algorithmen für die Operationen

• for all p ∈ M do • bestimme einen nächsten Nachbarn q ∈ M r {p} • berechne die Distanz d (p, q) • falls d (p, q) < dist, so setze: • p0 := p; q0 := q; dist := d (p, q).

• end do 14 / 1

13 / 1

Datenstrukturen

Datenstrukturen Lineare Liste

• Objekte:

Gliederung

• Menge aller endlichen Folgen eines gegebenen Grundtyps • die Schreibweise für eine lineare Liste ist

• Einführung • abstrakte Datentypen

L = ha1 , a2 , . . . , an i,

• Listen • Stacks und queues • Anwendungsbeispiele • Bäume

• hierbei ist L = hi die „leere Liste“

• verschiedene Operationen • im Folgenden ist L eine lineare Liste, x vom Grundtyp und p eine Position

15 / 1

16 / 1

Datenstrukturen

Datenstrukturen

Füge_ein(x,p,L) Entferne(p,L)

• falls L = ha1 , a2 , . . . , ap−1 , ap , ap+1 , . . . , an i 6= hi : L → ha1 , a2 , . . . , ap−1 , x , ap , ap+1 , . . . , an i L → hx , a1 , a2 , . . . , an i L → ha1 , a2 , . . . , an , x i

für L 6= hi und 1 ≤ p ≤ n gilt: für 1 < p ≤ n

• aus ha1 , a2 , . . . , ap−1 , ap , ap+1 , . . . an i

für p = 1 wird

für p = n + 1

ha1 , a2 , . . . , ap−1 , ap+1 , . . . an i.

• falls L = hi und p = 1:

hi → hx i

• undefiniert sonst

• undefiniert sonst

18 / 1

17 / 1

Datenstrukturen

Datenstrukturen

Suche(x,L) Verkette(L,L1,L2)

• liefert eine Position p in L = ha1 , a2 , . . . , an i mit ap = x , falls diese existiert,

• liefert für

• sonst 0.

L1 = ha1 , a2 , . . . , an1 i und L2 = hb1 , b2 , . . . , bn2 i die Liste

Zugriff(p,L)

L = ha1 , a2 , . . . , an1 , b1 , b2 , . . . , bn2 i.

• liefert ap in L = ha1 , a2 , . . . , an i, falls 1 ≤ p ≤ n, • sonst undefiniert.

19 / 1

20 / 1

Datenstrukturen

Datenstrukturen

Gliederung

• Einführung • abstrakte Datentypen

Darstellungen linearer Listen

• sequentielle Darstellung

• Listen

• zusammenhängende Speicherung als Feld mit direktem Zugriff

• sequentielle Listen • verkettete Listen

• verkettete Listen

• Stacks und queues • Anwendungsbeispiele

• verteilte Speicherung, durch Zeiger verknüpft

• Bäume

21 / 1

22 / 1

Datenstrukturen

Datenstrukturen Füge_ein(x,p,L)

Sequentielle Listen \\ fügt x als neues Element an Stelle p ein, falls p zulässig, gibt andernfalls Fehlermeldung aus

Eine sequentiell gespeicherte Liste L besteht aus:

• einer (hinreichend großen) Konstanten maxelzahl • einem Feld element[0, . . . , maxelzahl]

if (L.elzahl = L.maxelzahl or p < 1 or p > L.elzahl + 1) print ”Fehler” else for i = L.elzahl down to p do L.element(i+1) = L.element(i) end do L.element(p) = x L.elzahl = L.elzahl+1 end if

• der aktuellen Listengröße elzahl Ist 0 < L.elzahl ≤ L.maxelzahl, so ist in L.element(1), . . . , L.element(elzahl) die aktuelle Liste abgelegt.

23 / 1

24 / 1

Datenstrukturen

Datenstrukturen

Entferne(p,L)

Suche(x,L)

\\ entfernt das p. Element, falls p zulässig, gibt andernfalls Fehlermeldung aus

\\ liefert die höchste Position, an der x in L vorkommt, 0 sonst

if (L.elzahl = 0 or p < 1 or p > L.elzahl) print ”Fehler” else L.elzahl = L.elzahl - 1 for i = p to L.elzahl do L.element(i) = L.element(i+1) end do end if

L.element(0) = x i = L.elzahl while (L.element(i) 6= x) do i = i-1 end while return i

26 / 1

25 / 1

Datenstrukturen

Datenstrukturen

Zugriff(p,L)

Verkette(L,L1,L2)

\\ gibt das p. Element aus, falls p zulässig, gibt andernfalls Fehlermeldung aus

\\ hänge L2 an L1 an, falls L1 ausreichend lang if (L1.elzahl + L2.elzahl > L1.maxelzahl) print ”Fehler” else if (L2.elzahl > 0) then do for i = 1 to L2.elzahl do L1.element(L1.elzahl + i) = L2.element(i) end do end if L1.elzahl = L1.elzahl + L2.elzahl end if

if (p < 1 or p > L.elzahl) print ”Fehler” else return L.element(p) end if

27 / 1

28 / 1

Datenstrukturen

Datenstrukturen

Gliederung

Laufzeiten

• Einführung • abstrakte Datentypen

Sei n die Länge der Liste Operation suche füge_ein entferne Zugriff verkette

Zeit

• Listen

O(n) O(n) O(n) O(1) O(n2 )

• sequentielle Listen • verkettete Listen

• Stacks und queues • Anwendungsbeispiele • Bäume

29 / 1

30 / 1

Datenstrukturen

Datenstrukturen

eine mögliche Implementation von verketteten Listen

eine Liste L = ha1 , a2 , . . . , an i lässt sich wie folgt darstellen:

• eine verkettete Liste wird „kreuz und quer“ im Speicher abgelegt a1

• eine Liste ist gegeben als eine Folge von Knoten • jeder Knoten besteht aus

a2

...

an

DUMMY-Elemente

head

tail

(a) einem Listenelement dat (b) einem Zeiger next auf das nächste Listenelement

• zwei Dummy-Elemente als „Kopf“ und „Schwanz“ der Liste

eine leere Liste sieht dann wie folgt aus:

• einem Zeiger head auf das Kopfelement • einem Zeiger tail auf das Schwanzelement • der Zeiger des Schwanzelements zeigt auf das vorangehende Element

head

31 / 1

tail

32 / 1

Datenstrukturen

Datenstrukturen Füge_ein(x,p,L)

Vereinbarung:

• Zeiger von x := Zeiger von Element p − 1 • Zeiger von Element p − 1 := Zeiger auf x

Die Position p ist gegeben durch einen Zeiger auf den Knoten, dessen Zeiger auf das p.te Listenelement zeigt:

Skizze für Füge_ein: ap

vorher:

ap−1

ap

p

p nachher:

ap−1

ap

Die Listenoperationen lassen sich wie folgt durchführen: x

Wir überprüfen hier nicht, ob p ein legaler Zeiger ist. 33 / 1

34 / 1

Datenstrukturen

Datenstrukturen

Entferne(p,L)

• Zeiger von p − 1 := 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. Suche(x,L)

Skizze für Entferne(p,L):

vorher:

ap−1

ap

• kopiere x in das Datumsfeld des Schwanzes • beginnend mit dem Kopfelement suche nach x

ap+1

• wird x in einem Element p gefunden: p nachher:

ap−1

• ist p nicht das Schwanzelement: gib Zeiger auf p zurück • andernfalls gib Null zurück

ap+1

Wir überprüfen hier nicht, ob p ein legaler Zeiger ist.

35 / 1

36 / 1

Datenstrukturen

Datenstrukturen Doppelte Verkettung

Verkette(L,L1,L2)

• tail1 zeigt auf das Schwanzelement von L1 • der Zeiger dieses Schwanzelements zeigt auf das letzte Element von L1 • biege dessen Zeiger auf den Zeiger des Kopfelements von L2 um • entferne das Schwanzelement von L1 und das Kopfelement von L2

• 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 ap definieren

Skizze für Verkette: head1 head

ap−1

...

ap

ap+1

p

tail1

Beispiel für Entferne: tail

... head2

ap−1

ap+1

tail2 37 / 1

38 / 1

Datenstrukturen

Datenstrukturen

Zusammenfassung: Gliederung Operation suche füge_ein entferne Zugriff verkette

sequentiell Θ(n) Θ(n) Θ(n) Θ(1) Θ(n2 )

verkettet Θ(n) Θ(1) Θ(1) Θ(1) Θ(1)

• Einführung • abstrakte Datentypen • Listen • Stacks und queues • Anwendungsbeispiele • Bäume

39 / 1

40 / 1

Datenstrukturen

Datenstrukturen

Stapel

Schlange

• ist eine spezielle Liste • Einfügen und Entfernen nur am Anfang der Liste erlaubt

• ist eine spezielle Liste • Einfügen nur am Ende, Entfernen nur am Anfang der Liste

• „LIFO“: last-in-first-out

• „FIFO“: first-in-first-out

• Operationen:

• Operationen:

• empty(L): teste, ob L leer ist • pop(L,x): setze x := a1 ; entferne a1

• enqueue(L,x): füge x am Ende von L ein • dequeue(L,x): setze x = a1 , entferne a1 aus L • empty(L): teste, ob L leer ist

• top(L,x): setze x := a1 (ohne zu entfernen)

• top(L,x): setze x := a1 (ohne zu entfernen)

• push(L,x): füge x am Anfang von L ein

42 / 1

41 / 1

Datenstrukturen

Datenstrukturen

• alle Stapel-, Schlangen- und Doppelschlangen-Operationen können mit konstanter Laufzeit implementieren werden

Doppelschlangen

• sowohl sequentiell als auch verkettet

• beide push- und pop-Operationen sowie • empty(L), top(L,x), bottom(L,x)

• Anwendung als Warteschlangen und Vorrangwarteschlangen • sequentiell implementierte Schlangen sollten „zyklisch“ verwaltet werden

43 / 1

44 / 1

Datenstrukturen

Datenstrukturen

Skizzen für sequentielle Speicherung Stapel

(Doppel−)Schlange

maxn frei

1111 0000 0000 1111 Stapel

1111 0000 0000 1111 0000 1111 0000 1111

1111111111111111111 0000000000000000000 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 Anfang 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 maxn 1111111111111111111 frei 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 0 1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 00000000000000000001 Ende1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111 0000000000000000000 1111111111111111111

Gliederung

• Einführung • abstrakte Datentypen • Listen • Stacks und queues • Anwendungsbeispiele • Bäume

45 / 1

Datenstrukturen

46 / 1

Datenstrukturen

Definition eines wohlgeformten Klammerausdrucks Anwendung eines Stapels: wohlgeformte Klammerausdrücke (1) () ist ein wohlgeformter Klammerausdruck

• Test, ob Klammerfolgen wohlgeformt sind • Beispiel:

(()())

• Beispiel:

((())(

(2) sind w1 und w2 wohlgeformte Klammerausdrücke, so ist auch w1 w2 ein wohlgeformter Klammerausdruck

√

(3) mit w ist auch (w ) ein wohlgeformter Klammerausdruck



(4) nur die nach (1) bis (3) gebildeten Zeichenketten sind wohlgeformte Klammerausdrücke

47 / 1

48 / 1

Datenstrukturen

Datenstrukturen

Anwendung eines Stapels: Test von Klammerausdrücken

Anwendung von Listen: Datenstruktur für Projektplanungen

• durchsuche Zeichenkette von links nach rechts

gegeben: n Teilprojekte eines Projekts (Bauprojekt, Kfz-Fertigung, …) mit

• Zeitangaben über die Dauer der Teilprojekte • Reihenfolgebedingungen zwischen einzelnen Teilprojekten

• wird „(“ gefunden: lege sie auf Stapel • wird „)“ gefunden:

bestimme:

• ist Stapel leer ; nicht wohlgeformt

• Gesamtdauer • Pufferzeiten

• andernfalls entferne obere Klammer vom Stapel

• am Ende:

• kritische Pfade • …

• ist Stapel nicht leer ; nicht wohlgeformt • andernfalls ; wohlgeformt

49 / 1

50 / 1

Datenstrukturen

Datenstrukturen 12

Beispiel mit 4 Teilprojekten

• TP1 : Dauer: 12 • TP2 : Dauer: 6, muss warten auf Beendigung von TP1 , TP3 • TP3 : Dauer: 9, muss warten auf Beendigung von TP1 • TP4 : Dauer: 7, muss warten auf Beendigung von TP2 , TP3

6 1

2

3

4

9

7

Darstellung mit verketteten Listen 12

6 1

3 9

2

4

1

2

2

4

3

2

4

NIL

3

4

7

51 / 1

52 / 1

Datenstrukturen

Datenstrukturen

gerichteter Graph G = (V , E )

(ungerichteter) Graph G = (V , E )

besteht aus:

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

• 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

• u Startknoten, v Endknoten von e • wir identifizieren e und das Knotenpaar, d.h. e = (u, v )

• wir identifizieren e und das Knotenpaar, d.h. e = {u, v }

• Veranschaulichung wie vorher:

• Veranschaulichung:

• Knoten als Kreise

• Knoten als Kreise

• Kanten als „Pfeile“

• Kanten als Verbindungen, Strecken, …

• Darstellung z.B. durch „Adjazenzlisten“

• Darstellung z.B. durch „Adjazenzlisten“

53 / 1

54 / 1

Datenstrukturen 1

2

3

4

Datenstrukturen

Gliederung

• Einführung • abstrakte Datentypen

Darstellung mit verketteten Listen

1

2

3

2

1

3

4

3

1

2

4

4

2

3

• Listen • Stacks und queues • Anwendungsbeispiele • Bäume

55 / 1

56 / 1

Datenstrukturen

Datenstrukturen

Bäume

• wir werden im Laufe der Vorlesung immer wieder auf

bestehen aus:

graphentheoretische Modelle und Fragestellungen stoßen

• einer endlichen Menge V von Knoten • ein Knoten ist als Wurzel ausgezeichnet • jeder Knoten hat eine endliche Menge von direkten

• insbesondere kann die nächste Datenstruktur als gerichteter Graph aufgefasst werden

Nachfolgern (Söhnen)

• sie stellt ebenso eine Verallgemeinerung von Listen dar

• die Wurzel hat keinen direkten Vorgänger (Vater) • jeder andere Knoten hat genau einen direkten Vorgänger

57 / 1

58 / 1

Datenstrukturen

Datenstrukturen

Sprechweisen Bäume (rekursive Definition)

Sei T ein Baum mit Wurzel r und Unterbäumen T1 , . . . , Tk . Ferner sei ri die Wurzel des Baumes Ti .

bestehen aus einer endlichen Menge V von Knoten, so dass gilt:

• es gibt einen ausgezeichneten Knoten r (Wurzel) • die restlichen Knoten sind partitioniert in Teilmengen T1 , . . . , Tk , die

• ri ist i-ter Sohn von r , r ist Vater der r1 , . . . rk , • rj ist Bruder von ri , • u ist Nachfolger von ri , falls u im Unterbaum Ti liegt, • ein Knoten ohne Nachfolger heißt Blatt,

selbst wieder Bäume sind

• r zeigt auf die Wurzeln der Teilbäume r1 , . . . , rk

• Knoten von T , die nicht Blatt sind, heißen innere Knoten,

59 / 1

60 / 1

Datenstrukturen

Datenstrukturen Bezeichnungen

Sprechweisen

T1 5

Sei T ein Baum mit Wurzel r und Unterbäumen T1 , . . . , Tk .

Wurzel

T2

Niveau

2

0

Ferner sei ri die Wurzel des Baumes Ti . 3

7

• eine Folge von Knoten v0 , v1 , . . . , vk heißt Weg, falls vi +1 Nachfolger

linker Unterbaum 5 von

von vi ist für alle 0 ≤ i ≤ k − 1, 2

• der Weg v0 , v1 , . . . , vk hat die Länge k , • 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 ).

5

1

3 Knoten

8

Kanten

Tiefe(7)=2

7

5

3 ist Vater von 2 3 ist Vater von 5 2 ist linker Sohn von 3 5 ist rechter Sohn von 3

2

8

3

Blatt 5

4

62 / 1

61 / 1

Datenstrukturen

Datenstrukturen Darstellungen von Bäumen

In der Informatik werden Bäume stets so dargestellt, dass die Wurzel oben und die Blätter unten liegen.

• 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 Nachteil: variable Zeigerzahl

haben kann.

63 / 1

64 / 1

Datenstrukturen

Datenstrukturen

• verkettete Liste mit 3 Datentypen

Beispiel:

• jedes Element der Liste besteht aus 3 Teilen:

0

1

1

Datum

Indikator

1

Zeiger 2

3

6

0

4

4 0

5

1

2

0

3

0

7

7 1

• Indikator = 0: ; Datum ist eine zu speichernde Größe • Indikator = 1: ; 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 / 1

66 / 1

Datenstrukturen

Datenstrukturen

Binäre Bäume

Lemma

Ein Baum, in dem jeder Knoten höchstens 2 Söhne hat, heißt binär.

Ein binärer Baum der Höhe h hat höchstens 2h+1 − 1 Knoten und 2h Blätter.

Darstellung binärer Bäume Beweis: (per Induktion): √ • h=0:

• durch 2 Felder Leftsoni und Rightsoni • dazu ggf. Informationen über: Inhalt der Knoten, Väter, # Nachfolger in zusätzlichen Feldern 1

2

3

4

5

6

1 2 3 4 5 6

R 4 6 -

• sei T ein Baum der Höhe h • T hat höchstens 2 Söhne r1 und r2 • r1 , r2 sind Wurzeln von Unterbäumen der Höhe höchstens h − 1

L 2 3 5 -

• per Induktion haben T1 und T2 jeweils höchstens • 2h − 1 Knoten und 2h−1 Blätter

• damit hat T höchstens • 2 · (2h − 1) + 1 = 2h+1 − 1 Knoten und 2 · (2h−1 ) = 2h Blätter.

67 / 1

68 / 1

Datenstrukturen

Datenstrukturen • per Induktion gilt:

Satz

mittlere Tiefe(T1 ) ≥ log k1 ,

Die maximale und die mittlere Tiefe eines Blattes in einem Binärbaum mit k Blättern beträgt mindestens log k .

• die Tiefe in T ist um 1 größer als in T1 bzw. T2 • somit:

Beweis:

• haben alle Blätter die Tiefe höchstens t , so hat T höchstens 2t Blätter • ⇒ die maximale Tiefe ist mindestens log k .

” k “ ” k1 “ 2 mittlere Tiefe(T1 ) + 1 + mittlere Tiefe(T2 ) + 1 k k k1 k2 ≥ (log k1 + 1) + (log k2 + 1) k k 1 = (k1 log 2k1 + k2 log 2k2 ) k := f (k1 , k2 )

mittlere Tiefe(T ) =

Beweis des zweiten Teils per Induktion: √ • k =1: .

• sei T ein Baum mit k ≥ 2 Blättern • seien T1 , T2 die Teilbäume unter der Wurzel mit k1 bzw. k2 Blättern • per Induktion gilt: mittlere Tiefe(T1 ) ≥ log k1 ,

mittlere Tiefe(T2 ) ≥ log k2

Die Funktion f (k1 , k2 ) nimmt ihr Minimum unter der Bedingung k1 + k2 = k im Punkt k1 = k2 = k2 an. Somit:

mittlere Tiefe(T2 ) ≥ log k2 mittlere Tiefe(T ) ≥

1 k k k k ( log 2 + log 2 ) = log k . k 2 2 2 2 70 / 1

69 / 1

Datenstrukturen

Datenstrukturen

Definition

Definition

Ein binärer Baum der Höhe h heißt voll, wenn er 2h+1 − 1 Knoten hat.

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.

Sequentielle Darstellung Die Knoten des vollen binären Baums werden beginnend in der Wurzel auf jedem Tiefenniveau von links nach rechts durchnumeriert.

1

2

3

1

4 2

4

5

6

3

5

6

7

71 / 1

72 / 1

Datenstrukturen

Datenstrukturen

Lemma

Kompakte Darstellung vollständiger binärer Bäume

Für einen vollständigen binären Baum T mit n Knoten gilt

Vollständige binäre Bäume haben eine kompakte sequentielle Darstellung der Relationen Vater, linker Sohn und rechter Sohn (ohne Zeiger):

Höhe(T ) = dlog(n + 1)e − 1.



bi /2c : für i > 1 − : für i = 1 (Wurzel)



2i : für 2i ≤ n − : für 2i > n



2i + 1 : für 2i + 1 ≤ n − : für 2i + 1 > n

Vater (i ) =

Beweis (per Induktion):

• sei h die Höhe von T • die Knotenanzahl von T liegt zwischen denen der vollen Bäume der

Leftson (i ) =

Höhe h und h − 1

• ⇒ 2h − 1 < n ≤ 2h+1 − 1 • ⇒ h < log(n + 1) ≤ h + 1 • ⇒ h < dlog(n + 1)e ≤ h + 1

Rightson (i ) =

(da h ∈ N)

• ⇒ h + 1 = dlog(n + 1)e.

73 / 1

74 / 1

Datenstrukturen

Datenstrukturen



bi /2c : für i > 1 − : für i = 1 (Wurzel)

• diese Numerierung ist eine spezielle Aufzählung der Knoten eines



2i : für 2i ≤ n − : für 2i > n

• in einigen Anwendungen müssen wir die Knoten eines Baumes



2i + 1 : für 2i + 1 ≤ n − : für 2i + 1 > n

Vater (i ) = Leftson (i ) = Rightson (i ) =

Baums systematisch durchsuchen: • zum Ausgeben der Einträge • zum Aufsummieren der Einträge • zur Bildung eines Mittelwerts über die Einträge,. . .

1

• wir wollen somit die Knoten in einer bestimmten Reihenfolge

2

durchlaufen

3

• die gebräuchlichsten Reihenfolgen: 4

5

6

7

• Präordnung • Postordnung • symmetrisches Durchmustern (nur für Binärbäume)

75 / 1

76 / 1

Datenstrukturen

Datenstrukturen

Sei T ein Baum mit Wurzel r und Söhnen r1 , . . . , rk .

Eigenschaften der Durchmusterungen

Präordnung

Wir identifizieren Knoten mit ihrer Nummer.

(1) Durchmustere die Wurzel

Präordnung

(2) Durchmustere in Präordnung nacheinander T1 , . . . , Tk

(1) Durchmustere die Wurzel (2) Durchmustere in Präordnung nacheinander T1 , . . . , Tk

Postordnung

Sei r die Wurzel des Teilbaums Tr . Dann ist

(1) Durchmustere in Postordnung nacheinander T1 , . . . , Tk

v ∈ Tr ⇐⇒ r ≤ v ≤ r + |Tr | − 1.

(2) Durchmustere die Wurzel symmetrisches Durchmustern von Binärbäumen

Folgerung

(1) Durchmustere in symmetrischer Ordnung Tlinks (falls er existiert)

Ist |Tr | bekannt, so kann in O(1) Schritten entschieden werden, ob v Nachfolger von r ist.

(2) Durchmustere die Wurzel (3) Durchmustere in symmetrischer Ordnung Trechts (falls er existiert)

78 / 1

77 / 1

Datenstrukturen

Datenstrukturen

Postordnung

symmetrisches Durchmustern von Binärbäumen

(1) Durchmustere in Postordnung nacheinander T1 , . . . , Tk

(1) Durchmustere in symmetrischer Ordnung Tlinks (falls er existiert)

(2) Durchmustere die Wurzel

(2) Durchmustere die Wurzel (3) Durchmustere in symmetrischer Ordnung Trechts (falls er existiert)

Sei r die Wurzel des Teilbaums Tr . Dann ist v ∈ Tr ⇐⇒ r − |Tr | + 1 ≤ v ≤ r .

Die Knoten im linken Teilbaum von r tragen kleinere Nummern als r , die im rechten größere.

Folgerung

Folgerung

Ist |Tr | bekannt, so kann in O(1) Schritten entschieden werden, ob v Nachfolger von r ist.

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 / 1

80 / 1

Datenstrukturen

Datenstrukturen Nichtrekursiver Algorithmus zur symmetrischen Durchmusterung begin count = 1 v = root Top = 0 left: while (leftson(v) 6= leer) then push (Stack, v) v = leftson(v) end while Center: Number(v) = count count = count + 1 if (rightson(v) 6= leer) then v = rightson(v) goto left end if if (top 6= 0) then Pop(Stack, v) goto center end if end

Rekursiver Algorithmus zur symmetrischen Durchmusterung

begin count = 1 SymmOrd(Wurzel) end //Hauptprogramm

procedure SymmOrd(v) if (leftson(v) 6= leer) then SymmOrd(leftson(v)) Number(v) = count count = count + 1 if (rightson(v) 6= leer) then SymmOrd(rightson(v)) end

81 / 1

82 / 1

Datenstrukturen

Datenstrukturen Durch Einfügen und Löschen von Stichworten kann der Suchbaum wie folgt aussehen:

Stichwortsuche

• gegeben: ein Lexikon mit n Stichworten • Frage: ist ein gegebener Begriff im Lexikon enthalten?

g a

b

d

Zwei möglich Ansätze:

i

c d

• verkettete Listen: ; O(n) im worst-case

b

f

h

j

• binärer Baum als Suchbaum organisiert: j

a

c

e

• Wörter im linken Unterbaum sind alphabetisch größer als das Wort in der Wurzel Wir werden versuchen, diese Situation zu verhindern, und balancierte Bäume verwenden.

• Wörter im rechten Unterbaum sind alphabetisch kleiner als das Wort in der Wurzel

Wir verschieben daher die Laufzeituntersuchungen der Operationen Folgerung

Füge_ein, Entferne, Suche und Zugriff auf Bäumen auf ein späte-

Wir können in O(Höhe(T )) entscheiden, ob das gesuchte Wort im Lexikon vorkommt.

res Kapitel. 83 / 1

84 / 1