Algorithmen und Datenstrukturen II

Transkript

1 Algorithmen und Datenstrukturen II und Red-Black-Trees Dr. Georg Sauthoff 1 AG Praktische Informatik July 1, SoSe gsauthof@techfak.uni-bielefeld.de

2 Suchbäume (Indexdatenstrukturen) Zugriff in O(logn) Baum muss balanciert (ausgeglichen) sein Heute: Red-Black-Trees

3 Suchbäume (Indexdatenstrukturen) Zugriff in O(logn) Baum muss balanciert (ausgeglichen) sein Heute: Baumstruktur hard-wired Red-Black-Trees Muss ggf. durch Rotationen gefixt werden

4 Datenstruktur zur Sortierung von Schlüsseln Nicht zu verwechseln mit: Speicherverwaltungs-Heap

5 Datenstruktur zur Sortierung von Schlüsseln Voraussetzung: totale Ordnung auf den Schlüsseln Nicht zu verwechseln mit: Speicherverwaltungs-Heap Aufbau: O(n)

6 Datenstruktur zur Sortierung von Schlüsseln (Hinter einem Schlüssel kann ein Datensatz stehen) Nicht zu verwechseln mit: Speicherverwaltungs-Heap Aufbau: O(n) Einfügen: O(log n)

7 Datenstruktur zur Sortierung von Schlüsseln Nicht zu verwechseln mit: Speicherverwaltungs-Heap Aufbau: O(n) Einfügen: O(log n) ort: O(n log n)

8 Datenstruktur zur Sortierung von Schlüsseln Nicht zu verwechseln mit: Speicherverwaltungs-Heap Aufbau: O(n) Einfügen: O(log n) ort: O(n log n) in-place wie Insert-Sort worst-case Laufzeit wie Merge-Sort

9 Heap Array von Schlüsseln organisiert als Binärer Baum Jeder Knoten erfüllt die Heap-Eigenschaft

10 Heap Array von Schlüsseln organisiert als Binärer Baum Jeder Knoten erfüllt die Heap-Eigenschaft Definition (Heap-Eigenschaft) wobei i einen Knoten bezeichnet key(parent(i)) key(i) (1)

11 Heap Array von Schlüsseln organisiert als Binärer Baum Jeder Knoten erfüllt die Heap-Eigenschaft Definition (Heap-Eigenschaft) wobei i einen Knoten bezeichnet Binary Max-Heap key(parent(i)) key(i) (1)

12 Wiederholung Effiziente Verwaltung in einem Array A: A 0 ist der Wurzel-Knoten left(i) = 2i + 1 right(i) = 2i + 2 parent(i) = i 1 2, i > 0

13 Wiederholung Effiziente Verwaltung in einem Array A: A 0 ist der Wurzel-Knoten left(i) = 2i + 1 right(i) = 2i + 2 parent(i) = i 1 2, i > 0 height(a, x) = maximale Anzahl von Kannten bis zu einem Blatt height(a, x) = 0 falls isleaf (x) height(a) = height(a, 0) = log n, wenn A balanciert maxsize(a, h) = 2 h n 2 h+1 = # Knoten auf Level h max

14 Wiederholung Indices

15 Wiederholung Indices, left i 2i

16 Wiederholung Indices, left i 2i + 1, right i 2i

17 Wiederholung Indices, left i 2i + 1, right i 2i + 2, parent i i

18 Wiederholung

19 Heapify Voraussetzung Eingabe ist ein Knoten x, wobei isheap(h, left(x)) = isheap(h, right(x)) = true (2)

20 Heapify Voraussetzung Eingabe ist ein Knoten x, wobei isheap(h, left(x)) = isheap(h, right(x)) = true (2) Top-Down rekursiv Array-Elemente vertauschen wenn Heap-Eigenschaft verletzt ist

21 Heapify 1 c l a s s Heap { 2 p r i v a t e T a r r a y [ ] ; 3 p r i v a t e i n t l e n g t h ; 4 5 p r i v a t e T key ( i n t i ) ; 6 p r i v a t e void swap ( i n t i, i n t j ) ; 7 p r i v a t e void r e s i z e ( ) ; p u b l i c void h e a p i f y ( i n t i ) ; }

22 Heapify 1 void h e a p i f y ( i n t i ) 2 { 3 i n t x = i ; 4 i f ( l e f t ( i ) < l e n g t h 5 && key ( l e f t ( i ) ) > key ( i ) ) 6 x = l e f t ( i ) ; 7 i f ( r i g h t ( i ) < l e n g t h 8 && key ( r i g h t ( i ) ) > key ( x ) ) 9 x = r i g h t ( i ) ; 10 i f ( x == i ) 11 return ; 12 swap ( i, x ) ; 13 h e a p i f y ( x ) ; 14 }

23 Effizienz Anzahl der Rekursiven Aufrufe: height(0)

24 Effizienz Anzahl der Rekursiven Aufrufe: height(0) Laufzeit in O(log n) Speicher in O(n)

25 Effizienz Anzahl der Rekursiven Aufrufe: height(0) Laufzeit in O(log n) Speicher in O(n) Funktionsstack?

26 Effizienz Anzahl der Rekursiven Aufrufe: height(0) Laufzeit in O(log n) Speicher in O(n) Funktionsstack? Tail-Rekursion

27 Build Bottom-Up iterativer Aufruf von Heapify

28 Build Bottom-Up iterativer Aufruf von Heapify Beginnend mit 1-er 1 void b u i l d ( a r r a y a ) 2 { 3 a r r a y = a ; 4 l e n g t h = a r r a y. s i z e ( ) ; 5 i f ( l e n g t h == 0) return ; 6 // f o r ( i n t i = l e n g t h 1; i >=0; i ) 7 f o r ( i n t i = l e n g t h /2 1; i >=0; i ) 8 h e a p i f y ( i ) 9 }

29 Build-Laufzeit O(n log n) (3)

30 Build-Laufzeit Aber die Schranke ist zu großzügig: log n n 2 h+1 O(h) = O n h=0 O(n log n) (3) log n h=0 h = O(n) (4) 2 h

31 Sortierung Priority-Queue

32 ort Aufbau Heap

33 ort Aufbau Heap Tausch erstes und letztes Element

34 ort Aufbau Heap Tausch erstes und letztes Element length dekrementieren

35 ort Aufbau Heap Tausch erstes und letztes Element length dekrementieren root heapifizieren

36 Priority-Queue get-max O(1) extract-max O(log n) insert O(log n) increase-key O(log n)

37 get-max trivial

38 extract-max ersten mit letztem Knoten vertauschen length dekrementieren (neuen root) heapifizieren

39 extract-max ersten mit letztem Knoten vertauschen length dekrementieren (neuen root) heapifizieren 1 node extract_max ( ) 2 { 3 i f ( l e n g t h == 0) 4 throw RuntimeError ( " Heap i s empty " ) ; 5 swap ( 0, l e n g t h ) ; 6 h e a p i f y ( 0 ) ; 7 return a r r a y [ l e n g t h ] ; 8 }

40 Insert Array um 1 vergrößern Knoten an die letzte Stelle speichern Knoten nach oben tauschen, bis die Heap-Eigenschaft nicht mehr verletzt ist Bottom-Up 1 void i n s e r t ( node o ) 2 { 3 r e s i z e ( ) ; 4 i n t i = l e n g t h ; 5 a r r a y [ l e n g t h ++] = o ; 6 w h i l e ( i > 0) 7 i f ( key ( i ) > key ( p a r e n t ( i ) ) ) { 8 swap ( i, p a r e n t ( i ) ) ; 9 i = p a r e n t ( i ) ; 10 } 11 }

41 Sortierung

42 Sortierung gute Quicksort Implementierung; hat geringere konstante Laufzeitfaktoren in der Praxis

43 Sortierung gute Quicksort Implementierung; hat geringere konstante Laufzeitfaktoren in der Praxis Priority-Queue

44 Sortierung gute Quicksort Implementierung; hat geringere konstante Laufzeitfaktoren in der Praxis Priority-Queue beispielsweise Job-Scheduling

45 Red-Black-Trees Binary Search Tree Balenced d.h. ein RB-Tree wird ausbalanciert

46 Red-Black-Trees Binary Search Tree Balenced d.h. ein RB-Tree wird ausbalanciert Blätter sind Nil-Marker und speichern keine Schlüssel en:

47 Red-Black-Trees Binary Search Tree Balenced d.h. ein RB-Tree wird ausbalanciert Blätter sind Nil-Marker und speichern keine Schlüssel en: In-Memory Index-Strukturen Maps, assoziative Arrays (z.b. C++ STL map, Java TreeMap)

48 Red-Black-Trees Binary Search Tree Balenced d.h. ein RB-Tree wird ausbalanciert Blätter sind Nil-Marker und speichern keine Schlüssel en: In-Memory Index-Strukturen Maps, assoziative Arrays (z.b. C++ STL map, Java TreeMap) Definition (Red-Black-Tree) Ein Binärer-Suchbaum ist ein Red-Black-Tree, wenn jeder Knoten x die Red-Black-Eigenschaften erfüllt.

49 Red-Black-Tree Beispiel nil 5 8 nil nil nil nil

50 Red-Black-Eigenschaften Definition (Red-Black-Eigenschaften) Jeder Knoten x in einem Red-Black-Tree erfüllt folgende Eigenschaften: 1 color(x) {red, black} 2 isroot(x) color(x) = black 3 isleaf (x) color(x) = black key(x) = nil 4 color(x) = red color(left(x)) = color(right(x)) = black 5 {blacknodes(p) l leaves(x), p path(x, l)} = 1

51 Höhe Beobachtung Bei einem Red-Black-Tree der Höhe h ist die Anzahl der roten Knoten auf einem Pfad maximal h/2.

52 Höhe Beobachtung Bei einem Red-Black-Tree der Höhe h ist die Anzahl der roten Knoten auf einem Pfad maximal h/2. Lemma (RB-Höhe) Die Höhe h von einem Red-Black-Tree mit n internen Knoten ist 2 log(n + 1).

53 Höhe Beweis-Skizze Wenn alle Knoten schwarz sind folgt dies direkt aus der 2. RB-Eigenschaft ( blackheight(root) = log n)

54 Höhe Beweis-Skizze Wenn alle Knoten schwarz sind folgt dies direkt aus der 2. RB-Eigenschaft ( blackheight(root) = log n) Sonst: Die Längen der Pfade zu den Blättern können sich nur durch rote Knoten unterscheiden

55 Höhe Beweis-Skizze Wenn alle Knoten schwarz sind folgt dies direkt aus der 2. RB-Eigenschaft ( blackheight(root) = log n) Sonst: Die Längen der Pfade zu den Blättern können sich nur durch rote Knoten unterscheiden Maximal-Anzahl von roten Knoten ist bekannt

56 Höhe Beweis-Skizze Wenn alle Knoten schwarz sind folgt dies direkt aus der 2. RB-Eigenschaft ( blackheight(root) = log n) Sonst: Die Längen der Pfade zu den Blättern können sich nur durch rote Knoten unterscheiden Maximal-Anzahl von roten Knoten ist bekannt Pfad-Länge l im Intervall: blackheight(root) l 2blackheight(root)

57 Effizienz Direkte Folgerung aus dem Lemma:

58 Effizienz Direkte Folgerung aus dem Lemma: Lookup/Insert/Delete in O(log n)

59 Insert Knoten x wie in einen BST einfügen (O(log n)), color(x) = red

60 Insert Knoten x wie in einen BST einfügen (O(log n)), color(x) = red Beobachtung Ein neu eingefügter Knoten ist ein Blatt.

61 Insert Knoten x wie in einen BST einfügen (O(log n)), color(x) = red Beobachtung Ein neu eingefügter Knoten ist ein Blatt. Nun kann eine der Red-Black-Eigenschaften verletzt sein welche?

62 Insert Knoten x wie in einen BST einfügen (O(log n)), color(x) = red Beobachtung Ein neu eingefügter Knoten ist ein Blatt. Nun kann eine der Red-Black-Eigenschaften verletzt sein welche? Falls ja, RB-Tree korrigieren (O(log n))

63 Rotationen a x b y c Rechts- Rotation um y Links- Rotation um x a x b y c

64 Rotationen a x b y c Rechts- Rotation um y Links- Rotation um x a x b y c Beobachtung Rotation verändert nicht den in-order key-string.

65 Insert-Fixup Fallunterscheidung color(parent(x)) = black Elter-Knoten ist rot fixen: Großelter-Knoten hat einen Geschwister-Knoten rechts Großtante-Knoten ist rot (Fall 1) Großtante-Knoten ist schwarz Knoten hat Geschwister-Knoten links (Fall 2) Knoten hat Geschwister Knoten links oder rechts (Fall 2+3)

66 Insert-Fixup Fallunterscheidung color(parent(x)) = black Elter-Knoten ist rot fixen: Großelter-Knoten hat einen Geschwister-Knoten rechts Großtante-Knoten ist rot (Fall 1) Großtante-Knoten ist schwarz Knoten hat Geschwister-Knoten links (Fall 2) Knoten hat Geschwister Knoten links oder rechts (Fall 2+3) Großelter-Knoten hat einen Geschwister-Knoten links (symmetrisch) Großtante-Knoten ist rot Großtante-Knoten ist schwarz Knoten hat Geschwister-Knoten rechts Knoten hat Geschwister Knoten links oder rechts

67 Insert-Fixup Fallunterscheidung color(parent(x)) = black Elter-Knoten ist rot fixen: Großelter-Knoten hat einen Geschwister-Knoten rechts Großtante-Knoten ist rot (Fall 1) Großtante-Knoten ist schwarz Knoten hat Geschwister-Knoten links (Fall 2) Knoten hat Geschwister Knoten links oder rechts (Fall 2+3) Großelter-Knoten hat einen Geschwister-Knoten links (symmetrisch) Großtante-Knoten ist rot Großtante-Knoten ist schwarz Knoten hat Geschwister-Knoten rechts Knoten hat Geschwister Knoten links oder rechts Bottom-Up RB-Eigenschaft wiederherstellen

68 Beispiel: Fall 1 (Nil-Blätter nicht dargestellt)

69 Beispiel: Fall 1 (Nil-Blätter nicht dargestellt)

70 Beispiel: Fall 1 (Nil-Blätter nicht dargestellt) Farben vertauschen, 2-level Bottom-Up 4. RB-Eigenschaft verletzt

71 Beispiel: Fall

72 Beispiel: Fall

73 Beispiel: Fall Links Rotation um x 4. RB-Eigenschaft verletzt

74 Beispiel: Fall 3a

75 Beispiel: Fall 3a

76 Beispiel: Fall 3a Farbentausch 2. RB-Eigenschaft verletzt

77 Beispiel: Fall 3b

78 Beispiel: Fall 3b

79 Beispiel: Fall 3b Rechts-Rotation um parent(parent(x)) fertig