Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

Ähnliche Präsentationen


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

1 Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

2 Datenstrukturen Problem Operationen
Gegeben sind n Objekte O ,.., O mit zugehörigen Schlüsseln s(O ) Operationen Suche(x); Ausgabe O mit Schlüssel s(O) =x; nil, falls kein Objekt mit Schlüssel x in Datenbank Einfügen(O); Einfügen von Objekt O in Datenbank Löschen(O); Löschen von Objekt O mit aus der Datenbank 1 n i

3 Datenstrukturen Binäre Suchbäume Frage 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?

4 Datenstrukturen AVL-Bäume [Adelson-Velsky und Landis]
Ein Binärbaum heißt AVL-Baum, wenn für jeden Knoten gilt: Die Höhe seines linken und rechten Teilbaums unterscheidet sich höchstens um 1.

5 Datenstrukturen Satz 38 Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  h h+1

6 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis a) n  : AVL-Baum ist Binärbaum h h+1 h+1

7 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis a) n  : AVL-Baum ist Binärbaum Ein vollständiger Binärbaum hat eine maximale Anzahl Knoten unter allen Binärbäumen der Höhe h h h+1 h+1

8 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis a) n  : AVL-Baum ist Binärbaum Ein vollständiger Binärbaum hat eine maximale Anzahl Knoten unter allen Binärbäumen der Höhe h N(h) = Anzahl Knoten eines vollständigen Binärbaums der Höhe h h h+1 h+1

9 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis a) n  : N(h) = Anzahl Knoten eines vollständigen Binärbaums der Höhe h h h+1 h+1

10 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis a) n  : N(h) = Anzahl Knoten eines vollständigen Binärbaums der Höhe h h h+1 h+1

11 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Beweis per Induktion über die Struktur von AVL-Bäumen h h+1 h

12 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Beweis per Induktion über die Struktur von AVL-Bäumen (I.A.) Wir betrachten alle AVL-Bäume der Höhe 0 und 1. h h+1 h

13 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Beweis per Induktion über die Struktur von AVL-Bäumen (I.A.) Wir betrachten alle AVL-Bäume der Höhe 0 und 1. h=0: Der Baum hat einen Knoten. Es gilt (3/2) =1  1. h h+1 h h

14 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Beweis per Induktion über die Struktur von AVL-Bäumen. (I.A.) Wir betrachten alle AVL-Bäume der Höhe 0 und 1. h=0: Der Baum hat einen Knoten. Es gilt (3/2) =1  1. h=1: Der Baum hat 2 oder 3 Knoten. Es gilt (3/2) = 3/2  2  3. h h+1 h h h

15 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Beweis per Induktion über die Struktur von AVL-Bäumen. (I.A.) Wir betrachten alle AVL-Bäume der Höhe 0 und 1. h=0: Der Baum hat einen Knoten. Es gilt (3/2) =1  1. h=1: Der Baum hat 2 oder 3 Knoten. Es gilt (3/2) = 3/2  2  3. h h+1 h h h

16 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: (I.V.) Für jeden AVL-Baum der Höhe j, 0  j  h, gilt der Satz. h h+1 h v A B

17 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: (I.V.) Für jeden AVL-Baum der Höhe j, 0  j  h, gilt der Satz. (I.S.) Sei h≥1. Betrachte AVL-Baum T der Höhe h+1 mit Wurzel v. Seien A,B linker bzw. rechter Teilbaum von v. h h+1 h v A B

18 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: (I.V.) Für jeden AVL-Baum der Höhe j, 0  j  h, gilt der Satz. (I.S.) Sei h≥1. Betrachte AVL-Baum T der Höhe h+1 mit Wurzel v. Seien A,B linker bzw. rechter Teilbaum von v. A oder B (oder beide) hat Tiefe h. h h+1 h v A B

19 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: (I.V.) Für jeden AVL-Baum der Höhe j, 0  j  h, gilt der Satz. (I.S.) Sei h≥1. Betrachte AVL-Baum T der Höhe h+1 mit Wurzel v. Seien A,B linker bzw. rechter Teilbaum von v. A oder B (oder beide) hat Tiefe h. Wegen AVL-Eigenschaft haben A und B Tiefe mindestens h-1≥0. h h+1 h v A B

20 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: (I.V.) Für jeden AVL-Baum der Höhe j, 0  j  h, gilt der Satz. (I.S.) Sei h≥1. Betrachte AVL-Baum T der Höhe h+1 mit Wurzel v. Seien A,B linker bzw. rechter Teilbaum von v. A oder B (oder beide) hat Tiefe h. Wegen AVL-Eigenschaft haben A und B Tiefe mindestens h-1≥0. h h+1 h v A B

21 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Wegen AVL-Eigenschaft haben A und B Tiefe mindestens h-1≥0. Da T ein AVL-Baum ist, sind auch A und B AVL-Bäume. h h+1 h v A B

22 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Wegen AVL-Eigenschaft haben A und B Tiefe mindestens h-1≥0. Da T ein AVL-Baum ist, sind auch A und B AVL-Bäume. Kann also (I.V.) anwenden, da A und B AVL-Bäume der Tiefe ≥0 sind h h+1 h v A B

23 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Wegen AVL-Eigenschaft haben A und B Tiefe mindestens h-1≥0. Da T ein AVL-Baum ist, sind auch A und B AVL-Bäume. Kann also (I.V.) anwenden, da A und B AVL-Bäume der Tiefe ≥0 sind Es gibt drei Fälle: 1) A,B haben Höhe h 2) A hat Höhe h und B Hat Höhe h-1 3) A hat Höhe h-1 und B hat Höhe h h h+1 h v A B

24 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Sei T(h) die minimale Anzahl Knoten in einem AVL-Baum der Tiefe h. h h+1 h v A B

25 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Sei T(h) die minimale Anzahl Knoten in einem AVL-Baum der Tiefe h. Nach (I.V.) gilt in allen drei Fällen h h+1 h v A B

26 Datenstrukturen Satz 38 Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Beweis b) (3/2)  n: Sei T(h) die minimale Anzahl Knoten in einem AVL-Baum der Tiefe h. Nach (I.V.) gilt in allen drei Fällen h h+1 h v A B

27 Datenstrukturen Satz 38 Korollar 38
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Korollar 38 Ein AVL-Baum mit n Knoten hat Höhe Q(log n). h h+1

28 Datenstrukturen Satz 38 Korollar Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Korollar Ein AVL-Baum mit n Knoten hat Höhe Q(log n). Beweis (1) Zeige h=O(log n): Es gilt n ≥ (3/2) nach Satz h h+1 h

29 Datenstrukturen Satz 38 Korollar Beweis
Für jeden AVL-Baum der Höhe h≥0 mit n Knoten gilt: (3/2)  n  Korollar Ein AVL-Baum mit n Knoten hat Höhe Q(log n). Beweis (2) Zeige h=W(log n): Es gilt n ≤ ≤ nach Satz h h+1 h+1 h+1

30 Datenstrukturen Rotationen y x x y Rechtsrotation(T,y) C A
Linksrotation(T,x) A B B C

31 Datenstrukturen Beispiel 1 15 15 y Rechtsrotation(T,y) 9 21 9 19 x 7 x
27 y 7 17 21 17 20 20 27

32 Datenstrukturen Beispiel 2 x y 15 21 y x Linksrotation(T,x) 21 27 9 15
19 27 9 19 17 20 7 17 20

33 Datenstrukturen Linksrotation(T,x) 1. y  rc[x] 2. rc[x]  lc[y]
3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y

34 Datenstrukturen Annahme: x hat rechtes Kind. Linksrotation(T,x)
1. y  rc[x] 2. rc[x]  lc[y] 3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y

35 Datenstrukturen Annahme: x hat rechtes Kind. Linksrotation(T,x)
1. y  rc[x] 2. rc[x]  lc[y] 3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y x 15 9 21 7 19 27 17 20

36 Datenstrukturen Linksrotation(T,x) 1. y  rc[x] x 2. rc[x]  lc[y] 15
3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y x 15 y 9 21 7 19 27 17 20

37 Datenstrukturen Linksrotation(T,x) 1. y  rc[x] x 2. rc[x]  lc[y] 15
3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y x 15 y 9 21 7 19 27 17 20

38 Datenstrukturen Linksrotation(T,x) 1. y  rc[x] x 2. rc[x]  lc[y] 15
3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y x 15 y 9 21 7 19 27 17 20

39 Datenstrukturen Linksrotation(T,x) 1. y  rc[x] 2. rc[x]  lc[y]
3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y x nil 15 y 9 21 7 19 27 17 20

40 Datenstrukturen root[T] Linksrotation(T,x) 1. y  rc[x]
2. rc[x]  lc[y] 3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y x nil 15 y 9 21 7 19 27 17 20

41 Datenstrukturen root[T] Linksrotation(T,x) 1. y  rc[x]
2. rc[x]  lc[y] 3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y x nil 15 y 9 21 7 19 27 17 20

42 Datenstrukturen root[T] nil Linksrotation(T,x) 1. y  rc[x] 21 y
2. rc[x]  lc[y] 3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y 21 y x 15 27 9 19 7 17 20

43 Datenstrukturen root[T] nil Linksrotation(T,x) 1. y  rc[x] 21 y
2. rc[x]  lc[y] 3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y 21 y x 15 27 9 19 7 17 20

44 Datenstrukturen root[T] nil Linksrotation(T,x) 1. y  rc[x] 21 y
2. rc[x]  lc[y] 3. if lc[y]nil then p[lc[y]]  x 4. p[y]  p[x] 5. if p[x]=nil then root[T]  y 6. else if x=lc[p[x]] then lc[p[x]]  y else rc[p[x]]  y 8. lc[y]  x 9. p[x]  y 21 y x 15 27 9 19 7 17 20

45 Datenstrukturen Dynamische AVL-Bäume Idee
Operationen Suche, Einfügen, Löschen, Min/Max, Vorgänger/Nachfolger,… wie in der letzten Vorlesung Laufzeit O(h) für diese Operationen Nur Einfügen/Löschen verändern Struktur des Baums Idee Wir brauchen Prozedur, um AVL-Eigenschaft nach Einfügen/Löschen wiederherzustellen.

46 Datenstrukturen Nach Korollar gilt h = Q(log n) Dynamische AVL-Bäume
Operationen Suche, Einfügen, Löschen, Min/Max, Vorgänger/Nachfolger,… wie in der letzten Vorlesung Laufzeit O(h) für diese Operationen Nur Einfügen/Löschen verändern Struktur des Baums Idee Wir brauchen Prozedur, um AVL-Eigenschaft nach Einfügen/Löschen wiederherzustellen.

47 Datenstrukturen Definition
Ein Baum heißt beinahe-AVL-Baum, wenn die AVL-Eigenschaft in jedem Knoten außer der Wurzel erfüllt ist und sich die Höhe der Unterbäume der Wurzel um höchstens 2 unterscheidet.

48 Datenstrukturen Unterproblem
Umformen eines beinahe-AVL-Baums in einen AVL-Baum mit Hilfe von Rotationen O.b.d.A.: Linker Teilbaum der Wurzel höher als der rechte

49 Datenstrukturen Fall 1 y x C h-1 A B h oder h-1 h

50 Datenstrukturen Fall 1 x y Rechtsrotation(T,y) y x C A h-1 h A B B C
h oder h-1 h oder h-1 h-1 h

51 Datenstrukturen Fall 2 y x C h-1 A B h-1 h

52 Datenstrukturen Fall 2 y x C h-1 A B h-1 h

53 Datenstrukturen Fall 2 y x C h-1 z A h-1 h-2 oder h-1 h-2 oder h-1 B‘

54 Datenstrukturen Fall 2 y y Linksrotation(T,x) z x C C h-1 h-1 x A z
B‘‘ h-2 oder h-1 h-1 A B‘ h-2 oder h-1 B‘‘ h-2 oder h-1 B‘ h-2 oder h-1 h-1

55 Datenstrukturen Fall 2 y z Rechtsrotation(T,y) z x y C h-1 x B‘‘ A B‘
h-2 oder h-1 A B‘ h-2 oder h-1 h-1

56 Datenstrukturen y Balance(T) 1. t  root[T]
2. if h[lc[t]] > h[rc[t]]+1 then if h[lc[lc[t]]]< h[rc[lc[t]]] then Linksrotation(lc[t]) Rechtsrotation(t) 6. else if h[rc[t]]> h[lc[t]]+1 then if h[rc[rc[t]]]< h[lc[rc[t]] then Rechtsrotation(rc[t]) Linksrotation(t) x C h-1 A B h oder h-1 h

57 Datenstrukturen y Balance(T) 1. t  root[T]
2. if h[lc[t]] > h[rc[t]]+1 then if h[lc[lc[t]]]< h[rc[lc[t]]] then Linksrotation(lc[t]) Rechtsrotation(t) 6. else if h[rc[t]]> h[lc[t]]+1 then if h[rc[rc[t]]]< h[lc[rc[t]] then Rechtsrotation(rc[t]) Linksrotation(t) x C h-1 A B h oder h-1 h

58 Datenstrukturen h gibt Höhe des Teilbaums an. Dies müssen wir zusätzlich in unserer Datenstruktur aufrecht erhalten. y Balance(T) 1. t  root[T] 2. if h[lc[t]] > h[rc[t]]+1 then if h[lc[lc[t]]]< h[rc[lc[t]]] then Linksrotation(lc[t]) Rechtsrotation(t) 6. else if h[rc[t]]> h[lc[t]]+1 then if h[rc[rc[t]]]< h[lc[rc[t]] then Rechtsrotation(rc[t]) Linksrotation(t) x C h-1 A B h oder h-1 h

59 Datenstrukturen y Balance(T) 1. t  root[T]
2. if h[lc[t]] > h[rc[t]]+1 then if h[lc[lc[t]]]< h[rc[lc[t]]] then Linksrotation(lc[t]) Rechtsrotation(t) 6. else if h[rc[t]]> h[lc[t]]+1 then if h[rc[rc[t]]]< h[lc[rc[t]] then Rechtsrotation(rc[t]) Linksrotation(t) x C h-1 A B h oder h-1 h

60 Datenstrukturen Balance(T) 1. t  root[T]
2. if h[lc[t]] > h[rc[t]]+1 then if h[lc[lc[t]]]< h[rc[lc[t]]] then Linksrotation(lc[t]) Rechtsrotation(t) 6. else if h[rc[t]]> h[lc[t]]+1 then if h[rc[rc[t]]]< h[lc[rc[t]] then Rechtsrotation(rc[t]) Linksrotation(t) Laufzeit: O(1) x y A B C

61 Datenstrukturen Kurze Zusammenfassung Einfügen
Wir können aus einem beinahe-AVL-Baum mit Hilfe von maximal 2 Rotationen einen AVL-Baum machen Dabei erhöht sich die Höhe des Baums nicht Einfügen Wir fügen ein wie früher Dann laufen wir den Pfad zur Wurzel zurück An jedem Knoten balancieren wir, falls der Unterbaum ein beinahe-AVL-Baum ist

62 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 Einfügen 2

63 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 Einfügen 2

64 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 Einfügen 2

65 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 Einfügen 2

66 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 Einfügen 2

67 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 Einfügen 2

68 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 Einfügen 2

69 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 nil Einfügen 2

70 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Neuen Knoten erzeugen. Zusätzlich noch Zeiger lc[t] und rc[t] auf nil setzen, sowie p[t] und den Zeiger von p[t] setzen. 8 5 9 3 6 2 Einfügen 2

71 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 2 Einfügen 2

72 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 2 Einfügen 2

73 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 2 Einfügen 2

74 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 2 Einfügen 2

75 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 8 5 9 3 6 2 Einfügen 2

76 Datenstrukturen AVL-Einfügen(t,x) 1. if t=nil then 2. t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) 5 3 8 2 6 9 Einfügen 2

77 Datenstrukturen Laufzeit AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Laufzeit O(h) = O(log n) 5 3 8 2 6 9 Einfügen 2

78 Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1.

79 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Induktion über die Höhe des Baumes. (I.A.): Für Bäume der Höhe -1 und 0 ist die Aussage korrekt.

80 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Induktion über die Höhe des Baumes. (I.A.): Für Bäume der Höhe -1 und 0 ist die Aussage korrekt. (I.V.): Der Satz gilt für Bäume der Höhe j, -1≤j≤h.

81 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Induktion über die Höhe des Baumes. (I.A.): Für Bäume der Höhe -1 und 0 ist die Aussage korrekt. (I.V.): Der Satz gilt für Bäume der Höhe j, -1≤j≤h. (I.S.): Betrachte den Aufruf von AVL-Einfügen in einem AVL-Baum der Höhe h+1≥0.

82 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Induktion über die Höhe des Baumes. (I.A.): Für Bäume der Höhe -1 und 0 ist die Aussage korrekt. (I.V.): Der Satz gilt für Bäume der Höhe j, -1≤j≤h. (I.S.): Betrachte den Aufruf von AVL-Einfügen in einem AVL-Baum der Höhe h+1≥0. Sei o.b.d.A. key[x]<key[t] (der andere Fall ist symmetrisch).

83 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Induktion über die Höhe des Baumes. (I.A.): Für Bäume der Höhe -1 und 0 ist die Aussage korrekt. (I.V.): Der Satz gilt für Bäume der Höhe j, -1≤j≤h. (I.S.): Betrachte den Aufruf von AVL-Einfügen in einem AVL-Baum der Höhe h+1≥0. Sei o.b.d.A. key[x]<key[t] (der andere Fall ist symmetrisch). Da h+1≥0 ist, wird Zeile (3) ausgeführt.

84 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Induktion über die Höhe des Baumes. (I.A.): Für Bäume der Höhe -1 und 0 ist die Aussage korrekt. (I.V.): Der Satz gilt für Bäume der Höhe j, -1≤j≤h. (I.S.): Betrachte den Aufruf von AVL-Einfügen in einem AVL-Baum der Höhe h+1≥0. Sei o.b.d.A. key[x]<key[t] (der andere Fall ist symmetrisch). Da h+1≥0 ist, wird Zeile (3) ausgeführt.

85 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Nach (I.V.) ist der Baum lc[t] nach Einfügen ein AVL-Baum mit Höhe r oder r+1, wobei r die Höhe vor dem Einfügen war.

86 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Nach (I.V.) ist der Baum lc[t] nach Einfügen ein AVL-Baum mit Höhe r oder r+1, wobei r die Höhe vor dem Einfügen war. Hat lc[t] nach dem Einfügen Höhe h oder h-1, so ist t ein AVL-Baum.

87 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Nach (I.V.) ist der Baum lc[t] nach Einfügen ein AVL-Baum mit Höhe r oder r+1, wobei r die Höhe vor dem Einfügen war. Hat lc[t] nach dem Einfügen Höhe h oder h-1, so ist t ein AVL-Baum. Hat lc[t] nach dem Einfügen Höhe h+1, so ist t u.U. ein beinahe-AVL-Baum.

88 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Nach (I.V.) ist der Baum lc[t] nach Einfügen ein AVL-Baum mit Höhe r oder r+1, wobei r die Höhe vor dem Einfügen war. Hat lc[t] nach dem Einfügen Höhe h oder h-1, so ist t ein AVL-Baum. Hat lc[t] nach dem Einfügen Höhe h+1, so ist t u.U. ein beinahe-AVL-Baum. Dies wird durch in Zeile 7 durch Balance korrigiert.

89 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Nach (I.V.) ist der Baum lc[t] nach Einfügen ein AVL-Baum mit Höhe r oder r+1, wobei r die Höhe vor dem Einfügen war. Hat lc[t] nach dem Einfügen Höhe h oder h-1, so ist t ein AVL-Baum. Hat lc[t] nach dem Einfügen Höhe h+1, so ist t u.U. ein beinahe-AVL-Baum. Dies wird durch in Zeile 7 durch Balance korrigiert. Außerdem erhöht Balance die Höhe nicht und verringert sie maximal um 1.

90 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Nach (I.V.) ist der Baum lc[t] nach Einfügen ein AVL-Baum mit Höhe r oder r+1, wobei r die Höhe vor dem Einfügen war. Hat lc[t] nach dem Einfügen Höhe h oder h-1, so ist t ein AVL-Baum. Hat lc[t] nach dem Einfügen Höhe h+1, so ist t u.U. ein beinahe-AVL-Baum. Dies wird durch in Zeile 7 durch Balance korrigiert. Außerdem erhöht Balance die Höhe nicht und verringert sie maximal um 1. Also hat der Baum nach dem Einfügen Höhe h+1 oder h+2.

91 Datenstrukturen Satz 39 Beweis AVL-Einfügen(t,x) 1. if t=nil then
t  new node(x); h[t]0 ; return 3. else if key[x]<key[t] then AVL-Einfügen(lc[t],x) 4. else if key[x]>key[t] then AVL-Einfügen(rc[t],x) 5. else return  Schlüssel schon vorhanden 6. h[t]  1 + max{h[lc[t]], h[rc[t]]} 7. Balance(t) Datenstrukturen Satz 39 Wird mit AVL-Einfügen ein Element in einen AVL-Baum der Höhe h eingefügt, so ist der resultierende Baum ein AVL-Baum der Höhe h oder h+1. Beweis Nach (I.V.) ist der Baum lc[t] nach Einfügen ein AVL-Baum mit Höhe r oder r+1, wobei r die Höhe vor dem Einfügen war. Hat lc[t] nach dem Einfügen Höhe h oder h-1, so ist t ein AVL-Baum. Hat lc[t] nach dem Einfügen Höhe h+1, so ist t u.U. ein beinahe-AVL-Baum. Dies wird durch in Zeile 7 durch Balance korrigiert. Außerdem erhöht Balance die Höhe nicht und verringert sie maximal um 1. Also hat der Baum nach dem Einfügen Höhe h+1 oder h+2.

92 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) 5 3 8 6 9

93 Datenstrukturen x bezeichnet Schlüssel des zu löschenden Elements.
AVL-Löschen(t,x) 1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Löschen(3) 5 3 8 6 9

94 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Löschen(3) 5 3 8 6 9

95 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Löschen(3) 5 3 8 6 9

96 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Und die anderen Zeiger aktualisieren Löschen(3) 5 nil 8 6 9

97 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Löschen(3) 5 nil 8 6 9

98 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Nichts zu tun, da Baum leer. Löschen(3) 5 nil 8 6 9

99 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Löschen(3) 5 8 6 9

100 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Löschen(3) 8 5 9 6

101 Datenstrukturen AVL-Löschen(t,x)
1. if x<key[t] then AVL-Löschen(lc[t],x) 2. else if x>key then AVL-Löschen(rc[t],x) 3. else if t=nil then return  x nicht im Baum 4. else if lc[t]=nil then ersetze t durch rc[t] 5. else if rc[t]=nil then ersetze t durch lc[t] 6. else u=MaximumSuche(lc[t]) Kopiere Informationen von u nach t AVL-Löschen(key[u],lc[t]) 9. h[t] = 1 + max{h[lc[t]], h[rc[t]]} 10. Balance(t) Löschen(3) 8 5 9 6

102 Datenstrukturen Korrektheit: Satz 40: Ähnlich wie beim Einfügen
Mit Hilfe von AVL-Bäumen kann man Suche, Einfügen, Löschen, Minimum und Maximum in einer Menge von n Zahlen in Q(log n) Laufzeit durchführen.

103 Datenstrukturen Zusammenfassung und Ausblick
Effiziente Datenstruktur für das Datenbank Problem mit Hilfe von Suchbäumen Kann man eine bessere Datenstruktur finden? Was muss man ggf. anders machen?


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

Ähnliche Präsentationen


Google-Anzeigen