Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

Ähnliche Präsentationen


Präsentation zum Thema: "LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)"—  Präsentation transkript:

1 LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

2 LS 2 / Informatik 2 Organisatorisches Übungen Ab der nächsten Heimübung ist die Teilnahme an der Besprechung der Heimübung nicht mehr verpflichtend Lernraumbetreuung Mo 14:30-17:30 in U04 zur C-Betreuung (Praktikum) Dafür fällt aus: Mo 14:30 – 17:30 Zweiter Test Aufgabe 1: Nachvollziehen eines Algorithmus oder einer Datenstruktur Aufgabe 2: Entwurf und Analyse eines Algorithmus zur dynamischen Programmierung Aufgabe 3: Entwurf und Analyse eines gierigen Algorithmus

3 LS 2 / Informatik 3 Datenstrukturen Datenstruktur Feld Platzbedarf (max) Laufzeit Suche: (n) Laufzeit Einfügen/Löschen: (1) Vorteile Schnelles Einfügen und Löschen Nachteile Speicherbedarf abhängig von max (nicht vorhersagbar) Hohe Laufzeit für Suche

4 LS 2 / Informatik 4 Datenstrukturen Datenstruktur sortiertes Feld Sortiertes Feld A[1,…,max] Integer n, 1 n max n bezeichnet Anzahl Elemente in Datenstruktur nil A n

5 LS 2 / Informatik 5 Datenstrukturen Einfügen(s) 1. n n+1 2. i n 3. while s < A[i-1] do 4. A[i] A[i-1] 5. i i A[i] s nil n Einfügen(10)

6 LS 2 / Informatik 6 Datenstrukturen Einfügen(s) 1. n n+1 2. i n 3. while s < A[i-1] do 4. A[i] A[i-1] 5. i i A[i] s nil n Einfügen(10)

7 LS 2 / Informatik 7 Einfügen(s) 1. n n+1 2. i n 3. while s < A[i-1] do 4. A[i] A[i-1] 5. i i A[i] s Datenstrukturen nil n Einfügen(10)

8 LS 2 / Informatik 8 Einfügen(s) 1. n n+1 2. i n 3. while s < A[i-1] do 4. A[i] A[i-1] 5. i i A[i] s Datenstrukturen nil n Einfügen(10)

9 LS 2 / Informatik 9 Einfügen(s) 1. n n+1 2. i n 3. while s < A[i-1] do 4. A[i] A[i-1] 5. i i A[i] s Datenstrukturen nil n Einfügen(10) Laufzeit O(n)

10 LS 2 / Informatik 10 Datenstrukturen Löschen(i) 1. for j i to n-1 do 2. A[j] A[j+1] 3. A[n] nil 4. n n nil n Parameter ist der Index des zu löschenden Objekts

11 LS 2 / Informatik 11 Datenstrukturen Löschen(i) 1. for j i to n-1 do 2. A[j] A[j+1] 3. A[n] nil 4. n n nil n Parameter ist der Index des zu löschenden Objekts Löschen(2)

12 LS 2 / Informatik 12 Datenstrukturen Löschen(i) 1. for j i to n-1 do 2. A[j] A[j+1] 3. A[n] nil 4. n n nil n Parameter ist der Index des zu löschenden Objekts Löschen(2) i

13 LS 2 / Informatik 13 Datenstrukturen Löschen(i) 1. for j i to n-1 do 2. A[j] A[j+1] 3. A[n] nil 4. n n nil n Löschen(2) i

14 LS 2 / Informatik 14 Datenstrukturen Löschen(i) 1. for j i to n-1 do 2. A[j] A[j+1] 3. A[n] nil 4. n n nil n Löschen(2) i

15 LS 2 / Informatik 15 Löschen(i) 1. for j i to n-1 do 2. A[j] A[j+1] 3. A[n] nil 4. n n-1 Datenstrukturen nil n Löschen(2) i

16 LS 2 / Informatik 16 Löschen(i) 1. for j i to n-1 do 2. A[j] A[j+1] 3. A[n] nil 4. n n-1 Datenstrukturen nil n Löschen(2) i

17 LS 2 / Informatik 17 Suchen(x) Binäre Suche Laufzeit O(log n) Datenstrukturen nil n Löschen(2) i

18 LS 2 / Informatik 18 Datenstrukturen Datenstruktur sortiertes Feld Platzbedarf (max) Laufzeit Suche: (log n) Laufzeit Einfügen/Löschen: (n) Vorteile Schnelles Suchen Nachteile Speicherbedarf abhängig von max (nicht vorhersagbar) Hohe Laufzeit für Einfügen/Löschen

19 LS 2 / Informatik 19 Datenstrukturen Doppelt verkettete Listen Listenelement x ist Objekt bestehend aus Schlüssel und zwei Zeigern prev und next next verweist auf Nachfolger von x prev verweist auf Vorgänger von x prev/next sind nil, wenn Vorgänger/Nachfolger nicht existiert head[L] zeigt auf das erste Element nil head[L] prev next Schlüssel

20 LS 2 / Informatik 20 Datenstrukturen Einfügen(L,x) 1. next[x] head[L] 2. if head[L] nil then prev[head[L]] x 3. head[L] x 4. prev[x] nil nil 7 4 head[L]

21 LS 2 / Informatik 21 Datenstrukturen Einfügen(L,x) 1. next[x] head[L] 2. if head[L] nil then prev[head[L]] x 3. head[L] x 4. prev[x] nil nil 7 4 head[L] 5 x

22 LS 2 / Informatik 22 Datenstrukturen Einfügen(L,x) 1. next[x] head[L] 2. if head[L] nil then prev[head[L]] x 3. head[L] x 4. prev[x] nil 7 4nil head[L] 5 x

23 LS 2 / Informatik 23 Datenstrukturen Einfügen(L,x) 1. next[x] head[L] 2. if head[L] nil then prev[head[L]] x 3. head[L] x 4. prev[x] nil 7 4nil head[L] 5 x

24 LS 2 / Informatik 24 Datenstrukturen Einfügen(L,x) 1. next[x] head[L] 2. if head[L] nil then prev[head[L]] x 3. head[L] x 4. prev[x] nil 7 4nil head[L] nil 5 x

25 LS 2 / Informatik 25 Datenstrukturen Einfügen(L,x) 1. next[x] head[L] 2. if head[L] nil then prev[head[L]] x 3. head[L] x 4. prev[x] nil Laufzeit O(1) 7 4nil head[L] nil 5 x

26 LS 2 / Informatik 26 Datenstrukturen Löschen(L,x) 1. if prev[x] nil then next[prev[x]] next[x] 2. else head[L] next[x] 3. if next[x] nil then prev[next[x]] prev[x] 4. delete x 7 4nil head[L] nil 5

27 LS 2 / Informatik 27 Datenstrukturen Löschen(L,x) 1. if prev[x] nil then next[prev[x]] next[x] 2. else head[L] next[x] 3. if next[x] nil then prev[next[x]] prev[x] 4. delete x 7 4nil head[L] nil 5 x

28 LS 2 / Informatik 28 Datenstrukturen Löschen(L,x) 1. if prev[x] nil then next[prev[x]] next[x] 2. else head[L] next[x] 3. if next[x] nil then prev[next[x]] prev[x] 4. delete x 7 4nil head[L] nil 5 x

29 LS 2 / Informatik 29 Datenstrukturen Löschen(L,x) 1. if prev[x] nil then next[prev[x]] next[x] 2. else head[L] next[x] 3. if next[x] nil then prev[next[x]] prev[x] 4. delete x 7 4nil head[L] nil 5 x

30 LS 2 / Informatik 30 Datenstrukturen Löschen(L,x) 1. if prev[x] nil then next[prev[x]] next[x] 2. else head[L] next[x] 3. if next[x] nil then prev[next[x]] prev[x] 4. delete x 4nil head[L] nil 5

31 LS 2 / Informatik 31 Löschen(L,x) 1. if prev[x] nil then next[prev[x]] next[x] 2. else head[L] next[x] 3. if next[x] nil then prev[next[x]] prev[x] 4. delete x Laufzeit O(1) Datenstrukturen 4nil head[L] nil 5

32 LS 2 / Informatik 32 Suche(L,k) 1.x head[L] 2. while x nil and key[x] k do 3. x next[x] 4. return x Datenstrukturen

33 LS 2 / Informatik 33 Suche(L,k) 1.x head[L] 2. while x nil and key[x] k do 3. x next[x] 4. return x Datenstrukturen 4nil head[L] nil 5

34 LS 2 / Informatik 34 Suche(L,k) 1.x head[L] 2. while x nil and key[x] k do 3. x next[x] 4. return x Datenstrukturen 4nil head[L] nil 5 Suche(L,4) x

35 LS 2 / Informatik 35 Suche(L,k) 1.x head[L] 2. while x nil and key[x] k do 3. x next[x] 4. return x Datenstrukturen 4nil head[L] nil 5 Suche(L,4)

36 LS 2 / Informatik 36 Suche(L,k) 1.x head[L] 2. while x nil and key[x] k do 3. x next[x] 4. return x Datenstrukturen 4nil head[L] nil 5 Suche(L,4) x

37 LS 2 / Informatik 37 Suche(L,k) 1.x head[L] 2. while x nil and key[x] k do 3. x next[x] 4. return x Datenstrukturen 4nil head[L] nil 5 Suche(L,4) x

38 LS 2 / Informatik 38 Suche(L,k) 1.x head[L] 2. while x nil and key[x] k do 3. x next[x] 4. return x Datenstrukturen 4nil head[L] nil 5 Suche(L,4) x

39 LS 2 / Informatik 39 Suche(L,k) 1.x head[L] 2. while x nil and key[x] k do 3. x next[x] 4. return x Laufzeit O(n) Datenstrukturen 4nil head[L] nil 5 Suche(L,4) x

40 LS 2 / Informatik 40 Datenstruktur Liste: Platzbedarf (n) Laufzeit Suche: (n) Laufzeit Einfügen/Löschen: (1) Vorteile Schnelles Einfügen/Löschen O(n) Speicherbedarf Nachteile Hohe Laufzeit für Suche Datenstrukturen

41 LS 2 / Informatik 41 Drei grundlegende Datenstrukturen Feld sortiertes Feld doppelt verkettete Liste Diskussion Alle drei Strukturen haben gewichtige Nachteile Zeiger/Referenzen helfen beim Speichermanagement Sortierung hilft bei Suche ist aber teuer aufrecht zu erhalten Datenstrukturen

42 LS 2 / Informatik 42 Binärbäume Schlüssel key und ggf. weitere Daten Vaterzeiger p[v] auf Vater von v (blau) Zeiger lc[v] (rc[v]) auf linkes (rechtes) Kind von v Wurzelzeiger root[T] Datenstrukturen / // // // // root[T] keyp[v]lc[v]rc[v]

43 LS 2 / Informatik 43 Binäre Suchbäume Verwende Binärbaum Speichere Schlüssel geordnet Binäre Suchbaumeigenschaft: Sei x Knoten im binären Suchbaum Ist y Knoten im linken Unterbaum von x, dann gilt key[y] key[x] Ist y Knoten im rechten Unterbaum von x, dann gilt key[y]>key[x] Datenstrukturen

44 LS 2 / Informatik 44 Unterschiedliche Suchbäume Schlüsselmenge 3,4,6,7,7,9 Wir erlauben mehrfache Vorkommen desselben Schlüssels Datenstrukturen

45 LS 2 / Informatik 45 Ausgabe aller Schlüssel Gegeben binärer Suchbaum Wie kann man alle Schlüssel aufsteigend sortiert in (n) Zeit ausgeben? Datenstrukturen

46 LS 2 / Informatik 46 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Aufruf über Inorder-Tree-Walk(root[T])

47 LS 2 / Informatik 47 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen

48 LS 2 / Informatik 48 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen

49 LS 2 / Informatik 49 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen

50 LS 2 / Informatik 50 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen

51 LS 2 / Informatik 51 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen

52 LS 2 / Informatik 52 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Kein linkes Kind vorhanden, d.h. lc[x]=nil Kein linkes Kind vorhanden, d.h. lc[x]=nil xx nil

53 LS 2 / Informatik 53 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Kein linkes Kind vorhanden, d.h. lc[x]=nil Kein linkes Kind vorhanden, d.h. lc[x]=nil xx nil

54 LS 2 / Informatik 54 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3

55 LS 2 / Informatik 55 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3 Kein rechtes Kind vorhanden, d.h. rc[x]=nil Kein rechtes Kind vorhanden, d.h. rc[x]=nil nil

56 LS 2 / Informatik 56 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3 Kein rechtes Kind vorhanden, d.h. rc[x]=nil Kein rechtes Kind vorhanden, d.h. rc[x]=nil nil

57 LS 2 / Informatik 57 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3 Knoten abgearbeitet

58 LS 2 / Informatik 58 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4

59 LS 2 / Informatik 59 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4 nil

60 LS 2 / Informatik 60 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4 nil

61 LS 2 / Informatik 61 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4

62 LS 2 / Informatik 62 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6

63 LS 2 / Informatik 63 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6

64 LS 2 / Informatik 64 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6

65 LS 2 / Informatik 65 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6

66 LS 2 / Informatik 66 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6

67 LS 2 / Informatik 67 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6

68 LS 2 / Informatik 68 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6 nil

69 LS 2 / Informatik 69 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7

70 LS 2 / Informatik 70 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7

71 LS 2 / Informatik 71 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7 nil

72 LS 2 / Informatik 72 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7

73 LS 2 / Informatik 73 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7

74 LS 2 / Informatik 74 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7

75 LS 2 / Informatik 75 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7

76 LS 2 / Informatik 76 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7

77 LS 2 / Informatik 77 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7 nil

78 LS 2 / Informatik 78 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7, 9

79 LS 2 / Informatik 79 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7, 9

80 LS 2 / Informatik 80 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7, 9 nil

81 LS 2 / Informatik 81 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7, 9

82 LS 2 / Informatik 82 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7, 9

83 LS 2 / Informatik 83 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7, 9

84 LS 2 / Informatik 84 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7, 9

85 LS 2 / Informatik 85 Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Datenstrukturen Ausgabe: 3, 4, 6, 7, 7, 9

86 LS 2 / Informatik 86 Lemma 37 Inorder-Tree-Walk gibt die Schlüssel eines binären Suchbaums in aufsteigender Reihenfolge aus. Datenstrukturen

87 LS 2 / Informatik 87 Normale Induktion Wir wollen zeigen, dass Aussage A(i) für alle natürlichen Zahlen i gilt Dazu beweisen wir, dass (a) A(1) gilt (b) Wenn A(i) gilt, dann gilt auch A(i+1) (a) heißt Induktionsanfang (b) nennt man Induktionsschluss (oder auch Induktionsschritt) Die Vorraussetzung in (b) (also A(i)) heißt Induktionsvoraussetzung Datenstrukturen

88 LS 2 / Informatik 88 Induktion über die Struktur von Binärbäumen Wollen zeigen, dass Aussage für alle Binärbäume gilt: (a) Zeige Induktionsanfang für kleine Binärbäume (b) Setze größere Bäume aus kleinen Binärbäumen zusammen, d.h. Datenstrukturen A A B B Aussage gilt für Bäume A und B

89 LS 2 / Informatik 89 Induktion über die Struktur von Binärbäumen Wollen zeigen, dass Aussage für alle Binärbäume gilt: (a) Zeige Induktionsanfang für kleine Binärbäume (b) Setze größere Bäume aus kleinen Binärbäumen zusammen, d.h. Datenstrukturen v v A A B B Dann gilt Aussage auch für neuen Baum mit Wurzel v

90 LS 2 / Informatik 90 Definition Die Höhe eines Binärbaums mit Wurzel v ist die Länge (Anzahl Kanten) des längsten einfachen Weges (keine mehrfach vorkommenden Knoten) von der Wurzel zu einem Blatt. Beispiel Baum der Höhe 3 Datenstrukturen v v

91 LS 2 / Informatik 91 Definition Die Höhe eines Binärbaums mit Wurzel v ist die Länge (Anzahl Kanten) des längsten einfachen Weges (keine mehrfach vorkommenden Knoten) von der Wurzel zu einem Blatt. Beispiel Baum der Höhe 1 Datenstrukturen v v

92 LS 2 / Informatik 92 Definition Die Höhe eines Binärbaums mit Wurzel v ist die Länge (Anzahl Kanten) des längsten einfachen Weges (keine mehrfach vorkommenden Knoten) von der Wurzel zu einem Blatt. Beispiel Baum der Höhe 0 Datenstrukturen v v

93 LS 2 / Informatik 93 Definition Die Höhe eines Binärbaums mit Wurzel v ist die Länge (Anzahl Kanten) des längsten einfachen Weges (keine mehrfach vorkommenden Knoten) von der Wurzel zu einem Blatt. Beispiel Übereinkunft: Ein leerer Baum hat Höhe -1 Damit gilt: Höhe eines Baumes mit Wurzel v und Teilbäumen A und B ist 1 + max{ Höhe(A), Höhe(B)} Datenstrukturen v v A A B B

94 LS 2 / Informatik 94 Induktion über die Struktur von Binärbäumen Wir wollen Aussage A(i) durch Induktion über die Höhe von Bäumen zeigen (a) Zeige die Aussage für leere Bäume (Bäume der Höhe -1) (b) Zeige: Gilt die Aussage für Bäume der Höhe i, so gilt sie auch für Bäume der Höhe i+1 Datenstrukturen v v A A B B

95 LS 2 / Informatik 95 Induktion über die Struktur von Binärbäumen Wir wollen Aussage A(i) durch Induktion über die Höhe von Bäumen zeigen (a) Zeige die Aussage für leere Bäume (Bäume der Höhe -1) (b) Zeige: Gilt die Aussage für Bäume der Höhe i, so gilt sie auch für Bäume der Höhe i+1 Dabei können wir immer annehmen, dass ein Baum der Höhe i+1 aus einer Wurzel v und zwei Teilbäumen A,B besteht, so dass (1) A und B Höhe maximal i haben und (2) A oder B Höhe i hat Datenstrukturen v v A A B B Höhe i+1

96 LS 2 / Informatik 96 Induktion über die Struktur von Binärbäumen Wir wollen Aussage A(i) durch Induktion über die Höhe von Bäumen zeigen (a) Zeige die Aussage für leere Bäume (Bäume der Höhe -1) (b) Zeige: Gilt die Aussage für Bäume der Höhe i, so gilt sie auch für Bäume der Höhe i+1 Dabei können wir immer annehmen, dass ein Baum der Höhe i+1 aus einer Wurzel v und zwei Teilbäumen A,B besteht, so dass (1) A und B Höhe maximal i haben und (2) A oder B Höhe i hat Datenstrukturen v v A A B B Höhe i

97 LS 2 / Informatik 97 Lemma 37 Inorder-Tree-Walk gibt die Schlüssel eines binären Suchbaums in aufsteigender Reihenfolge aus. Beweis (I.A.) Ist die Eingabe ein leerer Baum, so wird Inorder-Tree-Walk nil übergeben. Damit bricht der Algorithmus sofort ab. Es gibt also keine Ausgabe, was auch korrekt ist. (I.V.) Das Lemma gilt für Bäume der Höhe i. (I.S.) Wir müssen zeigen, dass das Lemma auch für Höhe i+10. Dazu betrachten wir den Inorder-Tree-Walk auf einem solchem Baum. Datenstrukturen Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) v v A A B B

98 LS 2 / Informatik 98 Lemma 37 Inorder-Tree-Walk gibt die Schlüssel eines binären Suchbaums in aufsteigender Reihenfolge aus. Beweis (I.S.) Wir müssen zeigen, dass das Lemma auch für Höhe i+10. Dazu betrachten wir den Inorder-Tree-Walk auf einem solchem Baum. Da der Baum Höhe mindestens 0 hat, wird der Algorithmus nicht mit nil aufgerufen. Damit wird Zeile 2 ausgeführt. Dort wird Inorder-Tree-Walk rekursiv mit dem Teilbaum A der Höhe i ausgeführt. Nach (I.V.) werden die Schlüssel aus A in aufsteigender Reihenfolge ausgegeben Datenstrukturen Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) v v A A B B

99 LS 2 / Informatik 99 Lemma 37 Inorder-Tree-Walk gibt die Schlüssel eines binären Suchbaums in aufsteigender Reihenfolge aus. Beweis Nach (I.V.) werden die Schlüssel aus A in aufsteigender Reihenfolge ausgegeben. Dann wird in Zeile 3 key[v] ausgegeben. Wegen der Suchbaumeigenschaft ist key[v] größer gleich allen Schlüsseln in A und kleiner als alle Schlüssel in B. In Zeile 4 wird dann Inorder-Tree-Walk rekursiv für Teilbaum B aufgerufen. Die dort gespeicherten Schlüssel werden nach (I.V.) ebenfalls in aufsteigender Reihenfolge ausgegeben. Datenstrukturen Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) v v A A B B

100 LS 2 / Informatik 100 Lemma 37 Inorder-Tree-Walk gibt die Schlüssel eines binären Suchbaums in aufsteigender Reihenfolge aus. Beweis Zusammenfassend werden also erst die Schlüssel in Teilbaum A in aufsteigender Reihenfolge ausgegeben. Dann folgt key[v] und dann die Schlüssel aus B in aufsteigender Reihenfolge. Aufgrund der Suchbaum- eigenschaft ist die gesamte Folge aufsteigend sortiert. Datenstrukturen Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) Inorder-Tree-Walk(x) 1. if x nil then 2. Inorder-Tree-Walk(lc[x]) 3. Ausgabe key[x] 4. Inorder-Tree-Walk(rc[x]) v v A A B B

101 LS 2 / Informatik 101 Suchen in Binärbäumen Gegeben ist Schlüssel k Gesucht ist ein Knoten mit Schlüssel k Datenstrukturen

102 LS 2 / Informatik 102 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

103 LS 2 / Informatik 103 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

104 LS 2 / Informatik 104 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

105 LS 2 / Informatik 105 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

106 LS 2 / Informatik 106 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

107 LS 2 / Informatik 107 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

108 LS 2 / Informatik 108 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

109 LS 2 / Informatik 109 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

110 LS 2 / Informatik 110 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

111 LS 2 / Informatik 111 Baumsuche(x,k) 1. if x=nil or k=key[x] then return x 2. if k

112 LS 2 / Informatik 112 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

113 LS 2 / Informatik 113 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

114 LS 2 / Informatik 114 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

115 LS 2 / Informatik 115 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

116 LS 2 / Informatik 116 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

117 LS 2 / Informatik 117 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

118 LS 2 / Informatik 118 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

119 LS 2 / Informatik 119 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

120 LS 2 / Informatik 120 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

121 LS 2 / Informatik 121 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

122 LS 2 / Informatik 122 IterativeBaumsuche(x,k) 1. while x nil and k key[x] do 2. if k

123 LS 2 / Informatik 123 Minimum- und Maximumsuche Suchbaumeigenschaft: Alle Knoten im rechten Unterbaum eines Knotens x sind größer key[x] Alle Knoten im linken Unterbaum von x sind key[x] Datenstrukturen

124 LS 2 / Informatik 124 MinimumSuche(x) 1. while lc[x] nil do x lc[x] 2. return x Datenstrukturen Wird mit Wurzel aufgerufen

125 LS 2 / Informatik 125 MinimumSuche(x) 1. while lc[x] nil do x lc[x] 2. return x Datenstrukturen Wird mit Wurzel aufgerufen Laufzeit O(h)

126 LS 2 / Informatik 126 MaximumSuche(x) 1. while rc[x] nil do x rc[x] 2. return x Datenstrukturen Wird mit Wurzel aufgerufen Laufzeit O(h)

127 LS 2 / Informatik 127 Nachfolgersuche Nachfolger bzgl. Inorder-Tree-Walk Wenn alle Schlüssel unterschiedlich, dann ist das der nächstgrößere Schlüssel Datenstrukturen

128 LS 2 / Informatik 128 Nachfolgersuche Fall 1 (rechter Unterbaum von x nicht leer): Dann ist der linkeste Knoten im rechten Unterbaum der Nachfolger von x Datenstrukturen

129 LS 2 / Informatik 129 Nachfolgersuche Fall 1 (rechter Unterbaum von x nicht leer): Dann ist der linkeste Knoten im rechten Unterbaum der Nachfolger von x Datenstrukturen

130 LS 2 / Informatik 130 Nachfolgersuche Fall 1 (rechter Unterbaum von x nicht leer): Dann ist der linkeste Knoten im rechten Unterbaum der Nachfolger von x Datenstrukturen

131 LS 2 / Informatik 131 Nachfolgersuche Fall 2 (rechter Unterbaum von x leer und x hat Nachfolger y): Dann ist y der erste Knoten auf dem Pfad zur Wurzel, der größer als x ist Datenstrukturen

132 LS 2 / Informatik 132 Nachfolgersuche Fall 2 (rechter Unterbaum von x leer und x hat Nachfolger y): Dann ist y der erste Knoten auf dem Pfad zur Wurzel, der größer als x ist Datenstrukturen

133 LS 2 / Informatik 133 Nachfolgersuche Fall 2 (rechter Unterbaum von x leer und x hat Nachfolger y): Dann ist y der erste Knoten auf dem Pfad zur Wurzel, der größer als x ist Datenstrukturen

134 LS 2 / Informatik 134 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen

135 LS 2 / Informatik 135 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(6)

136 LS 2 / Informatik 136 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(6)

137 LS 2 / Informatik 137 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(6)

138 LS 2 / Informatik 138 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5)

139 LS 2 / Informatik 139 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5)

140 LS 2 / Informatik 140 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5) y

141 LS 2 / Informatik 141 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5) y

142 LS 2 / Informatik 142 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5) y x

143 LS 2 / Informatik 143 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5) y x

144 LS 2 / Informatik 144 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5) y x

145 LS 2 / Informatik 145 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5) y x

146 LS 2 / Informatik 146 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Nachfolgersuche(5) y x

147 LS 2 / Informatik 147 Nachfolgersuche(x) 1. if rc[x] nil then return MinimumSuche(rc[x]) 2. y p[x] 3. while y nil and x=rc[y] do 4. x y 5. y p[y] 6. return y Datenstrukturen Laufzeit O(h)

148 LS 2 / Informatik 148 Vorgängersuche Symmetrisch zu Nachfolgersuche Daher ebenfall O(h) Laufzeit Datenstrukturen Laufzeit O(h)

149 LS 2 / Informatik 149 Binäre Suchbäume Aufzählen der Elemente mit Inorder-Tree-Walk in O(n) Zeit Suche in O(h) Zeit Minimum/Maximum in O(h) Zeit Vorgänger/Nachfolger in O(h) Zeit Dynamische Operationen? Einfügen und Löschen Müssen Suchbaumeigenschaft aufrecht erhalten Auswirkung auf Höhe des Baums? Datenstrukturen

150 LS 2 / Informatik 150 Einfügen Ähnlich wie Baumsuche: Finde Blatt, an das neuer Knoten angehängt wird Danach wird nil-Zeiger durch neues Element ersetzt Datenstrukturen

151 LS 2 / Informatik 151 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen

152 LS 2 / Informatik 152 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen y wird Vater des einzufügenden Elements Einfügen(8) x

153 LS 2 / Informatik 153 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x

154 LS 2 / Informatik 154 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

155 LS 2 / Informatik 155 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

156 LS 2 / Informatik 156 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

157 LS 2 / Informatik 157 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

158 LS 2 / Informatik 158 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

159 LS 2 / Informatik 159 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

160 LS 2 / Informatik 160 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

161 LS 2 / Informatik 161 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

162 LS 2 / Informatik 162 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) x y

163 LS 2 / Informatik 163 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) y x nil

164 LS 2 / Informatik 164 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) y x nil

165 LS 2 / Informatik 165 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) y x nil

166 LS 2 / Informatik 166 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) y x 8

167 LS 2 / Informatik 167 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Einfügen(8) y x 8

168 LS 2 / Informatik 168 Einfügen(T,z) 1. y nil; x root[T] 2. while x nil do 3. y x 4. if key[z] < key[x] then x lc[x] 5. else x rc[x] 6. p[z] y 7. if y=nil then root[T] z 8. else 9. if key[z]< key[y] then lc[y] z 10. else rc[y] z Datenstrukturen Laufzeit O(h)

169 LS 2 / Informatik 169 Löschen 3 unterschiedliche Fälle (a) zu löschendes Element z hat keine Kinder (b) zu löschendes Element z hat ein Kind (c) zu löschendes Element z hat zwei Kinder Datenstrukturen

170 LS 2 / Informatik 170 Fall (a) zu löschendes Element z hat keine Kinder Datenstrukturen

171 LS 2 / Informatik 171 Fall (a) zu löschendes Element z hat keine Kinder Entferne Element Datenstrukturen

172 LS 2 / Informatik 172 Fall (b) Zu löschendes Element z hat 1 Kind Datenstrukturen

173 LS 2 / Informatik 173 Fall (b) Zu löschendes Element z hat 1 Kind Datenstrukturen

174 LS 2 / Informatik 174 Fall (c) Zu löschendes Element z hat 2 Kinder Datenstrukturen

175 LS 2 / Informatik 175 Fall (c) Zu löschendes Element z hat 2 Kinder Schritt 1: Bestimme Nachfolger von z Datenstrukturen

176 LS 2 / Informatik 176 Fall (c) Zu löschendes Element z hat 2 Kinder Schritt 1: Bestimme Nachfolger von z Datenstrukturen Nachfolger hat nur ein Kind

177 LS 2 / Informatik 177 Fall (c) Zu löschendes Element z hat 2 Kinder Schritt 1: Bestimme Nachfolger von z Schritt 2: Entferne Nachfolger Datenstrukturen

178 LS 2 / Informatik 178 Fall (c) Zu löschendes Element z hat 2 Kinder Schritt 1: Bestimme Nachfolger von z Schritt 2: Entferne Nachfolger Schritt 3: Ersetze z durch Nachfolger Datenstrukturen

179 LS 2 / Informatik 179 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen

180 LS 2 / Informatik 180 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) Referenz auf z wird übergeben!

181 LS 2 / Informatik 181 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) Bestimme Knoten, der gelöscht werden soll. Der Knoten hat nur einen Nachfolger z

182 LS 2 / Informatik 182 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) Bestimme Knoten, der gelöscht werden soll. Der Knoten hat nur einen Nachfolger z y

183 LS 2 / Informatik 183 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) Bestimme das Kind von y, falls existent z y x

184 LS 2 / Informatik 184 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) z y x Aktualisiere Vaterzeiger von x

185 LS 2 / Informatik 185 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) z y x

186 LS 2 / Informatik 186 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) z y x Das rechte Kind von z wird x.

187 LS 2 / Informatik 187 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) z y x Das rechte Kind von z wird x.

188 LS 2 / Informatik 188 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) z x Umkopieren des Inhalts von y nach z

189 LS 2 / Informatik 189 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) z

190 LS 2 / Informatik 190 Löschen(T,z) 1. if lc[z]=nil or rc[z]=nil then y z 2. else y NachfolgerSuche(z) 3. if lc[y] nil then x lc[y] 4. else x rc[y] 5. if x nil then p[x] p[y] 6. if p[y]=nil then root[T] x 7. else if y=lc[p[y]] then lc[p[y]] x 8. else rc[p[y]] x 9. key[z] key[y] Datenstrukturen Löschen(6) z Laufzeit O(h)

191 LS 2 / Informatik 191 Datenstrukturen Binäre Suchbäume Ausgabe aller Elemente in O(n) Suche, Minimum, Maximum, Nachfolger in O(h) Einfügen, Löschen in O(h) Frage Wie kann man eine kleine Höhe unter Einfügen und Löschen garantieren?


Herunterladen ppt "LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)"

Ähnliche Präsentationen


Google-Anzeigen