Algorithmen und Datenstrukturen

Transkript

1 Algorithmen und Datenstrukturen Werner Struckmann Wintersemester 2005/06

2 6. Bäume 6.1 Bäume 6.2 Binäre Suchbäume 6.3 Ausgeglichene Bäume 6.4 Heapsort

3 Listen und Bäume Listen und Bäume: Listen: Jedes Listenelement besitzt genau einen Vorgänger und einen Nachfolger. Ausnahmen: Das erste Element besitzt keinen Vorgänger und das letzte keinen Nachfolger. Bäume (engl.: trees): Jedes Element besitzt genau einen Vorgänger und mehrere Nachfolger. Ausnahmen: Das erste Element besitzt keinen Vorgänger und die letzten Elemente keine Nachfolger. Anwendungen von Bäumen: Ausdrücke, Speicherung von Mengen, hierarchisch strukturierte Daten, z. B. Dateibäume, Sortieralgorithmen. 6.1 Bäume 6-1

4 Grundbegriffe Die Elemente eines Baums heißen Knoten. Das erste Element eines Baums ist die Wurzel. Die letzten Elemente werden Blätter genannt. Innere Knoten sind Elemente, die keine Blätter sind. Jeder Knoten kann einen Schlüssel und weitere Informationen speichern Bäume 6-2

5 Grundbegriffe Nachfolgerknoten werden auch Kindknoten und Vorgängerknoten Vaterknoten genannt. Bäume sind wie Listen dynamische Datenstrukturen. Knoten können eingefügt und gelöscht werden. Bäume sind wie Listen rekursive Datenstrukturen. Jeder Knoten kann als die Wurzel eines (Teil-)Baums angesehen werden Bäume 6-3

6 Pfade Ein Pfad in einem Baum ist eine Folge aufeinanderfolgender Knoten. Die Anzahl der Knoten eines Pfades minus 1 heißt dessen Länge. In jedem Baum gibt es von der Wurzel zu einem beliebigen Knoten genau einen Pfad. Jeder Baum ist zusammenhängend. Jeder Baum ist zyklenlos [17, 13, 16] ist der Pfad vom Knoten mit Schlüssel 17 zum Knoten mit Schlüssel 16. Die Länge dieses Pfades beträgt Bäume 6-4

7 Niveau und Höhe Die Länge des Pfades von der Wurzel zu einem Knoten heißt Niveau des Knotens. Knoten, die auf dem gleichen Niveau liegen, heißen Nachbarknoten. Die Höhe eines Baums ist das Maximum der Längen aller Pfade im Baum. Die Höhe eines Knotens ist definiert als das Maximum der Längen aller Pfade von diesem Knoten zu einem Blatt Niveau 0 Niveau 1 Niveau 2 Niveau 3 [11, 17, 13, 16] und [11, 5, 7, 6] sind die längsten Pfade. Da ihre Länge 3 beträgt, ist die Höhe des Baumes 3. Die Höhe von Knoten 5 ist Bäume 6-5

8 Spezielle Bäume Ist k Ndie Maximalzahl der Kinder eines Knotens, so spricht man von einem k-nären Baum. Beispiele: Binärbäume (binäre Bäume) sind 2-näre Bäume. Ternärbäume (ternäre Bäume) sind 3-näre Bäume. B-Bäume werden später behandelt. Sind die Kinder eines Knotens in einer definierten Weise geordnet, so spricht man von einem geordneten Baum. Beispiele: Binäre Suchbäume sind geordnete Binärbäume. Heaps werden später behandelt. 6.1 Bäume 6-6

9 Binärbäume Binärbäume sind 2-näre Bäume. Die maximale Anzahl von Kindern eines Knotens ist 2. Die Kinder eines Knotens bilden die Wurzeln des linken und des rechten Teilbaums des Knotens Höhe des Baumes: 3 Max. Anzahl Knoten: 15 Max. Anzahl Blätter: 8 Max. Anzahl innerer Knoten: Bäume 6-7

10 Binärbäume als abstrakter Datentyp type BinTree(T) import Bool operators empty : BinTree bin : BinTree T BinTree BinTree left : BinTree BinTree right : BinTree BinTree value : BinTree T empty? : BinTree Bool axioms t T, x, y BinTree left(bin(x, t, y)) = x right(bin(x, t, y)) = y value(bin(x, t, y)) = t empty?(empty) = true empty?(bin(x, t, y)) = false 6.1 Bäume 6-8

11 Eigenschaften binärer Bäume Bezeichnungen: Höhe des Baums: h Anzahl der Knoten: n In einem nichtleeren binären Baum gilt: Maximalzahl der inneren Knoten: 2 h 1 Maximalzahl der Blätter: 2 h h + 1 n 2 h+1 1 Folgerung: log 2 (n + 1) 1 h n 1 Das heißt: h liegt zwischen Θ(log(n)) und Θ(n). 6.1 Bäume 6-9

12 Traversierung eines Binärbaums Unter der Traversierung eines Binärbaums versteht man ein Verfahren, bei dem jeder Knoten eines Baums genau einmal besucht wird. Beim Tiefendurchlauf (engl.: depth-first-search, DFS) wird zuerst in die Tiefe und erst dann in die Breite gegangen. Man besucht von einem Knoten erst die Kindknoten und setzt dort das Verfahren rekursiv fort. Die Verfahren unterscheiden sich darin, wann der Knoten selbst bearbeitet wird. Inorder-Durchlauf Preorder-Durchlauf Postorder-Durchlauf Bei der Breitensuche (engl.: breadth-first-search, BFS) geht man von einem Knoten zuerst zu allen Nachbarknoten, bevor die Kindknoten besucht werden. 6.1 Bäume 6-10

13 Tiefendurchlauf Inorder-Durchlauf: linker Teilbaum, Knoten, rechter Teilbaum 2, 5, 6, 7, 11, 13, 16, 17, 22 Preorder-Durchlauf: Knoten, linker Teilbaum, rechter Teilbaum 11, 5, 2, 7, 6, 17, 13, 16, 22 Postorder-Durchlauf: linker Teilbaum, rechter Teilbaum, Knoten 2, 6, 7, 5, 16, 13, 22, 17, Bäume 6-11

14 Inorder-Durchlauf proc inorder(x) begin if x nil then inorder(left(x)); bearbeite(x); inorder(right(x)); fi; end 6.1 Bäume 6-12

15 Preorder- und Postorder-Durchlauf proc preorder(x) begin if x nil then bearbeite(x); preorder(left(x)); preorder(right(x)); fi; end proc postorder(x) begin if x nil then postorder(left(x)); postorder(right(x)); bearbeite(x); fi; end 6.1 Bäume 6-13

16 Breitendurchlauf 11 Levelorder-Durchlauf: 11, 5, 17, 2, 7, 13, 22, 6, Bäume 6-14

17 Levelorder-Durchlauf proc levelorder(x) begin var q: queue; enter(q,x); while not isempty(q) do y front(q); leave(q); bearbeite(y); if left(y) nil then enter(q,left(y)); if right(y) nil then enter(q,right(y)); od; end 6.1 Bäume 6-15

18 Binäre Suchbäume Der Wert eines Knotens ist ein eindeutiger Schlüssel aus einer Grundmenge. Die Grundmenge ist durch bzw.<total geordnet. Die Knoten enthalten zusätzliche Nutzdaten. Die Anordnung der Knoten im Baum basiert auf der Ordnungsrelation. root 11 Person 5 5 Person Person Person 2 Person 22 Person Person 16 Person 7 Person Binäre Suchbäume 6-16

19 Binäre Suchbäume Ein binärer Suchbaum ist ein Binärbaum, bei dem für jeden Knoten v, seinen linken Teilbaum b 1 und seinen rechten Teilbaum b 2 gilt: Für jeden Knoten v 1 aus b 1 ist v 1 < v und für jeden Knoten v 2 aus b 2 ist v 2 > v. 11 < 11 > Die Nutzdaten werden im Folgenden nicht betrachtet. 6.2 Binäre Suchbäume 6-17

20 Basisalgorithmen für binäre Suchbäume Suchen eines Knotens, Bestimmen des Minimums oder Maximums, Bestimmen des Nachfolgers oder Vorgängers eines Knotens, Einfügen eines Knotens, Löschen eines Knotens. Die Operationen müssen die Suchbaumeigenschaft aufrechterhalten. 6.2 Binäre Suchbäume 6-18

21 Suchen eines Knotens (rekursiv) > 5 7 < func search(x,k) begin if x = nil oder k = schlüssel(x) then return x; fi; if k < schlüssel(x) then return search(links(x),k); else return search(rechts(x),k); fi; end 6.2 Binäre Suchbäume 6-19

22 Suchen eines Knotens (iterativ) > 5 7 < func search(x,k) begin while x nil und k schlüssel(x) do if k < schlüssel(x) then x links(x); else x rechts(x);fi; od; return x; end 6.2 Binäre Suchbäume 6-20

23 Minimum und Maximum func minimum(x) begin while links(x) nil do x links(x); od; return x; end func maximum(x) begin while rechts(x) nil do x rechts(x);od; return x; end 6.2 Binäre Suchbäume 6-21

24 Nachfolger und Vorgänger Bestimmung des Nachfolgers (Knoten mit dem nächsthöheren Schlüssel) eines Knotens k: Falls k kein rechtes Kind hat, ist der Nachfolger der nächste Vorgänger von k, dessen linkes Kind k oder ein Vorgänger von k ist. Falls k das Maximum im Baum ist, existiert kein derartiger Vorgänger. Falls k ein rechtes Kind hat, ist der Nachfolger das Minimum im vom rechten Kind aufgespannten Teilbaum. Nachfolger von 7: Binäre Suchbäume 6-22

25 Nachfolger und Vorgänger func successor(x) begin if rechts(x) nil then return minimum(rechts(x)); fi; y vater(x); while y nil und x = rechts(y) do x y; y vater(y); od; return y; end Die Bestimmung des Vorgängers erfolgt analog. 6.2 Binäre Suchbäume 6-23

26 Einfügen eines Knotens Einfügen des Schlüssels 12: > < < Binäre Suchbäume 6-24

27 Einfügen eines Knotens proc insert(t, z): begin y nil; x wurzel(t); while x nil do y x; if schlüssel(z) < schlüssel(x) then x links(x); else x rechts(x);fi; od; vater(z) y; if y = nil then wurzel(t) z; else if schlüssel(z) < schlüssel(y) then links(y) z; else if schlüssel(z) > schlüssel(y) then rechts(y) z; else error( Doppelter Schlüssel ); fi; fi; fi; end 6.2 Binäre Suchbäume 6-25

28 Löschen eines Knotens Beim Löschen eines Knotens können 3 Fälle auftreten. Der Knoten hat keine Kinder: Er wird einfach gelöscht. Der Knoten hat ein Kind: Er wird ausgeschnitten Binäre Suchbäume 6-26

29 Löschen eines Knotens Der Knoten hat zwei Kinder: Aus dem rechten Teilbaum wird der Nachfolger bestimmt und dieser dort gelöscht. Dieser Nachfolger hat höchstens ein Kind. Der Nachfolger wird anstelle des zu löschenden Knotens verwendet. Alternativ kann der Vorgänger im linken Teilbaum genommen werden Binäre Suchbäume 6-27

30 Löschen eines Knotens func delete(t, z): Knoten begin if links(z) = nil oder rechts(z)=nil then y z; else y successor(z);fi; if links(y) nil then x links(y);else x rechts(y);fi; if x nil then vater(x) vater(y); fi; if vater(y) = nil then wurzel(t) x; else if y = links(vater(y)) then links(vater(y)) x; else rechts(vater(y)) x; fi; fi; if y z then schlüssel(z) schlüssel(y); kopiere Nutzdaten; fi; return y; end 6.2 Binäre Suchbäume 6-28

31 Laufzeiten der Basisalgorithmen Die Analyse der Algorithmen liefert den Satz: Die Laufzeiten der Algorithmen Suchen eines Knotens, Minimum, Maximum, Nachfolger, Vorgänger, Einfügen eines Knotens und Löschen eines Knotens liegen bei geeigneter Implementierung in der Zeit O(h), wobei h die Höhe des binären Suchbaums ist. 6.2 Binäre Suchbäume 6-29

32 Random-Tree-Analyse Annahmen: 1. Die Schlüssel sind paarweise verschieden. 2. Die Bäume entstehen durch Einfüge-, aber nicht durch Löschoperationen. 3. Jede der n! Permutationen der Eingabe ist gleichwahrscheinlich. Es gilt der Satz: Für die mittlere Knotentiefe P(n) in einem zufällig erzeugten binären Suchbaum gilt P(n) = O(log(n)). Es gilt sogar schärfer der Satz: Die erwartete Höhe eines zufällig erzeugten binären Suchbaums mit n Schlüsseln ist O(log(n)). Beweis: s. Cormen et al., S Binäre Suchbäume 6-30

33 Gestaltsanalyse Satz: Für die Anzahl b n der strukturell verschiedenen Binärbäume gilt: b n = 1 ( ) 2n 1, falls n = 0, = n + 1 n n 1 k=0 b k b n 1 k, falls n>0. Annahmen: 1. Die Schlüssel sind paarweise verschieden. 2. Jeder der b n Binärbäume ist gleichwahrscheinlich. Satz: Der mittlere Abstand eines Knotens von der Wurzel eines Binärbaums mit n Knoten ist O ( n ). Beweis: s. Ottmann/Widmayer, S Binäre Suchbäume 6-31

34 Ausgeglichene Bäume Höhe des Binärbaums: h Anzahl der Knoten: n Es gilt: log 2 (n+1) 1 h n Binäre Suchbäume können zu Listen entarten : Ausgeglichene Bäume 6-32

35 Ausgeglichene Bäume Definition: M sei eine Klasse von Bäumen. Für T M sei n(t) die Knotenzahl und h(t) die Höhe von T. M heißt ausgeglichen (ausgewogen), wenn die beiden folgenden Bedingungen erfüllt sind: 1. Ausgeglichenheitsbedingung: c> 0 T M : h(t) c log n(t). 2. Rebalancierungsbedingung: Falls eine Einfüge- oder Löschoperation, ausgeführt in einem Baum T M, einen unausgeglichenen Baum T M erzeugt, dann soll es möglich sein, T mit Zeitaufwand O(log n) zu einem Baum T M zu rebalancieren. 6.3 Ausgeglichene Bäume 6-33

36 AVL-Bäume Definition: Ein binärer Suchbaum ist ein AVL-Baum, wenn für jeden Knoten p des Baums gilt, dass sich die Höhe des linken Teilbaums von der Höhe des rechten Teilbaums von p höchstens um 1 unterscheidet. G. M. Adelson-Velskii, E. M. Landis (1962) 6.3 Ausgeglichene Bäume 6-34

37 AVL-Bäume Ein AVL-Baum: Kein AVL-Baum: Ausgeglichene Bäume 6-35

38 AVL-Bäume Satz: Es sei ein beliebiger AVL-Baum der Höhe h mit n Knoten gegeben. Dann gilt h< log 2 (n+2) Die Klasse der AVL-Bäume erfüllt daher die Ausgeglichenheitsbedingung. Wir werden gleich sehen, dass sie auch die Rebalancierungsbedingung erfüllt. Damit gilt: Satz: Die Klasse der AVL-Bäume ist ausgeglichen. 6.3 Ausgeglichene Bäume 6-36

39 Basisalgorithmen für AVL-Bäume Da die Höhe h eines AVL-Baums durch h< log 2 (n + 2) beschränkt ist, liegen die Laufzeiten der Algorithmen Suchen eines Knotens, Minimum, Maximum, Nachfolger und Vorgänger in O(log n). 6.3 Ausgeglichene Bäume 6-37

40 Einfügen in AVL-Bäume 1. Wenn der einzufügende Schlüssel noch nicht im Baum vorkommt, endet die Suche in einem Blatt. Der Schlüssel wird dort wie bisher eingefügt. 2. Danach kann die AVL-Eigenschaft eines inneren Knotens k verletzt sein. 3. Wir unterscheiden abhängig von der aufgetretenen Stelle die folgenden Fälle: 1. Einfügen in linken Teilbaum des linken Kindes von k, 2. Einfügen in rechten Teilbaum des linken Kindes von k, 3. Einfügen in rechten Teilbaum des rechten Kindes von k, 4. Einfügen in linken Teilbaum des rechten Kindes von k. Die Fälle 1 und 3 sowie die Fälle 2 und 4 sind symmetrisch. Die Rebalancierung erfolgt durch so genannte Rotationen bzw. Doppelrotationen. 6.3 Ausgeglichene Bäume 6-38

41 Einfügen in AVL-Bäume Fall 1: Einfügen in den linken Teilbaum des linken Kindes y -2 x 0 x -1 c Rotation a y 0 Einfügen a b b c Rotiert wird hier das linke Kind nach rechts. Fall 3 läuft spiegelbildlich ab. 6.3 Ausgeglichene Bäume 6-39

42 Einfügen in AVL-Bäume Fall 2: Einfügen in den rechten Teilbaum des linken Kindes z -2 y 0 x +1 Doppelrotation x 0/-1 z 0/+1 y a d a b c d Einfügen b c Es hat eine Doppelrotation mit dem linken Kind nach links und bzgl. des Vaters nach rechts stattgefunden. Fall 4 läuft spiegelbildlich ab. 6.3 Ausgeglichene Bäume 6-40

43 Einfügen in AVL-Bäume RR LR Ausgeglichene Bäume 6-41

44 Einfügen in AVL-Bäume LR LR Ausgeglichene Bäume 6-42

45 Einfügen in AVL-Bäume DR r/l RR 4 LR Ausgeglichene Bäume 6-43

46 Einfügen in AVL-Bäume 1. Fall Einfügen in linken Teilbaum des linken Kindes: Rechtsrotation 2. Fall Einfügen in rechten Teilbaum des linken Kindes: Doppelrotation, links/rechts 3. Fall Einfügen in rechten Teilbaum des rechten Kindes: Linksrotation 4. Fall Einfügen in linken Teilbaum des rechten Kindes: Doppelrotation, rechts/links 6.3 Ausgeglichene Bäume 6-44

47 Löschen in AVL-Bäumen 1. Der Schlüssel wird wie bisher gesucht und gelöscht. 2. Danach kann die AVL-Eigenschaft eines Knotens verletzt sein. 3. Durch Rotationen kann die Ausgeglichenheit erreicht werden, allerdings wird dadurch u. U. die AVL-Eigenschaft weiter oben im Baum verletzt. Die Balance muss also ggf. rekursiv bis zur Wurzel wiederhergestellt werden. Da für die Höhe h des Baums h< log 2 (n + 2) gilt, bleibt die Rebalancierungsbedingung erfüllt Löschen von 5 2 Rechtsrotation Ausgeglichene Bäume 6-45

48 Rot-Schwarz-Bäume Ein Rot-Schwarz-Baum ist ein binärer Suchbaum, in dem jeder Knoten über ein Zusatzbit zur Speicherung einer Farbe (rot oder schwarz) verfügt. Idee: Durch Einschränkungen bei der Färbung der Knoten auf den Pfaden von der Wurzel zu einem Blatt wird sichergestellt, dass jeder Pfad, der in der Wurzel beginnt, maximal doppelt so lang ist, wie jeder andere solche Pfad. Für nicht vorhandene Kind-Knoten, wird ein spezieller Null-Knoten als Kind eingefügt Null Null Null Null Null Null Null Null Null Null Null Null Null Null Null Null 6.3 Ausgeglichene Bäume 6-46

49 Rot-Schwarz-Bäume Die Bedingungen an einen Rot-Schwarz-Baum lauten: 1. Jeder Knoten ist entweder rot oder schwarz. 2. Die Wurzel ist schwarz. 3. Jedes Blatt (Null-Knoten) ist schwarz. 4. Wenn ein Knoten rot ist, so sind beide Kinder schwarz. 5. Für jeden Knoten p gilt, dass alle Pfade vom Knoten zu einem Blatt die selbe Anzahl schwarzer Knoten beinhalten Null Null Null Null Null Null Null Null Null Null Null Null Null Null Null Null 6.3 Ausgeglichene Bäume 6-47

50 Rot-Schwarz-Bäume Die gemäß Bedingung 5 eindeutig bestimmte Zahl wird Schwarzhöhe bh(p) eines Knotens p genannt. Hierbei wird p selbst nicht mitgezählt. bh(8) = bh(12) = bh(11) = Null Null Null Null Null Null Null Null Null Null Null Null Null Null Null Null 6.3 Ausgeglichene Bäume 6-48

51 Rot-Schwarz-Bäume Satz: Es sei ein beliebiger Rot-Schwarz-Baum der Höhe h mit n Knoten gegeben. Dann gilt h< 2 log 2 (n + 1). Die Klasse der Rot-Schwarz-Bäume erfüllt daher die Ausgeglichenheitsbedingung. Wir werden gleich sehen, dass sie auch die Rebalancierungsbedingung erfüllt. Damit gilt: Satz: Die Klasse der Rot-Schwarz-Bäume ist ausgeglichen. 6.3 Ausgeglichene Bäume 6-49

52 Basisalgorithmen für Rot-Schwarz-Bäume Da die Höhe h eines Rot-Schwarz-Baums durch h< 2 log 2 (n + 1) beschränkt ist, liegen die Laufzeiten der Algorithmen Suchen eines Knotens, Minimum, Maximum, Nachfolger und Vorgänger in O(log n). 6.3 Ausgeglichene Bäume 6-50

53 Einfügen in Rot-Schwarz-Bäume 1. Einfügen eines Schlüssels mit bisherigem Algorithmus. 2. Der neue Knoten wird rot und erhält zwei Null-Knoten als Kinder. 3. Danach kann die Rot-Schwarz-Eigenschaft verletzt sein: 3.1 Jeder Knoten ist entweder rot oder schwarz. Wird nicht verletzt. 3.2 Die Wurzel ist schwarz. Wird verletzt, falls in den leeren Baum eingefügt wird. Der neue Knoten wird dann schwarz gefärbt. 3.3 Jedes Blatt ist schwarz. Wird nicht verletzt. 3.4 Wenn ein Knoten rot ist, so sind beide Kinder schwarz. Nicht durch k verletzt, da beide Kinder schwarze Null-Knoten sind. Die Eigenschaft wird verletzt, falls k als Kind eines roten Vaterknotens eingefügt wird. 3.5 Für jeden Knoten gilt, dass alle Pfade vom Knoten zu einem Blatt die selbe Anzahl schwarzer Knoten beinhalten. Da nur ein roter Knoten hinzukommt, wird diese Eigenschaft nicht verletzt. 6.3 Ausgeglichene Bäume 6-51

54 Einfügen in Rot-Schwarz-Bäume Maßnahmen, die die Rot-Schwarz-Eigenschaft 4 wiederherstellen: Links-, Rechts- und Doppel-Rotationen zwecks Höhenausgleich. Dabei gibt die Einfärbung der Knoten Aufschluss über die notwendigen Rotationen. Korrektur der Einfärbung der falsch eingefärbten Knoten. Die Einfärbung wird in Richtung der Wurzel korrigiert, wodurch ein Dienst zum Zugriff auf den Vaterknoten eines Knotens nötig wird. Dieser sei im Folgenden mit parent(k) beschrieben. Sechs Fälle sind zu unterscheiden: 1. parent(k) ist linkes Kind von parent(parent(k)) 1.1 Der Onkel von k ist rot. 1.2 Der Onkel von k ist schwarz und k ist rechtes Kind. 1.3 Der Onkel von k ist schwarz und k ist linkes Kind. 2. parent(k) ist rechtes Kind von parent(parent(k)): analog. 6.3 Ausgeglichene Bäume 6-52

55 Einfügen in Rot-Schwarz-Bäume Fall 1.1: Der Onkel von k ist rot: y y w z Umfärben w z a x k d e a x k d e b c b c Knoten y kann ebenfalls wieder Kind eines roten Knotens sein (erneute Verletzung der Eigenschaft 4). In diesem Fall wird für y rekursiv die Eigenschaft 4 wiederhergestellt. Da die Wurzel schwarz ist, terminiert das Verfahren. Der Fall, dass k linkes Kind von parent(k) ist, wird analog behandelt. 6.3 Ausgeglichene Bäume 6-53

56 Einfügen in Rot-Schwarz-Bäume Fall 1.2: Der Onkel von k ist schwarz und k ist rechtes Kind: y y w z Linksrotation x z a x k d e w c d e b c a b Durch Linksrotation entsteht Fall Ausgeglichene Bäume 6-54

57 Einfügen in Rot-Schwarz-Bäume Fall 1.3: Der Onkel von k ist schwarz und k ist linkes Kind: y x x z Rechsrotation Umfärben w y w k c d e a b c z a b d e Es wird eine Rechtsrotation und eine Umfärbung durchgeführt. 6.3 Ausgeglichene Bäume 6-55

58 B-Bäume Der Zugriff auf den Primärspeicher (RAM, Hauptspeicher) ist bezüglich der Zugriffszeit billig, wohingegen der Zugriff auf den Sekundärspeicher (Festplatte) teuer ist, vor allem dann, wenn das Auslesen der Daten eine Änderung der Position des Lesekopfes nötig macht oder der Beginn des einzulesenden Bereiches abgewartet werden muss. Daher ist es sinnvoll, zusammenhängende Daten, auf die komplett zugegriffen wird, möglichst beieinander liegend zu speichern. Diese Idee kann man auf Suchbäume übertragen. 6.3 Ausgeglichene Bäume 6-56

59 B-Bäume B-Bäume sind ausgeglichene geordnete k-näre Suchbäume, deren Knoten maximal k 1 Schlüssel tragen können und auf maximal k Kindknoten verweisen. B-Bäume sind nicht binär, das B steht für balanced Ausgeglichene Bäume 6-57

60 B-Bäume Ein 2t-närer Baum T heißt B-Baum der Ordnung t, t 2, wenn er die folgenden Eigenschaften erfüllt: 1. Jeder Knoten x besitzt die folgenden Felder bzw. Funktionen: n(x) ist die Anzahl der in Knoten x gespeicherten Schlüssel die n(x) Schlüssel sind in aufsteigender Weise geordnet: key 1 (x) key 2 (x) key n(x) (x) leaf(x) ist eine boolesche Funktion, die angibt, ob x ein Blatt ist. 2. Jeder innere Knoten x trägt n(x)+1 Zeiger c 1 (x), c 2 (x),...,c n(x)+1 (x) auf seine Kindknoten. 3. Die Schlüssel key i (x) unterteilen die in den Teilbäumen gespeicherten Werte. Sei treekeys(y) die Menge aller in einem B-Baum mit Wurzel y gespeicherten Schlüssel, so gilt für 1 i n(x): v i treekeys(c i (x)), v i+1 treekeys(c i+1 (x)) : v i key i (x) v i Ausgeglichene Bäume 6-58

61 B-Bäume 4. Jedes Blatt hat das gleiche Niveau. Es entspricht der Höhe h des Baums. 5. Die Ordnung t 2 legt die obere und die untere Grenze der Anzahl der Schlüssel und der Kindknoten eines Knotens fest: Jeder Knoten mit Ausnahme der Wurzel hat wenigstens t 1 Schlüssel. Jeder innere Knoten mit Ausnahme der Wurzel hat wenigstens t Kindknoten. Ist der Baum nicht leer, so trägt die Wurzel mindestens einen Schlüssel. Jeder Knoten trägt maximal 2t 1 Schlüssel. Damit hat jeder innere Knoten höchstens 2t Kinder. Ein Knoten heißt voll, wenn er genau 2t 1 Schlüssel trägt. Es gilt: t 1 n(x) 2t 1 für alle Knoten mit Ausnahme der Wurzel und t #Kinder von x 2t für alle inneren Knoten mit Ausnahme der Wurzel. 6.3 Ausgeglichene Bäume 6-59

62 B-Bäume Beispiel: B-Baum der Ordnung 3 50 Wurzel k Blatt Blatt Blatt Für alle Knoten x mit Ausnahme der Wurzel gilt: 3 1 = 2 n(x) = 5. Für alle inneren Knoten mit Ausnahme der Wurzel gilt: 3 #Kinder von x 2 3 = 6 Der Knoten k ist voll, sein rechter Bruder nicht. Es gibt insgesamt 11 Blätter, die alle das Niveau 2 haben. 6.3 Ausgeglichene Bäume 6-60

63 B-Bäume Alle Pfade von der Wurzel bis zu den Blättern sind in einem B-Baum gleich lang. Typischerweise werden B-Bäume hoher Ordnung benutzt. Die Knoten enthalten dadurch sehr viele Werte, die Höhe des Baumes ist aber gering. B-Bäume werden im Zusammenhang mit Datenbanken zum Beispiel für Indizierungen verwendet. Die Anzahl der Knoten eines Niveaus nimmt bei einem vollständigen B-Baum der Ordnung t exponentiell zur Basis 2t zu: Jeder Knoten hat 2t Kinder, auf Niveau n befinden sich (2t) n Knoten. Die Ordnung t eines B-Baumes wird auch als minimaler Grad bezeichnet. 6.3 Ausgeglichene Bäume 6-61

64 B-Bäume Wie für die binären Suchbäume ist die Laufzeit (und damit die Anzahl der Festplattenzugriffe) für die meisten B-Baum-Operationen abhängig von der Höhe des Baums. Satz: Ist n 1 die Anzahl der Schlüssel eines B-Baumes der Höhe h der Ordnung t, so gilt ( ) n+1 h log t Ausgeglichene Bäume 6-62

65 Suchen in B-Bäumen Suche in B-Bäumen kombiniert die Suche in binären Suchbäumen mit der Suche in Listen. Jeder Knoten muss dazu durch einen Festplattenzugriff erst in den Speicher geladen werden, bevor er bearbeitet werden kann. Um einen Schlüssel k zu suchen: 1. Lies den Wurzelknoten x ein. 2. Vergleiche in x beginnend mit i = 1 jeden Schlüssel key i (k) mit k bis ein Wert key i (x) k oder i = n(x) ist. 2.1 Ist k = key i (x), dann liefere Knoten x und Index i zurück und beende die Suche. 2.2 Ist k key i (x) und x ein Blatt, so ist der Schlüssel nicht enthalten, und die Suche ist fehlgeschlagen. 2.3 Ist key i (x)>k bzw. key i (x)<k und i = n(x), so lies Knoten c i (x) bzw. c i+1 (x) ein und fahre mit Schritt 2 fort. 6.3 Ausgeglichene Bäume 6-63

66 Suchen in B-Bäumen Suchen des Buchstabens Q in B-Bäumen der Ordnung 3: N Q > N C K Q < S S W A B D E F H L M O Q R T V X Y Z Q = Q Q > O Suche erfolgreich N Q > N C K Q < S S W A B D E F H L M O P R T V X Y Z Q < R Q > O Q > P Suche fehlgeschlagen 6.3 Ausgeglichene Bäume 6-64

67 Suchen in B-Bäumen 1. Die Suche innerhalb eines Knotens erfolgt linear und ist beendet, wenn ein Schlüssel größer oder gleich dem gesuchten Schlüssel ist oder alle n(x) Werte des Knotens betrachtet worden sind. In einem B-Baum der Ordnung t ist n(x) 2t. Daher liegt die Laufzeit dieser lokalen Suche in O(t). 2. Wird der Schlüssel in einem inneren Knoten nicht gefunden, so wird der nächste Knoten in Richtung der Blätter bearbeitet. Die Anzahl der besuchten Knoten (die Anzahl der Festplattenzugriffe) ist damit abhängig von der Höhe h des Baumes. Sie liegt nach obigem Satz in Θ(h) = Θ(log t n). 3. Die Laufzeit des gesamten Algorithmus liegt also in O(t h) = O(t log t n). 6.3 Ausgeglichene Bäume 6-65

68 Einfügen in B-Bäume Das Einfügen eines Wertes in einen B-Baum der Ordnung t ist komplizierter als bei binären Suchbäumen: Suche analog zum binären Suchbaum zuerst ein Blatt, in dem der Wert gespeichert werden kann. Sollte das Blatt vor dem Einfügen bereits voll gewesen sein, so verstößt der Baum danach gegen die B-Baum-Definition. Der übervolle Knoten wird in zwei Knoten am Median des ursprünglichen Knotens aufgeteilt. Beispiel: B-Baum der Ordnung 3 S C K S X Y Einfügen von W C K W X Y 6.3 Ausgeglichene Bäume 6-66

69 Einfügen in B-Bäume Der neue Vaterknoten muss in den ursprünglichen Vaterknoten integriert werden, wodurch wiederum die B-Baum-Eigenschaft verletzt sein kann. In Richtung Wurzel ist demnach solange jeder entstehende übervolle Knoten aufzuteilen, bis spätestens ein neuer Vater die neue Wurzel des Baumes bildet. Das beschriebene Verfahren durchläuft den Baum ggf. zweimal: Erst wird der Baum in Richtung eines Blattes durchsucht, der Knoten eingefügt und dann in Richtung der Wurzel korrigiert. Ein effizienteres Verfahren, dass den Baum nur einmal durchläuft, teilt auf dem Suchpfad in Richtung des Zielblattes vorsorglich jeden vollen Knoten auf und fügt zum Schluss den Wert in einen Knoten ein, der noch nicht voll ist (One-Pass-Verfahren). 6.3 Ausgeglichene Bäume 6-67

70 Einfügen in B-Bäume Beispiel: B-Baum der Ordnung 3 C F K Q S L K H T V K C F L Q S C F H L Q S T V W M R N K S K S C F H L Q T V W C F H L M N Q R T V W P K N S C F H L M P Q R T V W 6.3 Ausgeglichene Bäume 6-68

71 Einfügen in B-Bäume A B X Y K N S A B C F H L M P Q R T V W X Y D C K N S A B D F H L M P Q R T V W X Y Z C K N S W A B D F H L M P Q R T V X Y Z 6.3 Ausgeglichene Bäume 6-69

72 Einfügen in B-Bäume E C K N S W ohne One-Pass-Verfahren A B D E F H L M P Q R T V X Y Z E N mit One-Pass-Verfahren C K S W A B D E F H L M P Q R T V X Y Z 6.3 Ausgeglichene Bäume 6-70

73 Löschen in B-Bäumen Um einen Schlüssel in einem B-Baum der Ordnung t zu löschen: Suche den Knoten x, in dem der Schlüssel k = key i (x) gelöscht werden soll. Wird der Schlüssel aus dem betreffenden Knoten x entfernt, so können mehrere Fälle auftreten, von denen wir uns nur drei beispielhaft ansehen: 1. x ist ein Blatt und trägt mehr als t 1 Schlüssel. Dann kann der Schlüssel einfach gelöscht werden. 6.3 Ausgeglichene Bäume 6-71

74 Löschen in B-Bäumen 2. x ist ein Blatt, trägt die minimale Anzahl von t 1 Schlüsseln und ein Bruder b von x trägt mindestens t Schlüssel. Dann findet vor dem Löschen eine Rotation des kleinsten bzw. größten Schlüssels von b mit dem Schlüssel des Vaterknotens statt, dessen Teilbäume b und x sind. K N S K P S F H L M P Q R T V Löschen von M F H L N Q R T V 6.3 Ausgeglichene Bäume 6-72

75 Löschen in B-Bäumen 3. x ist ein Blatt und trägt die minimale Anzahl von t 1 Schlüsseln. Gleiches gilt für beide Brüder. Dann findet eine Verschmelzung von x und einem Bruder b statt, wobei der Schlüssel des Vaterknotens, dessen Teilbäume b und x sind, in der Mitte des neuen Knoten zwischen den Werten von x und b gespeichert wird. Dabei kann der Vaterknoten die kritische Größe t 1 Schlüssel unterschreiten. Ggf. muss also rekursiv nach oben verschmolzen werden K N S N S F H L M P Q R T V Löschen von H F K L M P Q R T V 6.3 Ausgeglichene Bäume 6-73

76 Löschen in B-Bäumen Die anderen Fälle werden ähnlich behandelt. Es erfolgt vor dem Löschen evtl. ein Zusammenfügen oder ein Aufspalten einzelner Knoten. Dabei muss ggf. rekursiv vorgegangen werden. Man kann zeigen, dass die Laufzeit der beiden Algorithmen zum Einfügen und Löschen ebenfalls in O(t log t n) liegt. Einzelheiten kann und sollte man in der Literatur (zum Beispiel Cormen et al., S ) nachlesen. 6.3 Ausgeglichene Bäume 6-74

77 Überblick Heapsort ist ein Sortieralgorithmus, der ein gegebenes Feld in-place sortiert. Heapsort verwendet eine auf Binärbäumen basierende Datenstruktur, den binären Heap. Das zu sortierende Feld wird dabei als ausgeglichener binärer Baum aufgefasst, der bis auf die Ebene der Blätter vollständig gefüllt ist. Die Ebene der Blätter ist von links bis zu einem Endpunkt gefüllt. In dem Binärbaum gilt nicht die Suchbaumeigenschaft, sondern die Heap-Eigenschaft. 6.4 Heapsort 6-75

78 Heaps Ein binärer Max-Heap ist ein Binärbaum, bei dem der Schlüssel eines Vaterknotens größer oder gleich den Schlüsseln seiner Kindknoten ist. Die Schlüssel der Kinder stehen untereinander in keiner Beziehung. Beim Heapsort wird das zu sortierende Feld a mit der Indexmenge 1...n im Bereich 1...h, h n, (Heap-Size) als binärer Heap interpretiert: a[1] ist die Wurzel des Baumes. left(k) = 2k ist der Index des linken Kindes des Knotens k. right(k) = 2k + 1 ist der Index des rechten Kindes des Knotens k. parent(k) = k ist der Index des Vaters des Knotens k. 2 a.size = n ist die Gesamtlänge des Felds. a.heapsize = h ist die Länge des Heaps. 6.4 Heapsort 6-76

79 Heaps In einem Max-Heap gilt die Max-Heap-Eigenschaft: k {2,...,h}.a[parent(k)] a[k] D. h., die Schlüssel der Kinder eines Knotens sind kleiner oder gleich dem Schlüssel des Vaterknotens. n = 9 h = Heapsort 6-77

80 Heapsort Der Algorithmus benötigt 3 Methoden: Max-Heapify: stellt die Max-Heap-Eigenschaft für einen Teilbaum sicher. Build-Max-Heap: konstruiert ausgehend von einem unsortierten Feld einen Max-Heap. Heapsort: sortiert ein ungeordnetes Feld in-place. 6.4 Heapsort 6-78

81 Max-Heapify Max-Heapify bekommt eine Referenz auf das Feld a übergeben, in dem ggf. die Heap-Eigenschaft an nur einer Stelle verletzt ist. Außerdem einen Index k, der denjenigen Knoten in a angibt, der die Heap-Eigenschaft verletzt. Die Teilbäume unterhalb von k verletzen die Heap-Eigenschaft nach Voraussetzung nicht. Max-Heapify stellt die Heap-Eigenschaft her. 6.4 Heapsort 6-79

82 Max-Heapify Heapsort 6-80

83 Max-Heapify proc Max-Heapify(a: <Referenz auf T[]>; k: int) begin var max: int; max k; if left(k) a.heapsize&& a[left(k)] > a[max] then max left(k); fi; if right(k) a.heapsize&& a[right(k)] > a[max] then max right(k); fi; if k max then swap(a[k],a[max]); Max-Heapify(a, max); fi; end 6.4 Heapsort 6-81

84 Max-Heapify Alle Operationen in Max-Heapify bis auf den rekursiven Aufruf sind in O(1) implementierbar. Falls ein rekursiver Aufruf erfolgt, dann nur auf Knoten, die unterhalb von k liegen. Die Aufruffolge ist daher durch die Höhe des von k aufgespannten Teilbaums nach oben begrenzt. Da auch der Teilbaum vollständig ist, liegt die Laufzeit von Max-Heapify innerhalb von O(log n). 6.4 Heapsort 6-82

85 Build-Max-Heap Build-Max-Heap erhält als Eingabe eine Referenz auf ein unsortiertes Feld und stellt sicher, dass im gesamten Feld die Max-Heap-Eigenschaft gilt. Dies geschieht, indem Max-Heapify auf alle Knoten angewendet wird. Da Max-Heapify erwartet, dass die Teilbäume unterhalb eines Knotens die Heap-Eigenschaft erfüllen, muss vom Ende des Felds begonnen werden. Alle inneren Knoten des Heaps liegen im Bereich n Auf diese Knoten muss also Max-Heapify angewendet werden. 6.4 Heapsort 6-83

86 Build-Max-Heap proc Build-Max-Heap(a: <Referenz auf T[]>) begin var i: int; a.heapsize a.length; for i a.length/2 downto 1 do Max-Heapify(a, i); od; end 6.4 Heapsort 6-84

87 Build-Max-Heap Iteration Iteration Iteration Heapsort 6-85

88 Build-Max-Heap Iteration Iteration Heapsort 6-86

89 Build-Max-Heap Der Aufruf von Max-Heapify liegt jeweils in O(log n), Max-Heapify wird O(n)-mal aufgerufen, daher ergibt sich eine Laufzeit innerhalb von O(n log n). Allerdings ist eine genauere Abschätzung möglich: Es gilt, dass ein Heap mit n Elementen die Höhe ld(n) hat und dass höchstens n 2 h+1 Knoten die Höhe h haben. h=0 h 2 h = 2 ld(h) h=0 n 2 h+1 ld(h) O(h) = O n h=0 h = O n 2 h h=0 h = O(n) 2 h Build-Max-Heap hat also eine lineare Laufzeit. 6.4 Heapsort 6-87

90 Heapsort Eingabe für Heapsort ist ein Referenzparameter auf ein unsortiertes Feld a, Ausgabe ist das sortierte Feld a. Der Algorithmus arbeitet folgendermaßen: 1. Konstruiere einen Max-Heap. 2. Vertausche das erste Element (Wurzel, größtes Element) und das letzte Element (Blatt ganz rechts) des Heaps. 3. Reduziere den Max-Heap um das Blatt ganz rechts. 4. Wende Max-Heapify auf die Wurzel an. 5. Solange Blätter vorhanden und nicht gleich der Wurzel sind, fahre mit Schritt 2 fort. 6.4 Heapsort 6-88

91 Heapsort proc Heapsort(a: <Referenz auf T[]>) begin var i: int; Build-Max-Heap(a); for i a.lengthdownto 2 do swap(a[1],a[i]); a.heapsize a.heapsize- 1; Max-Heapify(a, 1); od; end Die Laufzeit von Heapsort liegt in O(n log n). 6.4 Heapsort 6-89

92 Heapsort 12 1 Heap MaxHeapify swap Heapsort 6-90

93 Heapsort MaxHeapify swap MaxHeapify swap, MaxHeapify Heapsort 6-91

94 Heapsort MaxHeapify swap,maxheapify Array Heapsort 6-92

95 Prioritätswarteschlangen Heaps können nicht nur zum Sortieren benutzt werden, sondern auch für weitere Anwendungen. Eine wollen wir jetzt betrachten. Eine Max-Prioritätswarteschlange ist eine Datenstruktur zur Speicherung einer Menge S, deren Elementen ein Schlüssel (Priorität) zugeordnet ist. Prioritätswarteschlangen besitzen die folgenden Operationen: maximum(s) gibt das Element von S mit dem maximalen Schlüssel zurück. extract-max(s) entfernt aus S das maximale Element. increase-key(s,x,k) erhöht den Schlüssel von x auf k. insert(s,x) fügt x in S ein. Max-Prioritätswarteschlangen können effizient durch Max-Heaps implementiert werden. 6.4 Heapsort 6-93

96 Prioritätswarteschlangen proc maximum(s) begin return S[1]; end proc extract-max(s) begin if heap-groesse(s) < 1 then error fi; max S[1]; S[1] S[heap-groesse(S)]; heap-groesse(s) heap-groesse(s)-1; Max-Heapify(S,1); return max; end 6.4 Heapsort 6-94

97 Prioritätswarteschlangen proc increase-key(s,x,k) begin if k < S[x] then error fi; S[x] k; while x > 1 S[vater(x)]<S[x] do swap (S[x],S[vater(x)]); x vater(x); od; end proc insert(s,x) begin heap-groesse(s) heap-groesse(s)+1; S[heap-groesse(S)] ; increase-key(s,heap-groesse(s),k); end 6.4 Heapsort 6-95

98 Prioritätswarteschlangen Die Laufzeiten der vier Operationen für Prioritätswarteschlangen der Größe n liegen in O(log n). Analog zu Max-Heaps und Max-Prioritätswarteschlangen lassen sich Min-Heaps und Min-Prioritätswarteschlangen definieren. 6.4 Heapsort 6-96