Objektorientierte Programmierung

Transkript

1 Universität der Bundeswehr Fakultät für Informatik Institut 2 Priv.-Doz. Dr. Lothar Schmitz FT 2006 Übungsblatt 5 Objektorientierte Programmierung Aufgabe 9 (SMS-Eingabe am Handy mit Tries) Für die Eingabe einer Textnachricht (SMS) am Handy werden i.w. die numerischen Tasten verwendet, die für diese Zwecke mehrfach überladen sind, z.b. die Taste 6 mit M, N, O die Taste 8 mit T, U, V (Tatsächlich sind die Tasten mit weiteren Zeichen wie Umlauten oder Buchstaben mit Akzenten überladen. Für diese Aufgabe spielt das aber keine Rolle!) Alle in einem Wort vorkommenden Zeichen liegen auf einer der Tasten 2 bis 9. Wir nennen ein Wort verträglich mit einer Tastenfolge gleicher Länge, wenn für alle i jeweils der i-te Buchstabe des Worts zu den Zeichen gehört, mit denen die i-te Taste der Tastenfolge überladen ist. Ein Wort ist also mit genau einer Tastenfolge verträglich, während umgekehrt mit einer Tastenfolge viele Wörter verträglich sein können. Beispielsweise sind mit der Tastenfolge 866 u.a. die Wörter TON, VOM und UNO verträglich. Im Normalmodus wird bei der Eingabe eines Worts für jeden Buchstaben die zugehörige Taste so oft hintereinander gedrückt, bis das richtige der überladenen Zeichen ausgewählt ist. Schneller geht die Eingabe eines Worts im sogenannten T9-Modus, der auf der Verwendung eines (erweiterbaren) Wörterbuchs beruht: Eingetippt wird nur die mit dem Wort verträgliche Tastenfolge. Danach bietet das Handy die mit der Tastenfolge verträglichen Wörter aus dem Wörterbuch zur Auswahl und Bestätigung an. Neue Wörter können zum Wörterbuch hinzugefügt werden; dazu müssen sie im Normalmodus eingetippt werden. Der neue Handy-Hersteller Sokison hat Sie mit der Programmierung eines geeigneten Wörterbuchs in Java beauftragt und erwartet, dass Sie sich präzise an die folgenden Vorgaben halten. Das Wörterbuch ist als T9-Trie organisiert, d.h. als ein Baum, in dem jeder innere Knoten genau acht Söhne hat (die wieder T9-Tries sind), und zwar für jede der Tasten 2 bis 9 einen Sohn. Den Sohn zur Taste i nennen wir kurz den i-sohn. Jedem Knoten eines T9-Trie entspricht genau eine Tastefolge: dem Wurzelknoten des Gesamtbaums entspricht die leere Tastenfolge; entspricht einem Knoten k die Tastenfolge t, dann entspricht dem i-sohn von k die Tastenfolge t i (also die Tastenfolge t verlängert um die Taste i). Auf dem Java-Beiblatt ist der Rahmen der gewünschten Implementierung bereits vorgegeben; darin werden einige Methoden noch geeignet zu ergänzen sein. T9-Tries bestehen aus inneren Knoten (Objekten der Klasse Trie) und aus Blättern (Objekten der Klasse EmptyTrie). Die Klassen Trie und EmptyTrie sind Unterklassen der abstrakte Klasse T9Trie, welche ihre gemeinsame Schnittstelle festlegt und eine statische Hilfsmethode tastezu() bereitstellt. Die Söhne eines inneren Knotens sind erreichbar über das Attribut sohn der Klasse Trie, genauer: Der i-sohn steht in sohn[i-2], weil Array-Indizes bei 0 beginnen, die Tasten aber mit 2 bis 9 beschriftet sind. Nur den inneren Knoten sind Wörter zugeordnet; im 1

2 Attribut wortliste der Klasse Trie befinden sich die Wörter, die mit der Tastenfolge verträglich sind, die dem Knoten entspricht. Instanzen der Klassen TrieIterator und EmptyTrieIterator zählen die Wörter auf, die sich in dem angesprochenen Knoten oder in einem seiner Unterbäume befinden. Aus Sicherheitsgründen darf in einem T9-Trie der Wert null nicht vorkommen (um die entsprechenden Exceptions zu vermeiden). Aus Effizienzgründen darf im ganzen Programm der Konstruktor der Klasse EmptyTrie nur ein einziges Mal verwendet werden, nämlich bei der Definition der Konstanten EMPTY. a) In welchen Klassen kann der Aufruf tastezu( R ) stehen und was ergibt er? b) Erläutern Sie kurz, warum der Konstruktor von EmptyTrie als private deklariert ist und ergänzen Sie unten den Rumpf des Konstruktors von Trie so, dass er der Sicherheitsanforderung von Sokison entspricht. public Trie() { 2

3 c) Implementieren Sie die Methoden suchen so, dass der Aufruf w.suchen(tastenfolge,0) die Liste der Wörter zurückgibt, die im T9-Trie mit der Wurzel w mit der Tastenfolge in tastenfolge verträglich sind. Bei rekursiven Aufrufen wird jeweils der Parameter ab um 1 erhöht, der Parameter tastenfolge dagegen unverändert weitergereicht. Zuerst die Implementierung in EmptyTrie: public List suchen(int[] tastenfolge, int ab)) { Dann die Implementierung in Trie: public List suchen(int[] tastenfolge, int ab)) { if ( ) return wortliste; return sohn[ d) Der Methodenaufruf w.eintragen(wort,ab) liefert ein Trie-Objekt zurück, das zusätzlich zu den im Baum mit der Wurzel w befindlichen Wörtern das einzutragende Wort wort enthält. Der Parameter ab wird genauso verwendet wie bei der Methode suchen. Zuerst die Implementierung in EmptyTrie: public T9Trie eintragen(string wort, int ab)) { T9Trie neu = ; neu = return ; 3

4 Anschließend die Implementierung in Trie: public T9Trie eintragen (String wort, int ab) { if ( == wort.length()) { // Wort im Knoten eintragen: wortliste. ; ; return ; // Ansonsten Wort beim richtigen Sohn eintragen: int i = ; sohn[i] = ; return ; e) Die Iteratoren TrieIterator und EmptyTrieIterator dienen zum Aufzählen der Wörter, die in den entsprechenden T9Trie-Bäumen enthalten sind. Zu EmptyTrieIterator ist die Implementierung bereits gegeben. Implementieren Sie nun TrieIterator so, dass (mit Hilfe geeigneter Hilfsiteratoren in akt) zuerst die im Knoten enthaltenen Wörter aufgezählt werden und anschließend die Wörter der Unterbäume. Ergänzen Sie zunächst die Hilfsmethode finde(), die einen erschöpften Hilfsiterator in akt gegen einen Folgeiterator austauscht, der noch nicht erschöpft ist sofern es einen solchen Folgeiterator noch gibt. Der Index bi zeigt dabei an, welcher Sohn als nächster zu durchlaufen ist: private void finde() { while (! && ) { akt = ((T9Trie)baum.getSoehne()[ ]). ; ; 4

5 Implementieren Sie als nächstes den Konstruktor von TrieIterator so, dass er der Sicherheitsanforderung von Sokison entspricht und das Attribut akt den ersten nicht erschöpften Hilfsiterator enthält. TrieIterator (Trie b) { // Attribute belegen: baum = ; akt = ; bi = ; // Wenn moeglich sicherstellen, dass Iterator in akt // nicht erschoepft ist: ; Ergänzen Sie zuletzt die Methoden hasnext() und next(): public boolean hasnext() { return ; public String next() { String erg = ; ; return ; 5

6 6

7 Java-Beiblatt import java.util.*; * Abstrakte Oberklasse der in T9 fuer Woerterbuecher verwendeten * Tries; legt Schnittstelle fest und stellt die Hilfsmethode * "tastezu" bereit. public abstract class T9Trie { * Konversionsmethode: liefert Tastennummer zu Zeichen z das Zeichen die Nummer der Taste, auf der z liegt static public int tastezu (char z) { String belegung = "ABC " + // Taste 2 "DEF " + // Taste 3 "GHI " + // Taste 4 "JKL " + // Taste 5 "MNO " + // Taste 6 "PQRS" + // Taste 7 "TUV " + // Taste 8 "WXYZ"; // Taste 9 return belegung.indexof(z) / 4 + 2; * Mit Tastenfolge vertraegliche Woerter bestimmen. tastenfolge die Tastenfolge als int-array ab Index, ab dem Tastenfolge noch zu bearbeiten ist. Liste der vertraeglichen Woerter public abstract List suchen (int[] tastenfolge, int ab); * Neues Wort in Woerterbuch eintragen. wort das einzutragende Wort als String ab Index, ab dem wort noch zu bearbeiten ist. Trie(!), der zusaetzlich wort enthaelt. public abstract T9Trie eintragen (String wort, int ab); * Iterator zu Trie erstellen und zurueckgeben. public abstract Iterator iterator (); 7

8 import java.util.*; * Klasse der inneren Knoten eines Tries. public class Trie extends T9Trie { private List wortliste; private T9Trie[] sohn; // sohn[i] wird ueber Taste i+2 erreicht // getter-methoden: public List getwortliste() { return wortliste; public T9Trie[] getsoehne() { return sohn; * Konstruktor fuer Trie-Objekte. Belegt alle Attribute * entsprechend der Sicherheitsanforderung. public Trie() { public List suchen (int[] tastenfolge, int ab) { * wort eintragen in den angesprochenen Trie; zurueckgegeben * wird der so modifizierte Trie. public T9Trie eintragen (String wort, int ab) { * Iterator zu Trie erstellen und zurueckgeben. public Iterator iterator () { 8

9 import java.util.*; * Leere Tries - statt null verwenden! public class EmptyTrie extends T9Trie { // Konstante, die den einzigen EmptyTrie bereitstellt: public static final EmptyTrie EMPTY = new EmptyTrie(); Konstruktor fuer EmptyTrie-Objekte. private EmptyTrie () { public List suchen (int[] tastenfolge, int ab) { * wort eintragen in einen neuen Trie, der als Ergebnis * zurueckgegeben wird. public T9Trie eintragen (String wort, int ab) { public Iterator iterator () { ////////////////////////////////////////////////////////////////// import java.util.*; * Iterator fuer Klasse EmptyTrie. public class EmptyTrieIterator implements Iterator { public boolean hasnext() { return false; public Object next() { return "FEHLER: EmptyTrieIterator.next() aufgerufen!"; public void remove() { 9

10 import java.util.*; * Iterator fuer Klasse Trie. public class TrieIterator implements Iterator{ Trie baum; Iterator akt; int bi; // Index des naechsten zu betrachtenden Sohn-Iterators. * Hilfsmethode: Setzt akt auf den naechsten Iterator, der noch * Elemente enthaelt - sofern es einen solchen gibt. private void finde() { * Konstruktor fuer Trie-Iteratoren. TrieIterator (Trie b) { public boolean hasnext() { public Object next() { public void remove() { 10

11 Aufgabe 10 (Quadtrees) Aus der Vorlesung sind bereits knotenmarkierte Binärbäume bekannt, deren innere Knoten jeweils zwei Nachfolger haben können. In dieser Aufgabe sollen nun knotenmarkierte Quad-Bäume (QuadTrees) behandelt werden. Deren einziger Unterschied zu den Binärbäumen besteht darin, dass jeder Knoten nun bis zu vier Unterbäume besitzen kann. QuadTrees eignen sich zur Speicherung von Punkten der Ebene. Dabei wird in jedem Knoten genau ein Punkt gespeichert. Dieser Punkt teilt die Ebene in vier Quadranten (rechts-oben, links-oben, links-unten und rechtsunten), deren Knoten in den vier Unter-QuadTrees gespeichert werden. a) Unten ist die abstrakte Klasse QuadTree gegeben. Von ihr sollen nun zwei instanziierbare Klassen erstellt werden: QuadTreeElement als Repräsentant eines inneren QuadTree-Knotens und EmptyQuadTree. Überlegen Sie sich, welche Attribute für die beiden Klassen sinnvoll sind. Die Klasse QuadTree: public abstract class QuadTree{ public final static QuadTree empty(){ return new EmptyQuadTree(); // zu Aufgabe c) public abstract boolean isempty(); public abstract QuadTree insert(koord newk); Und die Klasse Koord: public interface Koord{ public double getx(); public double gety(); public boolean equals(object o); b) Zeichnen Sie ein Objektdiagramm zum unten gezeigten QuadTree. Der QuadTree ist wie folgt zu verstehen. Der Punkt A (1,0) bildet die Wurzel des Baumes. Im rechten oberen Quadranten von A liegt der Unterbaum für Punkt B (10,10) und im linken unteren Quadranten von A der Unterbaum für Punkt C (-1,-2). Weiterhin existieren noch zwei Unterbäume von C: Der Punkt D (-5,-1) im linken oberen Quadranten und der Punkt E (-2,-3) im linken unteren Quadranten. Alle anderen Quadranten, die nicht durch Punkte belegt sind, werden durch Leerbäume gekennzeichnet. Damit das Diagramm nicht unübersichtlich wird, benutzen Sie für ein EmptyQuadTree-Objekt einfach einen schwarz ausgemalten Punkt. 11

12 c) Implementieren Sie nun die beiden Klassen QuadTreeElement und EmptyQuadTree. Folgende Methoden sind dabei zu realisieren: Jede Klasse soll maximal einen Konstruktor enthalten. public boolean isempty(); Diese Methode gibt zurück, ob der Baum leer ist. public QuadTree insert(koord newk); Diese Methode fügt eine neue Koordinate in den Baum ein. Für ein QuadTreeElement entscheidet sie, in welchen Quadranten (=Unterbaum) die Koordinate gehört und setzt den Einfügemechanismus rekursiv fort. Die Rückgabe ist der Baum mit der eingefügten Koordinate. Existiert die Koordinate im Baum bereits, wird sie nicht noch einmal hinzugefügt. d) Implementieren Sie in QuadTreeElement weiterhin die Methode public QuadTree getsubtree(int number); die den gewünschten Unterbaum zurückgibt, wobei 0 bis 3 als Nummern für die vier verschiedenen Unterbäume erlaubt sind. e) Mit den nun vorhandenen Methoden und Klassen soll der auf dem Beiblatt skizzierte QuadTreeIterator vervollständigt werden. Der Iterator soll in dieser Realisierung zuerst alle Elemente der Unterbäume produzieren (Reihenfolge der Unterbäume unwichtig) und dann das eigene Element. Dabei dient das Attribut cursubtree als Zähler, welcher Unterbaum gerade produziert wird. 12

13 import java.util.*; public class QuadTreeIterator implements Iterator{ private int cursubtree; private Iterator currentiterator; private QuadTreeElement qt; public QuadTreeIterator(EmptyQuadTree qt){ this.qt = null; this.cursubtree = this.currentiterator = null; public QuadTreeIterator(QuadTreeElement qt){ this.qt = qt; this.cursubtree = 0; this.currentiterator = public boolean hasnext(){ return cursubtree!= 5; public void remove(){ public Object next(){ if(!hasnext()) throw if(cursubtree == 4){ // Alle SubTrees durchgelaufen => "qt" zurückgeben if(currentiterator.hasnext()) else{ // aktueller Iterator leer => nächster SubTree // Solange cursubtree einen vorhandenen SubTree // bezeichnet, den Iterator davon erzeugen if( ) // rekursiv diese Methode aufrufen return next(); 13