15. Bäume Algorithmen und Datenstrukturen 15. Bäume 15.1 15.2 15.3 Suchbäume Menge als Suchbaum AVL-Bäume Prof. Dr. Michael Philippsen Department Informatik • Martensstraße 3 • 91058 Erlangen Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-2 15.1 Suchbäume 15.1 Suchbäume Effizientes Suchen Beispiel Grundgedanke: Kombiniere Offenheit der verketteten Liste mit Aufwand O(log2n) des Teile-und-Herrsche-Prinzips. Bäume kann man sich als strukturelles Abbild des Teile-undTeile und Herrsche-Prinzips vorstellen, wenn man beim Zugriff jeweils pro Knoten nur ein Kind weiterverfolgt. Eine solche Datenstruktur in Form eines Baums wird Suchbaum genannt. Ein binärer Suchbaum hat max. zwei Kinder je Knoten: v Wert e<v Wert e>v Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-3 © Michael Philippsen 4 7 13 14 20 24 38 Binärer Suchbaum 2 1 h=2 0 4 14 7 24 13 20 38 Die Höhe h eines Knotens entspricht der Anzahl Bei Graphen wird der Kanten des längsten Pfades zu einem von im Allg. eine diesem Knoten aus erreichbaren Blatt (= Knoten andere Def. der ohne Nachfolger). Höhe verwendet. Die Höhe h eines Baums ist die Höhe der Wurzel. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-4 1 15.1 Suchbäume 15.1 Suchbäume Klassifikation von Suchbäumen Anzahl m der Kinder pro Knoten/Knotengrad: □ Binärbaum: Anzahl 0 ≤ m ≤ 2 □ Vielwegbaum: Anzahl beliebig Speicherort der Nutzdaten: □ Blattbaum/hohler Baum: Nutzdaten werden nur in den Blattknoten gespeichert. Innere Knoten dienen nur der Verzweigung. □ Natürlicher Baum: Nutzdaten werden bei jedem Knoten gespeichert. Übliche Verwendung Zur Implementierung von Mengen im Hauptspeicher werden üblicherweise natürliche und ausgewogene Binärbäume verwendet. verwendet Zur Implementierung von Mengen auf Hintergrundspeicher präferiert man hohle und ausgewogene Vielwegbäume. mehr dazu in der Vorlesung „Datenbanksysteme“ Ausgewogenheit/Ausgeglichenheit: □ Ausgewogener/ausgeglichener/balancierter Baum: Für alle Knoten gilt: Die Höhen aller ihrer Unterbäume unterscheiden sich höchstens um ∆ (meistens ±1) Höhenbalance Vollständig ausgewogen: Die Höhe des Baumes ist log(n). □ Nicht ausgewogener Baum: Keine derartige Einschränkung. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-5 Zur Erinnerung: aus Abschnitt „12.6 Binärbaum“ Signatur BinBaum(T) □ □ □ □ □ □ create: bin: l ft left: right: value: empty: BinBaum x T x BinBaum BinBaum Bi B BinBaum BinBaum BinBaum BinBaum BinBaum Bi B BinBaum BinBaum T Boolean Axiome: □ □ □ □ □ A1: A2: A3: A4: A5: left(bin(x,b,y)) = x right(bin(x,b,y)) = y value(bin(x,b,y)) = b empty(create) = true empty(bin(x,b,y)) = false Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-7 © Michael Philippsen Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-6 Zur Erinnerung: aus Abschnitt „12.6 Binärbaum“ Signatur SuchBaum(T), T mit Ordnungsrelation: □ create: BinTree □ insert: T x BinTree BinTree □ find: find T x BinTree Bool □ delete T x BinTree BinTree Signaturen bin, left, right, value und empty des (normalen) Binärbaums werden verborgen. Ein ADT-Benutzer kann nur mit insert und delete auf dem Baum arbeiten arbeiten. Zur Implementierung von insert und delete können die Signaturen des normalen Binärbaums verwendet werden, solange sichergestellt ist, dass sowohl insert als auch delete die Eigenschaft „binärer Suchbaum“ erhält. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-8 2 15.2 Menge als Suchbaum 15.2 Menge als Suchbaum Die eigentliche Funktionalität zur Manipulation der Menge findet sich in der Klasse TreeSet<Type>, die als Datenstruktur einen Binärbaum verwendet: Imperative Impl. einer Menge im Hauptspeicher Binärer Suchbaum mit Knotenklasse Entry: Speicherung der Mengenelemente in den Baumknoten. class Entry { Entry left; // linker Nachfolger Entry right; // rechter Nachfolger Entry parent; // Elternknoten Type value; Doppelte Verzeigerung: parent // Nutzdaten public Entry(Type o, Entry parent) { left = right = null; value = o; this.parent = parent; } } public class TreeSet<Type extends Comparable<Type>> implements java.util.Set<Type> { // Wurzel des Binärbaums Entry root; parent public TreeSet() { root = null; } ... left right nicht für alle Verwendungen nötig; aber vieles (z.B. Iterator) wird leichter Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-9 15.2 Menge als Suchbaum Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-10 15.2 Menge als Suchbaum Rekursive Suche Suchen eines Elements Suche 13 13<14 daher Abstieg nach links 7<13 daher Abstieg nach rechts public boolean contains(Object o) { return treeContains(o, root); } 14 7 4 24 13 20 38 // Element suchen durch Abstieg im Baum private boolean treeContains(Object o, Entry node) { if (node == null) return false; int result = node.value.compareTo((Type)o); 5 Das minimale Element befindet sich immer „ganz links“ im Baum. while (node.left != null) { node = node.left } return node.value; Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-11 © Michael Philippsen // redundant if (result == 0) return true; if (result > 0) { return treeContains(o, node.left); } else { return treeContains(o, node.right); } zusammenfassen mit Hilfsvariable Hilfsvariable, Rechtsrekursion, Transformation in iterative Form } Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-12 3 15.2 Menge als Suchbaum 15.2 Menge als Suchbaum Iterative Suche Einfügen eines Elements Grundidee am Beispiel des Einfügens von public boolean contains(Object o) { Entry node = root; while hil ( (node d ! != null) ll) { int result = node.value.compareTo((Type)o); if (result == 0) return true; if (result > 0) { Effizienter: Typwandlung nur node = node.left; einmal vor der Schleife. } else { node = node.right; } } return false; } Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-13 12<14 daher Abstieg nach links 7<12 daher Abstieg nach rechts 12<13 daher neuer li k N linker Nachfolger hf l 12 Implementierung wie Suche. Wenn dabei 14 der einzufügende Wert gefunden wird false 7 24 Sonst: Neuen Knoten 4 13 20 38 als neuen Nachfolger des letzten Blatts ein12 t tragen. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-14 15.2 Menge als Suchbaum 15.2 Menge als Suchbaum Iteratives Einfügen Einfügen eines Elements Grundidee am Beispiel des Einfügens von 12 public boolean containsadd(Type o) { if (root == null) { // Sonderfall Einf. in leeren Baum root = new Entry(o, null); return t t true; } Entry node = root; Entry schlepp = null; // Schleppzeiger int result = 0; while (node != null) { result = node.value.compareTo(o); if (result == 0) return truefalse; schlepp = node; // zeigt auf letzten Knoten if (result > 0) node = node.left; else node = node.right; } // schlepp zeigt auf Blatt, an das anzuhängen ist. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-15 © Michael Philippsen node 14 schlepp --node 7 schlepp 14 node 13 schlepp 7 node --schlepp hl 13 14 7 4 24 13 20 38 node == null beendet Schleife Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-16 4 15.2 Menge als Suchbaum 15.2 Menge als Suchbaum Iteratives Einfügen Löschen eines Elements // schlepp zeigt auf Blatt, an das anzuhängen ist. // Neuen Knoten an Blatt anfügen. Entry y neu = new Entry(o, y schlepp); pp if (result > 0) { // result hat Ergebnis des letzten Vergl. schlepp.left = neu; } else { schlepp.right = neu; } return falsetrue; 1. Suche (wie oben) den zu löschenden Knoten im Baum 2. Entfernen des Knotens: nicht gezeigt: Suche □ Fall F ll 1 1: Lö Löschen h von Bl Blattknoten ttk t schlepp node } Übung: implementieren Sie das Einfügen rekursiv. Berechnung der Kinderlosigkeit setzt nebenbei die Variable kind (für den Fall 2). Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-17 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-18 15.2 Menge als Suchbaum 15.2 Menge als Suchbaum Fall 2: Löschen von Knoten mit nur einem Nachfolger Löschen eines Blattknotens am Beispiel schlepp node 14 7 4 14 24 13 20 7 38 4 kind 24 13 20 12 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-19 © Michael Philippsen mit Schleppzeiger. ... Entry kind = node.left; if (kind == null) { kind = node.right; } if (kind == null) { // node ist kinderlos if (schlepp.left == node) { schlepp.left = null; } else { schlepp.right = null; } node.parent = null; return true; } else if ... 38 ... else if ( (node.left == null) || (node.right == null)) { // node hat genau ein Kind ki d kind.parent t = schlepp; hl adjustParentship(node, kind); return true; } ... // Elterneintrag von zu löschendem Eintrag anpassen. private void adjustParentship(Entry oldparent, Entry kid) { if ( (oldparent p == root) ) { root = kid; } else if (oldparent.parent.left == oldparent) { oldparent.parent.left = kid; // node LinksKind v.schlepp } else { // kid LinksKind v.schlepp oldparent.parent.right = kid; // node RechtsKind v.schlepp } } // kid neues RechtsKind Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-20 5 15.2 Menge als Suchbaum 15.2 Menge als Suchbaum Fall 3: Löschen von inneren Knoten mit 2 Nachfolgern Löschen eines Knotens mit Einzelkind am Beispiel Beispiel: Lösche Knoten 24 14 14 7 4 24 13 14 20 7 38 4 7 24 12 20 4 38 24 13 6 12 16 15 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-21 15.2 Menge als Suchbaum 14 4 24 13 6 16 15 20 23 21 Keines der Blätter 38 31 6 15 21 31 21 40 33 Bedingungen für Ersatz x von Knoten 24 : (da rechter Nachfolger von 14) □ x ≥ 14 □ 20 ≤ x ≤ 38 □ 23 ≤ x ≤ 31 40 (da 20 linker und 38 rechter Nachfolger wird) (da 23 größter Nachfolger von 20 und 31 kleinster Nachfolger von 38 ist) (da 20 linker und 38 rechter Nachfolger wird) (da 23 größter Nachfolger von 20 und 31 kleinster Nachfolger von 38 ist) mögliche Lösung 14 33 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-23 © Michael Philippsen 23 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-22 33 passt! p 40 Bedingungen für Ersatz x von Knoten 24 : □ x ≥ 14 (da rechter Nachfolger von 14) □ 20 ≤ x ≤ 38 □ 23 ≤ x ≤ 31 38 15.2 Menge als Suchbaum Welcher Knoten tritt an die Stelle von 24 ? 7 20 Wäh d es iin d Während den Fäll Fällen 1 und d2 klar war, was zu tun ist und nur das Zeiger-Umhängen technische Mühe gemacht hat, braucht man hier eine Idee: Was macht man mit den zwei Nachfolgern des zu löschenden Knotens? 7 4 24 13 6 16 15 20 23 21 14 lösche 24 7 4 38 31 33 40 23 13 6 16 20 21 38 31 15 40 33 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-24 6 15.2 Menge als Suchbaum 15.2 Menge als Suchbaum Bedingungen für Ersatz x von Knoten 24 : (da rechter Nachfolger von 14) □ x ≥ 14 □ 20 ≤ x ≤ 38 □ 23 ≤ x ≤ 31 4 andere Lösung 6 16 15 20 23 31 21 7 4 38 40 33 linker Unterbaum 14 lösche 24 24 13 Ersetze zu löschenden Knoten durch den größten Knoten im linken Unterbaum (folgender Code) oder durch den kleinsten Knoten im rechten Unterbaum (beide haben maximal einen Nachfolger). (da 20 linker und 38 rechter Nachfolger wird) (da 23 größter Nachfolger von 20 und 31 kleinster Nachfolger von 38 ist) 14 7 Allgemein 31 13 6 20 23 16 15 38 33 40 21 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-25 15.2 Menge als Suchbaum Fall 3: Löschen von Knoten mit zwei Nachfolgern ... schlepp Entry maxLeft = node.left; node d Wertkopie evtl.: maxLeft if (maxLeft.right == null) { // Sonderfall: linker Nachf. von node // hat selbst keinen rechten Nachfolger // Übung! (Benötigt adjustParentship) } else { while (maxLeft.right != null) { maxLeft = maxLeft.right; } // Umhängen des evtl. linken Nachfolgers if (maxLeft.left != null) { maxLeft.parent.right L ft t i ht = maxLeft.left; L ft l ft maxLeft.left.parent = maxLeft.parent; } else { maxLeft.parent.right = null; } node.value = maxLeft.value; } ... Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-27 © Michael Philippsen zu löschender Knoten größter Knoten im linken Teilbaum, hat max. einen Nachfolger Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-26 15.2 Menge als Suchbaum Aufwandsbetrachtung Suchen: Bei Ausgewogenheit spiegelt der Suchbaum die Binärsuche strukturell wider. □ Suchen in O(Höhe) = O(log2n) bei ausgewogenen Bäumen. Einfügen: add() entspricht einem Einfügeschritt in einer Sortierprozedur mit O(log2n). Wiederholtes Einfügen ist daher effektiv eine Sortierprozedur mit einem Aufwand in O(n·log2n) bei n Elementen (man spricht von Baumsortieren). □ Einfügen in O(Höhe) = O(log2n) bei ausgewogenen Bäumen. Löschen: □ Löschen in O(Höhe) = O(log2n) bei ausgewogenen Bäumen. Lesen in Sortierreihenfolge: next() leistet dies bei der Traversierung. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-28 7 Zur Erinnerung aus „10.1 Charakterisierung von Aufwänden“ Zur Erinnerung aus „10.1 Charakterisierung von Aufwänden“ Suchbäume – Einfügereihenfolge bedingt Aussehen Suchbäume – Einfügereihenfolge bedingt Aussehen 5 4 3 2 Höhenunterschiede aller Unterbäume, z.B. 5 Knoten 5: h(4)=2, h(4) 2, h(null) h(null)=-1 1 ±3 4 nicht ausgewogener Baum 4 2 5 3 4 2 5 3 2 4 3 5 2 4 3 Höhenunterschiede aller Unterbäume, z.B. Knoten 4: h(2)=1 h(2)=1, h(5)=0 ±1 Knoten 2: h(null)=-1, h(3)=0 ±1 Ausgewogener Baum, da rechte und linke Unterbäume stets etwa die gleiche Höhe (max. ±1) haben. Sogar vollständig ausgewogener Baum. Höhenunterschiede aller Unterbäume, z.B. Knoten 4: h(3)=0, h(5)=0 0 Knoten 2: h(null)=-1, h(4)=1 ±2 nicht ausgewogener Baum. 5 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-29 extremer Fall, da vorsortierte Eingabe. Suchen, Einfügen und Löschen haben Aufwand O(n). 3 2 4 3 2 5 4 3 5 ausgewogener Baum. vollständig ausgewogener Baum. 2 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-30 15.3 AVL-Bäume 15.3 AVL-Bäume Ausgewogenheit bei Bäumen Ziel: Herstellen von Ausgewogenheit: Möglichkeit 1: Reorganisation: Alle Elemente aus einem unausgewogenen Baum B auslesen, l di diese d dann so umordnen, d dass die neu sortierte Folge beim Einfügen in einen frischen Baum Ausgewogenheit liefert. aufwändig Bestimmung der Höhe eines Knotens Möglichkeit 2: Ausgewogenheit schon bei jedem Einfügen eines Elements durch lokalen Umbau des Baums sichern. besser Balancefaktor eines Knotens v = Differenz zwischen der Höhe des linken Unterbaums und der Höhe des rechten Unterbaums. 3/0 Höhe/Balancefaktor 2/0 1/1 Baum nicht ausgewogen! 2/-2 1/-1 1/ 1 1/1 0/0 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-31 © Michael Philippsen Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-32 8 15.3 AVL-Bäume 15.3 AVL-Bäume Bestimmung der Höhe eines Knotens Bestimmung der Höhe eines Knotens Induktionsannahme: Höhe und Balancefaktor eines Blattes sind 0 Induktionshypothese: Höhe und Balancefaktoren von Binärbäumen mit <n Knoten können berechnet werden werden. Induktionsschluss: □ Betrachte die Wurzel eines Baums mit n Knoten. □ Die Unterbäume haben <n Knoten. Laut Induktionshypothese können deren Höhen und Balancefaktoren berechnet werden. □ Die Höhe der Wurzel lässt sich dann bestimmen: Höhe der Wurzel = 1+max(Höhe ( linker Unterbaum,, Höhe rechter Unterbaum) Balancefaktor d. Wurzel: Höhe linker Unterbaum - Höhe rechter Unterbaum Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-33 Aufwandsüberlegung: Berechnung für den ganzen Baum: □ Di Die resultierende lti d rekursive k i IImplementierung l ti steigt t i t bi bis zu d den Blätt Blättern ab und berechnet dann Höhe und Balancefaktoren „von unten nach oben“ im Baum. □ Jeder Knoten wird dabei einmal besucht: O(n) Korrektur bei einer Änderung: □ Nimmt man an einem Blatt eine Änderung vor (Hinzufügen eines neuen Nachfolgers, oder Löschen des Blatts), dann ändern sich die Höhenangaben und Balancefaktoren nur auf den Knoten, die auf dem Pfad von der Änderungsstelle zur Wurzel liegen. □ Die Korrektur nach einer Änderung hat daher bei ausgewogenen Bäumen den Aufwand O(log2n). Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-34 15.3 AVL-Bäume 15.3 AVL-Bäume Korrektur bei einer Änderung AVL-Bäume AVL-Bedingung: 3/0 === 3/0 Höhe/Balancefaktor 2/1 2/0 === 1/1 von der Änderung b t ff betroffene Baumteile B t il | h(e.links) - h(e.rechts) | ≤ 1 2/-2 0/0 === 1/-1 □ Sei e beliebiger Knoten eines binären Suchbaumes, und h(e) die Höhe des Unterbaums mit Wurzel e, e dann gilt für die beide Kinder e.links und e.rechts von e: 1/1 Ein binärer Suchbaum mit dieser Eigenschaft heißt AVL-Baum (nach Adel’son-Vel’skii und Landis, 1962), erste Datenstruktur, die im schlechtesten Fall einen Aufwand O(log2n) für Einfügen, Löschen und Suchen hatte. 0/0 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-35 © Michael Philippsen Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-36 9 15.3 AVL-Bäume 15.3 AVL-Bäume AVL-Bäume sind nicht immer vollständig ausgewogen. Beispiel: 5 3 2 4 1 -erfüllt AVL-Eigenschaft -nicht nicht vollständig ausgewogen 8 11 6 7 10 Operationen auf AVL-Bäumen □ Suchen: wie bei binärem Suchbaum □ Einfügen: Z ä h t wie Zunächst i b beii bi binärem ä S Suchbaum hb Dann Wiederherstellen der AVL-Eigenschaft Rebalancierung □ Löschen: Zunächst wie bei binärem Suchbaum Dann Wiederherstellen der AVL-Eigenschaft (eventuell mehrfach). 12 9 Rebalancierung Für die Höhe h eines AVL-Baums mit n Knoten gilt: log2(n+1) ≤ h < 1,441 log2(n+2) Im Vergleich zum vollständig ausgewogenen Binärbaum (mit minimaler Höhe) ist der AVL-Baum also höchstens ~44% höher. Alle Operationen bleiben daher vom Aufwand in O(log2n). Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-37 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-38 15.3 AVL-Bäume 15.3 AVL-Bäume Einfügen in AVL-Bäume Einfügen in AVL-Bäume 1. Einfügen wie in „normale“ binäre Suchbäume, O(log2n). Zwei Möglichkeiten für Fall c (weitere symmetrische Fälle ignoriert): C C A Fall a: Neuer Knoten wird unten an ein Blatt aus Unterbaum C oder C' C angefügt. Baum bleibt in AVL-Form. C' C A Beide Formen symmetrisch Fall b: neuer Knoten wird unten an ein Blatt aus Unterbaum C angefügt. Baum bleibt in AVL-Form. Fall c: neuer Knoten wird unten an ein Blatt aus Unterbaum A angefügt. Baum wird unausgewogen. 2. Um festzustellen, dass Fall c vorliegt, Neuberechnen der Balancefaktoren auf dem Pfad vom neuen Knoten zur Wurzel, O(log2n). 3. Rebalancieren, falls ein Knoten mit Balancefaktor bf ≥2 entsteht. Wir zeigen, dass dies mit konstantem Aufwand O(1) möglich ist. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-39 © Michael Philippsen Fall c1: x y C A Fall c2: z y D B neu x C A z D B neu Durch Einfügen von "neu" wird der Balancefaktor bf(x)>1. Zu großer Balancefaktor an äußerem Teilbaum, bf-Vorzeichen bleibt. Zu großer Balancefaktor an innerem Teilbaum, bf-Vorzeichen wechselt. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-40 10 15.3 AVL-Bäume 15.3 AVL-Bäume Rebalancieren im Fall c1 vorher: nachher: x y z y x Rebalancieren im Fall c2 vorher: Idee von Fall c1 klappt nicht: nach oben ziehen x und restliche Knoten „einseitig“ anbauen ist y z nicht möglich möglich, weil es kleinere Werte (in A) und z größere Werte (in C,D) gibt. C A A D B B C neu neu wieder ausgewogen D C A D Betrachte „Vergrößerung“: x y w B neu y wird i d neue W Wurzell d des U Unterbaums, t b d der K Knoten t x und dB Baum B müssen aufgrund der Suchbaumeigenschaft ihre Lage ändern. x y y Rotation CD A x Konstante Anzahl von Referenzänderungsschritten. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-41 Beispiel w 4 x add(7) 5 B1 A B2 B2 w Rotation ausgewogen 5 w y 4 w x Rotation x y Doppelrotation; konstante Anzahl von Referenzänderungsschritten. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-43 © Michael Philippsen 4 7 add(2) 7 0/0 w wird neue Wurzel des Unterbaums, die ehemalige Wurzel x wird in Richtung des niedrigeren Teilbaums CD verschoben verschoben. x 1 5 1/ -1 5 Rotation CD wieder neu neu gleiches Vorzeichen 4 2/ -2 CD y neu 15.3 AVL-Bäume Rebalancieren im Fall c2 x vorher: y nachher: y w B1 B2 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-42 15.3 AVL-Bäume A B1 Falls „neu“ an B1 erfolgt das Rebalancieren genau gleich. 2 7 OK 5 add(1) 2/2 4 7 Rotation 1/1 2 0/0 1 Vom neuen Knoten kommend ist 4 der erste unausgewogene Knoten. Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-44 11 15.3 AVL-Bäume 15.3 AVL-Bäume Beispiel Beispiel 5 5 Rotation 2/2 2/ 24 2 7 1 1/1 2 7 add(3) dd(3) 5 2/-1 4 0/0 1 0/0 1 2 7 0/0 2 4 3/2 4 1/1 1 4 5 3 7 2 Doppelrotation 1 3 6 5 7 6 3 0/0 4 Doppelrotation 2 1 add(6) 5 3 7 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-45 Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-46 15.3 AVL-Bäume Weitere Eigenschaften von AVL-Bäumen Nachteile □ Zusätzlicher Platzbedarf in den Knoten zur Speicherung der Höhe oder der Balancefaktoren. Balancefaktoren (Der andere Wert kann leicht berechnet werden, weil die Änderungsoperation vom Blatt in Richtung Wurzel läuft.) □ Komplizierte Implementierung. Programmieren Sie einen AVLBaum! Lustig: fib(h+3) 1 ≤ n < 2h+1-1 fib(h+3)-1 1 Fibonacci-Zahlen tauchen immer wieder mal überraschend auf ☺ Algorithmen und Datenstrukturen • Philippsen/Stamminger/Pflaum • WS 2008/09 • Folie 15-47 © Michael Philippsen 12