Algorithmen und Programmierung III

Transkript

1 Musterlösung zum 5. Aufgabenblatt zur Vorlesung WS 2006 Algorithmen und Programmierung III von Christian Grümme Aufgabe 1 Implementieren von ADTs Testlauf der Klasse TestDeque in der z05a1.jar: 10 Punkte Erzeuge Deques. Füge nun 2500 Elemente zu den Deques hinten hinzu. Die Deque in der Liste hat 47 Millisekunden gebraucht. Die Deque im Feld hat 15 Millisekunden gebraucht. Füge nun 2500 Elemente zu den Deques vorne hinzu. Die Deque in der Liste hat 16 Millisekunden gebraucht. Die Deque im Feld hat 16 Millisekunden gebraucht. Füge nun je 5000 Elemente an zufaelligen Stellen ein. Die Deque in der Liste hat 15 Millisekunden gebraucht. Die Deque im Feld hat 16 Millisekunden gebraucht. Nehme nun je 5000 Elemente an zufaelligen Stellen raus. Die Deque in der Liste hat 15 Millisekunden gebraucht. Die Deque im Feld hat 16 Millisekunden gebraucht. Es befinden sich noch Elemente in der Deque in der Liste. Es befinden sich noch Elemente in der Deque im Feld. Lösche die restlichen Elemente aus den Deques. Die Deque in der Liste hat 0 Millisekunden gebraucht. Die Deque im Feld hat 31 Millisekunden gebraucht. Die Laufzeit des Deques im Feld hängt sehr von dessen Initalizierungsgrösse ab. Ist diese größ, muss das Feld wenig verändert werden und die Deque im Feld ist dann schneller als die Deque in der Liste. Interface Deque 1 /** 2 * Algorithmen und Programmierung III WS2006 /07 3 * 5. Aufgabenblatt 4 * Aufgabe 1 5 */ 6 package alp3. zettel05. a1; 7 8 import java. util. NoSuchElementException ; 9 10 /** 11 * Dies ist eine Double - Ended - Queue. 12 * Die Deque ( Double - Ended - Queue ) ist eine Warteschlange wie die Queue, 13 * nur dass auf beiden Seiten Elemente hinzugefügt und wieder entfernt 14 * werden können. 15 * 16 Christian Grümme 17 * 18 <T> Typ der Elemente 19 */ 20 public interface Deque <T> { 21

2 22 /** 23 * Fügt gegebenes Element vorne an die Dequeue an. 24 value Das vorne einzufügende Element 25 */ 26 public void insertfirst ( T value ); /** 29 * Gibt das vorderste Element zurück und entfernt es aus der Dequeue. 30 Das erste bzw. vorderste Element 31 NoSuchElementException Wird geworfen, wenn die Deque leer ist 32 */ 33 public T removefirst () throws NoSuchElementException ; /** 36 * Gibt das erste bzw. vorderste Element als Ergebnis zurück. 37 Das erste bzw. vorderste Element 38 NoSuchElementException Wird geworfen, wenn die Deque leer ist 39 */ 40 public T first () throws NoSuchElementException ; /** 43 * Fügt gegebenes Element hinten an die Dequeue an. 44 value Das hinten einzufügende Element 45 */ 46 public void insertlast ( T value ); /** 49 * Gibt das hinterste Element zurück und entfernt es aus der Dequeue. 50 Ist mindestens ein Element vorhanden 51 NoSuchElementException Wird geworfen, wenn die Deque leer ist 52 */ 53 public T removelast () throws NoSuchElementException ; /** 56 * Gibt das letzte bzw. hinterste Element als Ergebnis zurück. 57 Das letzte bzw. hinterste Element 58 NoSuchElementException Wird geworfen, wenn die Deque leer ist 59 */ 60 public T last () throws NoSuchElementException ; /** 63 * Prüft, ob die Double - Ended - Queue leer ist. 64 Ist mindestens ein Element vorhanden 65 */ 66 public boolean isempty (); /** 69 * Gibt die Anzahl der in der Double - Ended - Queue enthaltenen 70 * Elemente zurück. 71 Anzahl der Elemente in der Double - Ended - Queue 72 */ 73 public int size (); 74 } Diese Klasse benutzt meine Implementierung der einfachverketteten Liste vom 3. Übungszettel. class ListDeque 1 /** 2 * Algorithmen und Programmierung III WS2006 /07 3 * 5. Aufgabenblatt 4 * Aufgabe 1 5 */ 6 package alp3. zettel05. a1; 7 8 import java. util. NoSuchElementException ; 9 import alp3. zettel03. a2.*; /** 12 * Implementierung der Deque durch eine doppelt verkettete Liste. 13 * <br > 14 * <br > 15 * Diese doppelt verkettete Liste ist so implemetiert, dass hier

3 16 * alle Methoden, außer tostring (), eine asymptotische Laufzeit 17 * von O (1) haben. 18 * 19 * <br > 20 Christian Grümme 21 * 22 <T> Typ der Elemente 23 * 24 */ 25 public class ListDeque <T> implements Deque <T> { /** Interne Liste zur Verwaltung der Elemente */ 28 List <T> list ; /** Konstruktor */ 31 public ListDeque () { 32 this. list = new DoubleLinkedList <T >() ; 33 } /* (non - Javadoc ) 36 alp3. zettel05.a1. Deque # first () 37 */ 38 public T first () throws NoSuchElementException { 39 try { 40 return this. list. get (0) ; 41 } catch ( IndexOutOfBoundsException e) { 42 throw new NoSuchElementException (" Deque is Emtpy "); 43 } 44 } /* (non - Javadoc ) 47 alp3. zettel05.a1. Deque # get () 48 */ 49 public T removelast () throws NoSuchElementException { 50 // Löscht das letzte Element in der Liste und gibt es zurück 51 try { 52 return this. list. remove ( this. list. size () -1); 53 } catch ( IndexOutOfBoundsException e) { 54 throw new NoSuchElementException (" Deque is Emtpy "); 55 } 56 } /* (non - Javadoc ) 59 alp3. zettel05.a1. Deque # isempty () 60 */ 61 public boolean isempty () { 62 return this. list. isempty (); 63 } /* (non - Javadoc ) 66 alp3. zettel05.a1. Deque # last () 67 */ 68 public T last () throws NoSuchElementException { 69 try { 70 return this. list. get ( this. list. size () -1); 71 } catch ( IndexOutOfBoundsException e) { 72 throw new NoSuchElementException (" Deque is Emtpy "); 73 } 74 } /* (non - Javadoc ) 77 alp3. zettel05.a1. Deque # pop () 78 */ 79 public T removefirst () throws NoSuchElementException { 80 // Löscht das vorderste Element in der Liste und gibt es zurück 81 try { 82 return this. list. remove (0) ; 83 } catch ( IndexOutOfBoundsException e) { 84 throw new NoSuchElementException (" Deque is Emtpy "); 85 } 86 } /* (non - Javadoc ) 89 alp3. zettel05.a1. Deque # push ( java. lang. Object ) 90 */

4 91 public void insertfirst ( T value ) { 92 // Füge vorne in die Liste ein 93 this. list. add (0, value ); 94 } /* (non - Javadoc ) 97 alp3. zettel05.a1. Deque # put ( java. lang. Object ) 98 */ 99 public void insertlast ( T value ) { 100 // Füge hinten in die Liste ein 101 this. list. add ( value ); 102 } /* (non - Javadoc ) 105 alp3. zettel05.a1. Deque # size () 106 */ 107 public int size () { 108 return this. list. size (); 109 } /* (non - Javadoc ) 112 java. lang. Object # tostring () 113 */ 114 public String tostring () { 115 return this. list. tostring (); 116 } 117 } class ArrayDeque 1 /** 2 * Algorithmen und Programmierung III WS2006 /07 3 * 5. Aufgabenblatt 4 * Aufgabe 1 5 */ 6 package alp3. zettel05. a1; 7 8 import java. util. NoSuchElementException ; 9 10 /** 11 * Implementierung der Deque durch Speicherung in deinem Feld. 12 * <br > 13 * <br > 14 * Diese die Methode tostring () hat eine asymptotische Laufzeit von O( n). 15 * <br > 16 * normalizearray () hat im Worst Case eine asymptotische Laufzeit von O( n). 17 * Da insertfirst (), removefirst (), insertlast () und removelast () 18 * normalizearray () aufrufen können, haben sie im WorstCase auch eine 19 * asymptotische Laufzeit von O( n). Aber das amotisiert sich im Normalfall, 20 * so dass diese Methode im Mittel eine asymptotische Laufzeit von O (1). 21 * <br > 22 * Die restlichen drei Methoden, first (), last (9 und size () haben eine 23 * asymptotische Laufzeit von O (1). 24 * 25 * <br > 26 Christian Grümme 27 * 28 <T> Typ der Elemente 29 * 30 */ 31 public class ArrayDeque <T> implements Deque <T> { /** Feld zum Speichern der Elemente */ 34 private T[] elements ; 35 /** Größe mit der das Feld initializiert wurde */ 36 private int init_size = 64; 37 /** Zeiger auf den nächsten ( rechten ) leeren Feldplatz */ 38 private int top ; 39 /** Zeiger auf das vorderste ( links ) Element 40 * Wenn das Feld leer ist, dann entspicht es top. */ 41 private int bottom ; /** 44 * Konstruktor, der das interne Feld standardmäßig mit 45 * einer Größe von 64 initalisiert.

5 46 * 47 */ (" unchecked ") 49 public ArrayDeque () { 50 this. elements = ( T []) new Object [ this. init_size ]; 51 // Damit in der Mitte angefangen wird einzufügen 52 this. top = this. init_size /2; 53 this. bottom = this. init_size /2; 54 } /** 57 * Konstruktor inizialisiert das Feld mit der gegebenen Größe. 58 size Inizalisierungsgröße vom internem Feld 59 */ (" unchecked ") 61 public ArrayDeque ( int size ) { 62 this. init_size = size ; 63 this. elements = ( T []) new Object [ this. init_size ]; 64 // Damit in der Mitte angefangen wird einzufügen 65 this. top = this. init_size /2; 66 this. bottom = this. init_size /2; 67 } /* (non - Javadoc ) 70 alp3. zettel05.a1. Deque # first () 71 */ 72 public T first () throws NoSuchElementException { 73 if( this. top == this. bottom ) { 74 throw new NoSuchElementException (" Deque is Emtpy "); 75 } else { 76 return this. elements [ this. bottom ]; 77 } 78 } /* (non - Javadoc ) 81 alp3. zettel05.a1. Deque # get () 82 */ 83 public T removelast () throws NoSuchElementException { 84 if( this. top == this. bottom ) { 85 throw new NoSuchElementException (" Deque is Emtpy "); 86 } else { 87 T result = this. elements [ this. top -1]; 88 // Für den Garbish Collector 89 this. elements [ this.top -1] = null ; 90 this.top - -; 91 this. normalizearray (); 92 return result ; 93 } 94 } /* (non - Javadoc ) 97 alp3. zettel05.a1. Deque # isempty () 98 */ 99 public boolean isempty () { 100 return ( this. top == this. bottom ); 101 } /* (non - Javadoc ) 104 alp3. zettel05.a1. Deque # last () 105 */ 106 public T last () throws NoSuchElementException { 107 if( this. top == this. bottom ) { 108 throw new NoSuchElementException (" Deque is Emtpy "); 109 } else { 110 return this. elements [ this.top -1]; 111 } 112 } /* (non - Javadoc ) 115 alp3. zettel05.a1. Deque # pop () 116 */ 117 public T removefirst () throws NoSuchElementException { 118 // Löscht das vorderste Element in der Liste und gibt es zurück 119 if( this. top == this. bottom ) { 120 throw new NoSuchElementException (" Deque is Emtpy ");

6 121 } else { 122 T result = this. elements [ this. bottom ]; 123 // Für den Garbish Collector 124 this. elements [ this. bottom ] = null ; 125 this. bottom ++; 126 this. normalizearray (); 127 return result ; 128 } 129 } /* (non - Javadoc ) 132 alp3. zettel05.a1. Deque # push ( java. lang. Object ) 133 */ 134 public void insertfirst ( T value ) { 135 if( this. bottom == 0) { 136 // Zeiger aus das Vorderste Element ist ganz vorne angekommen 137 this. normalizearray (); 138 } 139 // Speicher Verweis auf das neue Element 140 this. elements [ this. bottom ] = value ; 141 // Dekrementiere Zeiger auf den nächsten leeren Platz im Feld 142 this. bottom - -; 143 } /* (non - Javadoc ) 146 alp3. zettel05.a1. Deque # put ( java. lang. Object ) 147 */ 148 public void insertlast ( T value ) { 149 if( this. top == this. elements. length ) { 150 // Feld ist voll, erzeuge neues mit doppelter Größe 151 this. normalizearray (); 152 } 153 // Speicher Verweis auf das neue Element 154 this. elements [ this. top ] = value ; 155 // Inkrementiere Zeiger auf den nächsten leeren Platz im Feld 156 this. top ++; 157 } /* (non - Javadoc ) 160 alp3. zettel05.a1. Deque # size () 161 */ 162 public int size () { 163 return ( this. top - this. bottom ); 164 } /* (non - Javadoc ) 167 java. lang. Object # tostring () 168 */ 169 public String tostring () { 170 StringBuffer sb = new StringBuffer (); 171 if ( this. top == this. bottom ) { 172 // Es existiert kein Element im Feld 173 sb. append (" null <-->"); 174 } else { 175 for ( int i = this. bottom ; i < this. top ; i ++) { 176 sb. append ( this. elements [i]. tostring ()); 177 sb. append (" <--> "); 178 } 179 } 180 return sb. tostring (); 181 } /** 184 * Diese Methode überprüft, ob das interne Feld verändert werden muss. 185 * 1. Fall : Es ist schon zu mehr als zu 2/3 belegt. 186 * Dann wird die Feldgröße verdoppelt und die Elemente werden 187 * so kopiert, dass sich links und rechts von der Mitte des 188 * Feldes gleich viele Elemente befinden. 189 * 2. Fall : Es ist zu weniger als zu 1/4 belegt. 190 * Dann wird die Feldgröße halbiert und die Elemente werden so 191 * kopiert, dass sich links und rechts von der Mitte des Feldes 192 * gleich viele Elemente befinden. 193 * 3. Fall : Fall 1 und 2 treffen nicht zu, aber Zeiger, also bottom oder 194 * top, stoßen an die Grenzen des Feldes. 195 * Nun werden nur die Elemente so verschoben, dass sich links

7 196 * und rechts von der Mitte des Feldes gleich viele Elemente 197 * befinden. 198 */ (" unchecked ") 200 private void normalizearray () { 201 // Bestimme Mitte der Befüllung 202 int middle = ( this. top - this. bottom )/2 + this. bottom ; 203 int size = this. top - this. bottom ; 204 if (( this. top - this. bottom ) >= ((2 * this. elements. length ) / 3)) { 205 // Feld ist min. zu 2/3 gefüllt, also erdopple ich das Feld 206 T[] newarray = ( T []) new Object [ this. elements. length *2]; 207 // Berechne den neuen Index des vordersten Elements 208 int new_middle = newarray. length /2; 209 int new_bottom = this. bottom - ( middle - new_middle ); 210 // Kopiere alles Einträge ins neue Feld 211 System. arraycopy ( this. elements, this. bottom, newarray, 212 new_bottom, size ); 213 // Setzte Zeiger neu 214 this. bottom = new_bottom ; 215 this. top = new_bottom + size ; 216 // Neues Array ist neues globles Feld 217 this. elements = newarray ; 218 } else if (( this. top - this. bottom ) <= ( this. elements. length / 4) 219 && ( this. elements. length > this. init_size ) ) { 220 // Feld weniger als zu ein Viertel gefüllt 221 // Erzeuge neues mit halber Größe 222 T[] newarray = ( T []) new Object [ this. elements. length /2]; 223 // Berechne den neuen Index des vordersten Elements 224 int new_middle = newarray. length /2; 225 int new_bottom = this. bottom - ( middle - new_middle ); 226 // Kopiere alles Einträge ins neue Feld 227 System. arraycopy ( this. elements, this. bottom, newarray, 228 new_bottom, size ); 229 // Setzte Zeiger neu 230 this. bottom = new_bottom ; 231 this. top = new_bottom + size ; 232 // Neues Array ist neues globles Feld 233 this. elements = newarray ; 234 } else if( this. bottom == 0 this. top == this. elements. length ) { 235 /* Feld ist nicht zu voll oder zu leer, aber Ränder erreicht, 236 also verschiebe nur die Elemente in die Mitte */ 237 // Berechne den neuen Index des vordersten Elements 238 int new_middle = this. elements. length /2; 239 int new_bottom = this. bottom - ( middle - new_middle ); 240 // Verschiebe Elemente 241 System. arraycopy ( this. elements, this. bottom, this. elements, 242 new_bottom, size ); 243 // Setzte Zeiger neu 244 this. bottom = new_bottom ; 245 this. top = new_bottom + size ; 246 } 247 } 248 } Aufgabe 2 Datenabstraktion in Sprachen Aufgabe 3 Ausnahmen und Fehler 10 Punkte 10 Punkte