Algorithmen und Datenstrukturen

Transkript

1 Übung 3: Die generische Klasse BinärerSuchbaum in Java 1 Datenelemente der Klasse BinaererSuchbaum Das einzige Datenelelement in dieser Klasse ist die Wurzel vom Typ BinaerBaumknoten. Die Klasse BinaerBaumknoten ist allgemein sichtbar. Der binäre Suchbaum setzt voraus, daß alle Datenelemente der Baumknoten in eine Ordnungsbeziehung gebracht werden können. Eine generische Klasse für einen binären Suchbaum erfordert daher ein Interface, das Ordnungsbeziehungen zwischen Daten eines Datenbestands festlegt. Diese Eigenschaft besitzt das Interface Comparable public interface Comparable int compareto(comparable rs) Durch die Definition eines Interface wird der zugehörige Referenztyp erzeugt, der wie andere Datentypen eingesetzt werden kann. Methoden der Klasse BinaererSuchbaum Die öffentlich zugänglichen, sichtbaren Methoden rufen private, rekursive Methoden auf: Die private Methode elementat gibt eine Referenz zurück, die auf den Baumknoten verweist, in dem ein bestimmtes Datenelement gespeichert ist. Das Auffinden eines Datenelements im binären Suchbaum besorgt: private BinaerBaumknoten find(comparable x, BinaerBaumknoten b); Das Auffinden des größten bzw. kleinsten Datenelements im binären Suchbaum übernehmen: private BinaerBaumknoten findmax(binaerbaumknoten b); private BinaerBaumknoten findmin(binaerbaumknoten b); Das Einfügen eines Knoten in den binären Suchbaum übernimmt: private BinaerBaumknoten insert(comparable x, BinaerBaumknoten b); Duplikate können beim Einfügen durch ein spezielles Feld im Baumknoten behandelt werden, das die doppelten Vorkommen zählt. Das Löschen eines Baumkoten übernimmt private BinaerBaumknoten remove(comparable x, BinaerBaumknoten b); Beim Entfernen sind 3 Fälle zu unterscheiden: 1. Der zu entfernende Knoten ist ein Blattknoten. Das Entfernen dieses Knoten kann direkt erfolgen. 2. Der zu entfernende Knoten hat einen Nachfolger. Hier wird vom Elternknoten des zu entfernenden Knoten ein Link auf den Nachfolger des zu entfernenden Knoten gesetzt. 1 Vgl. PR

2 Der zu entfernende Knoten hat 2 Nachfolger. Hier könnte eine allgemeine Strategie für das Entfernen des Knoten so lauten: - Ersetze den Inhalt des Datenelements durch den Inhalt des kleinsten Datenelements des rechten Teilbaums. Dieser Baumknoten kann leicht gefunden werden. - Das Datenelement mit dem kleinsten Inhalt vom rechten Teilbaum des zu entfernenden Baumknoten ist dann leer, der zugehörige Baumknoten kann deshalb rekursiv entfernt werden. Da der Knoten mit dem kleinsten Inhalt des Datenelements keine linken Nachfolger besitzt, ist diese Art des Entfernens einfach Bsp.: Entfernen des Knotens mit dem Datenelement Test: Klasse BinaerSuchbaumTest Aufgaben: Ersetze die rekursiven Methoden durch Methoden, die Iterationen anstatt Rekursionen verwenden. 2

3 Lösungen // Elementarer Knoten eines binaeren Baums, der nicht ausgeglichen ist // Der Zugriff auf diese Klasse ist nur innerhalb eines Verzeichnisses // bzw. Pakets moeglich class BinaerBaumknoten // Instanzvariable protected BinaerBaumknoten links; protected BinaerBaumknoten rechts; public Comparable daten; // linker Teilbaum // rechter Teilbaum // Dateninhalt der Knoten // Konstruktor public BinaerBaumknoten(Comparable datenelement) this(datenelement, null, null ); public BinaerBaumknoten(Comparable datenelement, BinaerBaumknoten l, BinaerBaumknoten r) daten = datenelement; links = l; rechts = r; public BinaerBaumknoten getlinks() return links; public BinaerBaumknoten getrechts() return rechts; // Freier binaerer Intervallbaum // Generische Klasse fuer einen unausgeglichenen binaeren Suchbaum // // Konstruktor: Initialisierung der Wurzel mit dem Wert null // // **********oeffentlich zugaengliche Methoden************************************* // void insert( x ) --> Fuege x ein // void remove( x ) --> Entferne x // Comparable find( x ) --> Gib das Element zurueck, das zu x passt // Comparable findmin( ) --> Rueckgabe des kleinsten Elements // Comparable findmax( ) --> Rueckgabe des groessten Elements // boolean isempty( ) --> Return true if empty; else false // void makeempty( ) --> Entferne alles // void printtree( ) --> Ausgabe der Binaerbaum-Elemente in sortierter Folge // void ausgbinaerbaum() --> Ausgabe der Binaerbaum-Elemente um 90 Grad vers. * Implementiert einen unausgeglichenen binaeren Suchbaum. * Das Einordnen in den Suchbaum basiert auf der Methode compareto public class BinaererSuchbaum 3

4 // Private Datenelemente Die Wurzel des Baums private BinaerBaumknoten root; // Oeffentlich zugaengliche Methoden * Konstruktor. public BinaererSuchbaum() root = null; * Einfuegen eines Elements in den binaeren Suchbaum * Duplikate werden ignoriert public void insert( Comparable x ) root = insert(x, root); * Entfernen aus dem Baum. Falls x nicht da ist, geschieht nichts public void remove( Comparable x ) root = remove(x, root); * finde das kleinste Element im Baum public Comparable findmin() return elementat(findmin(root)); * finde das groesste Element im Baum public Comparable findmax() return elementat(findmax(root)); * finde ein Datenelement im Baum public Comparable find(comparable x) return elementat(find(x, root)); * Mache den Baum leer public void makeempty() root = null; * Test, ob der Baum leer ist public boolean isempty() return root == null; * Ausgabe der Datenelemente in sortierter Reihenfolge 4

5 public void printtree() if( isempty( ) ) System.out.println( "Baum ist leer" ); else printtree( root ); * Ausgabe der Elemente des binaeren Baums um 90 Grad versetzt public void ausgbinaerbaum() if( isempty() ) System.out.println( "Leerer baum" ); else ausgbinaerbaum( root,0 ); // Private Methoden * Methode fuer den Zugriff auf ein Datenelement private Comparable elementat( BinaerBaumknoten b ) return b == null? null : b.daten; * Interne Methode fuer das Einfuegen in einen Teilbaum private BinaerBaumknoten insert(comparable x, BinaerBaumknoten b) 1 if( b == null ) 2 b = new BinaerBaumknoten( x, null, null ); 3 else if( x.compareto( b.daten ) < 0 ) 4 b.links = insert( x, b.links ); 5 else if( x.compareto( b.daten ) > 0 ) 6 b.rechts = insert( x, b.rechts ); 7 else 8 ; // Duplikat; tue nichts 9 return b; * Interne Methode fuer das Entfernen eines Knoten in einem Teilbaum private BinaerBaumknoten remove(comparable x, BinaerBaumknoten b) if( b == null ) return b; // nichts gefunden; tue nichts if( x.compareto(b.daten) < 0 ) b.links = remove(x, b.links ); else if( x.compareto(b.daten) > 0 ) b.rechts = remove( x, b.rechts ); else if( b.links!= null && b.rechts!= null ) // Zwei Kinder b.daten = findmin(b.rechts).daten; b.rechts = remove(b.daten, b.rechts); else b = ( b.links!= null )? b.links : b.rechts; return b; * Interne Methode zum Bestimmen des kleinsten Datenelements im Teilbaum 5

6 private BinaerBaumknoten findmin(binaerbaumknoten b) if (b == null) return null; else if( b.links == null) return b; return findmin(b.links ); * Interne Methode zum Bestimmen des groessten Datenelements im Teilbaum private BinaerBaumknoten findmax( BinaerBaumknoten b) if( b!= null ) while( b.rechts!= null ) b = b.rechts; return b; * Interne Methode zum Bestimmen eines Datenelements im Teilbaum. private BinaerBaumknoten find(comparable x, BinaerBaumknoten b) if(b == null) return null; if( x.compareto(b.daten ) < 0) return find(x, b.links); else if( x.compareto(b.daten) > 0) return find(x, b.rechts); else return b; // Gefunden! * Internae Methode zur Ausgabe eines Teilbaums in sortierter Reihenfolge private void printtree(binaerbaumknoten b) if(b!= null) printtree(b.links); System.out.print(b.daten); System.out.print(' '); printtree( b.rechts ); * Ausgabe des Binaerbaums um 90 Grad versetzt private void ausgbinaerbaum(binaerbaumknoten b, int stufe) if (b!= null) ausgbinaerbaum(b.links, stufe + 1); for (int i = 0; i < stufe; i++) System.out.print(' '); System.out.println(b.daten); ausgbinaerbaum(b.rechts, stufe + 1); 6

7 public class BinaererSuchbaumTest // Test program public static void main( String [] args ) // Test Nr. 1 BinaererSuchbaum b = new BinaererSuchbaum(); final int ZAHLEN = 4000; final int LUECKE = 37; System.out.println( "Pruefung... (keine weiteren Ausgaben bedeutet Erfolg)"); for( int i = LUECKE; i!= 0; i = (i + LUECKE) % ZAHLEN) b.insert( new Integer( i ) ); for(int i = 1; i < ZAHLEN; i+= 2 ) b.remove( new Integer( i ) ); if (ZAHLEN < 40) b.printtree( ); if( ((Integer)(b.findMin( ))).intvalue( )!= 2 ((Integer)(b.findMax( ))).intvalue( )!= ZAHLEN - 2 ) System.out.println( "FindMin oder FindMax -Fehler!" ); for( int i = 2; i < ZAHLEN; i+=2 ) if( ((Integer)(b.find( new Integer( i ) ))).intvalue( )!= i ) System.out.println( "Find Fehler Nr.1!" ); for( int i = 1; i < ZAHLEN; i+=2 ) if( b.find( new Integer( i ) )!= null ) System.out.println( "Find error2!" ); // Test Nr.2 BinaererSuchbaum b1 = new BinaererSuchbaum(); for (int i = 0; i < 10; i++) // Erzeuge eine Zahl zwischen 0 und 100 Integer r = new Integer((int)(Math.random()*100)); b1.insert(r); System.out.println("Inorder-Durchlauf"); b1.printtree(); System.out.println(); System.out.println("Baumdarstellung um 90 Grad versetzt"); b1.ausgbinaerbaum(); System.out.print("Kleinster Wert: "); System.out.print(((Integer)(b1.findMin())).intValue()); System.out.println(); System.out.print("Groesster Wert: "); System.out.print(((Integer)(b1.findMax())).intValue()); System.out.println(); for (int i = 0; i < 10; i++) // Erzeuge eine Zahl zwischen 0 und 100 Integer r = new Integer((int)(Math.random()*100)); if ( b1.find(r)!= null ) b1.remove( r ); // else System.out.println(r.intValue() + " nicht gefunden"); b1.ausgbinaerbaum(); // Test Nr. 3 BinaererSuchbaum b2 = new BinaererSuchbaum(); for (int i = 0; i < 20; i++) // 20 Zusfallsstrings speichern String s = "Zufallszahl " + (int)(math.random() * 100); 7

8 b2.insert(s); b2.printtree(); // Sortiert wieder ausdrucken 8