Übung 6. Rot-Schwarz-Bäume

Transkript

1 Übung 6. Rot-Schwarz-Bäume Top-Down Bäume Zum Ausschluß des ungünstigsten Falls bei binären Suchbäumen ist eine gewisse Flexibilität in den verwendeten Datenstrukturen nötig. Das kann bspw. durch Aufnahme von mehr als einem Schlüssel in Baumknoten erreicht werden. So soll es 3-Knoten bzw. 4-Knoten geben, die 2 bzw. 3 Schlüssel enthalten können: - Ein 3-Knoten besitzt 3 von ihm ausgehende Verkettungen -- eine für alle Datensätze mit Schlüsseln, die kleiner sind als seine beiden Schlüssel -- eine für alle Datensätze, die zwischen den beiden Schlüsseln liegen -- eine für alle Datensätze mit Schlüsseln, die größer sind als seine beiden Schlüssel. - Ein 4-Knoten besitzt vier von ihm ausgehende Verkettungen, nämlich eine Verkettung für jedes der Intervalle, die durch seine drei Schlüssel definiert werden. Rot-Schwarz-Bäume Es ist möglich Bäume als gewöhnliche binäre Bäume (mit nur zwei Knoten) darzustellen, wobei nur ein zusätzliches Bit je Knoten verwendet wird. Die Idee besteht darin, 3-Knoten und 4 -Knoten als kleine binäre Bäume darzustellen, die durch rote Verkettungen miteinander verbunden sind, im Gegensatz zu den schwarzen Verkettungen, die den Baum zusammenhalten: oder Abb.: Rot-schwarze Darstellung von Bäumen 4-Knoten werden als 2-Knoten dargestellt, die mittels einer roten Verkettung verbunden sind. 3-Knoten werden als 2 Knoten dargestellt, die mit einer roten Markierung verbunden sind. Zu jedem Baum gibt es viele ihm entsprechende Rot-Schwarz-Bäume. 1

2 Eine Variante von Rot-Schwarz-Bäumen Nach jeder Einfüge -Operation bzw. Entferne-Operation lassen sich Rot-Schwarz-Bäume durch Rotationen ausgleichen. Eine Variante von Rot-Schwarz-Bäumen ist durch folgende Farbeigenschaften definiert: 1. Jeder Knoten ist entweder rot oder schwarz gefärbt. 2. der Wurzelknoten ist schwarz gefärbt. 3. Falls ein Knoten rot gefärbt ist, müssen seine Nachfolger schwarz gefärbt sein. 4. Jeder Pfad von einem Knoten zu einer Null-Referenz muß die gleiche Anzahl von schwarzen Knoten enthalten. Eine Folgerung dieser Farbregeln ist: Die Höhe eines Rot-Schwarz-Baums ist etwa 2 log( + 1) N. Aufgabe: Ermittle, welche Gestalt jeweils ein nach den vorliegenden Farbregeln erstellte Rot-Schwarz- Baum beim einfügen folgenden Schlüssel annimmt

3

4 Die Abbildungen zeigen, daß im Durchschnitt der Rot-Schwarz-Baum ungefähr die Tiefe eines AVL- Baums besitzt. Der Vorteil von Rot-Schwarz-Bäumen ist der geringere Overhead zur Ausführung von Einfügevorgängen und die geringere Anzahl von Rotationen. Top -Down Rot-Schwarz-Bäume Kann auf dem Weg nach unten festgestellt werden, daß ein Knoten X zwei rote Nachfolgeknoten hat, dann wird X rot und die beiden Kinder schwarz: X X c1 c2 c1 c2 Das führt zu einem Verstoß gegen Bedingung 3, falls der Vorgänger von X auch rot ist. In diesem Fall können aber geeignete Rotationen herangezogen werden: 4

5 G P P S X G C A X B B S A C G X P S P G X C A A B1 B2 S B1 B2 C Der folgende Fall kann nicht eintreten: Der Nachbar vom Elternknoten ist rot gefärbt. Auf dem Weg nach unten muß der Knoten mit zwei roten Nachfolgern einen schwarzen Großvaterknoten haben. Implementierung Sie wird dadurch erschwert, daß einige Teilbäume (z.b. der rechte Teilbaum des Knoten 10 im vorliegenden Bsp.) leer sein können, und die Wurzel des Baums (, da ohne Vorgänger, ) einer speziellen Behandlung bedarf. Aus diesem Grund werden hier Sentinel -Knoten verwendet: - einer für die Wurzel. Dieser Knoten speichert den Schlüssel und einen rechten Link zu dem realen Knoten - einen Nullknoten (nullnode), der eine Null-Referenz anzeigt. Der Inorder-Durchlauf nimmt aus diesem Grund folgende Gestalt an: Ausgabe der im Baum gespeicherten Datenelemente in sortierter Reihenfolge. public void printtree( ) if( isempty() ) System.out.println("Leerer Baum"); else printtree( header.rechts ); * Interne Methode fuer die Ausgabe des Baum in sortierter Reihenfolge. * b ist der Wurzelknoten. private void printtree(rotschwarzknoten b) if (b!= nullnode ) printtree(b.links); System.out.println(b.daten ); printtree(b.rechts ); 5

6 Programme: 1 // BaumKnoten fuer RotSchwarzBaeume class RotSchwarzKnoten // Instanzvariable public Comparable daten; // Dateninformation der Knoten protected RotSchwarzKnoten links; // linkes Kind protected RotSchwarzKnoten rechts; // rechtes Kind protected int farbe; // Farbe // Konstruktoren RotSchwarzKnoten(Comparable datenelement) this(datenelement, null, null ); RotSchwarzKnoten(Comparable datenelement, RotSchwarzKnoten l, RotSchwarzKnoten r) daten = datenelement; links = l; rechts = r; farbe = RotSchwarzBaum.BLACK; // Die Klasse RotSchwarzBaum // // Konstruktion: mit einem "negative infinity sentinel" // // ******************PUBLIC OPERATIONEN********************* // void insert(x) --> Insert x // void remove(x) --> Entferne x (nicht implementiert) // Comparable find(x) --> Rueckgabe des Datenelements, das x enthaelt // Comparable findmin() --> Rueckgabe des kleinsten Datenelements // Comparable findmax() --> Rueckgabe des groessten Datenelements // boolean isempty() --> Rueckgabe true, falls leer; anderenfalls false // void makeempty() --> Entferne alles // void printtree() --> Ausgabe in aufsteigend sortierter Folge // void ausgrotschwarzbaum() --> Ausgabe des Baums um 90 Grad versetzt * Implementierung eines RotSchwarzBaum. * Vergleiche basieren auf der Methode compareto. public class RotSchwarzBaum private RotSchwarzKnoten header; private static RotSchwarzKnoten nullnode; static // Static Initialisierer for nullnode nullnode = new RotSchwarzKnoten(null); nullnode.links = nullnode.rechts = nullnode; static final int BLACK = 1; // Black must be 1 static final int RED = 0; // Fuer "insert routine" und zugehoerige unterstuetzende Routinen private static RotSchwarzKnoten current; private static RotSchwarzKnoten parent; private static RotSchwarzKnoten grand; 1 PR

7 private static RotSchwarzKnoten great; * Baumkonstruktion. * neginf ist ein Wert, der kleiner oder gleich zu allen anderen Werten ist. public RotSchwarzBaum(Comparable neginf) header = new RotSchwarzKnoten(negInf); header.links = header.rechts = nullnode; * Einfügen in den Baum. Duplikate werden ueberlesen. * "item" ist das einzufuegende Datenelement. public void insert(comparable item) current = parent = grand = header; nullnode.daten = item; while( current.daten.compareto( item )!= 0 ) great = grand; grand = parent; parent = current; current = item.compareto(current.daten ) < 0? current.links : current.rechts; // Pruefe, ob zwei rote Kinder; falls es so ist, fixiere es if( current.links.farbe == RED && current.rechts.farbe == RED ) reorientierung( item ); // Fehlanzeige fuer Einfuegen, falls schon da if( current!= nullnode ) return; current = new RotSchwarzKnoten( item, nullnode, nullnode ); // Anhaengen an die Eltern if( item.compareto( parent.daten ) < 0 ) parent.links = current; else parent.rechts = current; reorientierung( item ); * Entferne aus dem Baum. * Nicht implementiert * x ist das zu entfernemde Datenelement. public void remove( Comparable x ) System.out.println("Entfernen ist nicht implementiert"); * Finde das kleinste Datenelement im Baum. * Rueckgabe kleinstes Datenelement oder null, falls leer. public Comparable findmin( ) if (isempty( )) return null; RotSchwarzKnoten itr = header.rechts; while( itr.links!= nullnode ) itr = itr.links; return itr.daten; * Finde das groesste Datenelement im Baum. 7

8 * Rueckgabe des groessten Datenelemnts oder null, falls leer. public Comparable findmax( ) if (isempty( )) return null; RotSchwarzKnoten itr = header.rechts; while( itr.rechts!= nullnode ) itr = itr.rechts; return itr.daten; * Finde ein Datenelement im Baum. * x enthaelt das zu suchende Datenelement. * Rueckgabe des passenden Datenelements oder null, falls nicht gefunden. public Comparable find(comparable x) nullnode.daten = x; current = header.rechts; for( ; ; ) if( x.compareto( current.daten ) < 0 ) current = current.links; else if( x.compareto( current.daten ) > 0 ) current = current.rechts; else if( current!= nullnode ) return current.daten; else return null; * Mache den Baum logisch leer. public void makeempty( ) header.rechts = nullnode; * Test, ob der Baum logisch leer ist. * Rueckgabe true, falls leer; anderenfalls false. public boolean isempty( ) return header.rechts == nullnode; * Ausgabe der im Baum gespeicherten Datenelemente in sortierter Reihenfolge. public void printtree( ) if( isempty() ) System.out.println("Leerer Baum"); else printtree( header.rechts ); * Interne Methode fuer die Ausgabe des Baum in sortierter Reihenfolge. * b ist der Wurzelknoten. private void printtree(rotschwarzknoten b) 8

9 if (b!= nullnode ) printtree(b.links); System.out.println(b.daten ); printtree(b.rechts ); * Ausgabe des Binaerbaums um 90 Grad vesetzt public void ausgrotschwarzbaum() ausgrotschwarzbaum(header.rechts,0); private void ausgrotschwarzbaum(rotschwarzknoten b, int nspace) if (b!= nullnode) ausgrotschwarzbaum(b.links,nspace += 6); for (int i = 0; i < nspace; i++) System.out.print(" "); System.out.println(b.daten + " " + b.farbe); ausgrotschwarzbaum(b.rechts, nspace); * Interne Routine, die waehrend eines Einfuegevorgangs aufgerufen wird * Falls ein Knoten zwei rote Kinder hat, fuehre Tausch der Farben aus * und rotiere. * item enthaelt das einzufuegende Datenelement. private void reorientierung(comparable item) // Tausch der Farben current.farbe = RED; current.links.farbe = BLACK; current.rechts.farbe = BLACK; if (parent.farbe == RED) // Rotation ist noetig grand.farbe = RED; if ( (item.compareto( grand.daten) < 0 )!= (item.compareto( parent.daten) < 0 ) ) parent = rotation(item, grand); // Start Doppelrotation current = rotation(item, great); current.farbe = BLACK; header.rechts.farbe = BLACK; // Mache die Wurzel schwarz * Interne Routine, die eine einfache oder doppelte Rotation veranlasst. * Da das Ergebnis an "parent" geheftet wird, gibt es vier Faelle. * Aufruf durch reorientierung. * "item" ist das Datenelement reorientierung. * "parent" ist "parent" von der wurzel des rotierenden Teilbaums. * Rueckgabe: Wurzel des rotierenden Teilbaums. private RotSchwarzKnoten rotation(comparable item, RotSchwarzKnoten parent) if (item.compareto(parent.daten) < 0) return parent.links = item.compareto( parent.links.daten) < 0? rotationmitlinksnachf(parent.links) : // LL 9

10 rotationmitrechtsnachf(parent.links) ; // LR else return parent.rechts = item.compareto(parent.rechts.daten) < 0? rotationmitlinksnachf(parent.rechts) : // RL rotationmitrechtsnachf(parent.rechts); // RR * Rotation Binaerbaumknoten mit linkem Nachfolger. static RotSchwarzKnoten rotationmitlinksnachf( RotSchwarzKnoten k2 ) RotSchwarzKnoten k1 = k2.links; k2.links = k1.rechts; k1.rechts = k2; return k1; * Rotate Binaerbaumknoten mit rechtem Nachfolger. static RotSchwarzKnoten rotationmitrechtsnachf(rotschwarzknoten k1) RotSchwarzKnoten k2 = k1.rechts; k1.rechts = k2.links; k2.links = k1; return k2; import java.io.*; public class RotSchwarzBaumTest public static void main(string[ ] args) InputStreamReader isr = new InputStreamReader(System.in); BufferedReader ein = new BufferedReader(isr); String eingabezeile = null; RotSchwarzBaum b = new RotSchwarzBaum(new Integer(Integer.MIN_VALUE)); System.out.println("Eingabe ganzzahliger Werte: "); while (true) try eingabezeile = ein.readline(); int a = Integer.parseInt(eingabeZeile); if (a == 0) break; b.insert(new Integer(a)); b.ausgrotschwarzbaum(); catch(ioexception e) System.out.println(e.toString()); // System.exit(0); // b.printtree(); b.ausgrotschwarzbaum(); 10