Algorithmen und Programmierung III

Transkript

1 Musterlösung zum 3. Aufgabenblatt zur Vorlesung WS 2006 Algorithmen und Programmierung III von Christian Grümme Aufgabe 1 Potenzieren von Matrizen Testlauf der Klasse Matrix.java: 10 Punkte Erzeuge Matrix der Dimension 250 Potenziere normal mit Potenz 50:... Gebrauchte Zeit: Millisekunden Anzahl der Multiplikationen: Potenziere schnell mit Potenz 50:... Gebrauchte Zeit: Millisekunden Anzahl der Multiplikationen: Effizenz: 7 class Matrix 1 /** 2 * Algorithmen und Programmierung III WS2006 /07 3 * 3. Aufgabenblatt 4 * Aufgabe 2 5 */ 6 package alp3. zettel03. a1; 7 8 /** 9 * Klasse zum Vergleich der Matrixmultiplikation 10 * 11 Christian Grümme */ public class Matrix { /** Globales mitzählen der Multiplikationen */ 18 private long amount = 0; /**

2 21 * Gibt eine Identitätsmatrix der gegeben Dimension zurück 22 n Dimension der Identitätsmatrix, natürliche Zahl 23 Identitätsmatrix der gegebenen Dimension 24 */ 25 private long [][] getidentity ( int n) { 26 long [][] result = new long [n][n]; 27 // Durchlauf die Matrix 28 for ( int i = 0; i < n; ++i) { 29 for ( int j = 0; j < n; ++j) { 30 if( i == j) { 31 // Diagonale, also 1 32 result [ i][ j] = 1; 33 } else { 34 // Sonst 0 35 result [ i][ j] = 0; 36 } 37 } 38 } 39 return result ; 40 } /** 43 * Multipiziert zwei Matrizen und gibt das Produkt zurück 44 a Der linke Faktor 45 b Der rechte Faktor 46 Die multiplizierte Matrix ( a* b) 47 */ 48 private long [][] multiplicate ( long [][] a, long [][] b) { 49 if( b. length!= a [0]. length ) { 50 throw new IllegalArgumentException (" Dimentions do not match "); 51 } 52 // Die Dimensionen 53 int l = a. length ; 54 int m = a [0]. length ; 55 int n = b [0]. length ; 56 // Anzahl der Multiplicationen ; 57 long [][] c = new long [l ][n]; 58 // Durchlauf der Matrizen 59 for ( int i = 0; i < l; ++i) { 60 for ( int j = 0; j < n; ++j) { 61 c[ i][ j] = 0; 62 for ( int k = 0; k < m; ++k) { 63 c[i][j] += a[i][k] * b[k][j]; 64 this. amount ++; 65 if( this. amount % == 0) { 66 System. out. print ("."); 67 } 68 } 69 } 70 } 71 return c; 72 } /** 75 * Potenziert die gegebene Matrix mit der gegebenen Potenz 76 a Die zupotenzierende Matrix 77 n Die Potenz, natürliche Zahl 78 Die Potenz a^n 79 */ 80 public long [][] powers ( long [][] a, int n) { 81 if( n < 0) 82 throw new IllegalArgumentException (" n is not positiv "); 83 if( n == 0) 84 return this. getidentity (a. length ); 85 if( n == 1) 86 return a; 87 long [][] result = this. getidentity ( a. length ); 88 for ( int i = 0; i < n ;++ i) { 89 result = this. multiplicate ( result, a); 90 } 91 return result ; 92 } /** 95 * Potenziert die gegebene Matrix mit der gegebenen Potenz nach der schnellen

3 Methode 96 a Die zupotenzierende Matrix 97 n Die Potenz, natürliche Zahl 98 Die Potenz a^n 99 */ 100 public long [][] fastpowers ( long [][] a, int n) { 101 if( n < 0) 102 throw new IllegalArgumentException (" n is not positiv "); 103 if( n == 0) 104 return this. getidentity ( a. length ); 105 if( n == 1) 106 return a; 107 if (( n % 2) == 0) { 108 // Potenz ist grade 109 long [][] temp = this. fastpowers (a, (n /2) ); 110 return this. multiplicate (temp, temp ); 111 } else { 112 // Potenz ist ungrade 113 long [][] temp = this. fastpowers (a, ((n -1) /2) ); 114 return this. multiplicate (a, this. multiplicate (temp, temp )); 115 } 116 } /** 119 * Methode für den Testlauf 120 args Kommandozeilenübergabe wird ignoriert 121 */ 122 public static void main ( String [] args ) { 123 Matrix m = new Matrix (); 124 Long time1, time2 ; 125 int dimension = 250; 126 int potenz = 50; 127 long [][] matrix = new long [ dimension ][ dimension ]; 128 System. out. println (" Erzeuge Matrix der Dimension " + dimension ); 129 for ( int i = 0; i < matrix. length ; ++i) { 130 for ( int j = 0; j < matrix [0]. length ; ++j) { 131 matrix [ i][ j] = j; 132 } 133 } (" unused ") 135 long result [][]; 136 System. out. println (" Potenziere normal mit Potenz "+ potenz +":"); 137 time1 = System. currenttimemillis (); 138 result = m. powers ( matrix, potenz ); 139 time2 = System. currenttimemillis (); 140 System. out. println (); 141 System. out. println (" Gebrauchte Zeit : "+( time2 - time1 )+" Millisekunden "); 142 System. out. println (" Anzahl der Multiplikationen : " +m. amount ); 143 long old = m. amount ; 144 m. amount = 0; 145 System. out. println (" Potenziere schnell mit Potenz "+ potenz +":"); 146 time1 = System. currenttimemillis (); 147 result = m. fastpowers ( matrix, potenz ); 148 time2 = System. currenttimemillis (); 149 System. out. println (); 150 System. out. println (" Gebrauchte Zeit : "+( time2 - time1 )+" Millisekunden "); 151 System. out. println (" Anzahl der Multiplikationen : " +m. amount ); 152 System. out. println (" Effizenz : "+( old /m. amount )); 153 } 154 } Aufgabe 2 Verkettete Listen Testlauf der Klasse TestList.java in der z03a2.jar: 10 Punkte Erzeuge Listen. Füge nun 5000 Elemente zu den Listen hinzu. Einfachverkettete Liste hat 47 Millisekunden gebraucht. Doppeltverkettete Liste hat 31 Millisekunden gebraucht. Füge nun je 5000 Elemente an zufaelligen Stellen ein.

4 Einfachverkettete Liste hat 610 Millisekunden gebraucht. Doppeltverkettete Liste hat 297 Millisekunden gebraucht. Schaue, ob Element3647 in den Listen existiert. Einfachverketteten Liste: true Doppeltverketteten Liste: true Nehme nun je 5000 Elemente an zufaelligen Stellen. Einfachverkettete Liste hat 359 Millisekunden gebraucht. Doppeltverkettete Liste hat 422 Millisekunden gebraucht. Lösche die ersten 5000 Elemente aus den Listen. Einfachverkettete Liste hat 7094 Millisekunden gebraucht. Doppeltverkettete Liste hat 7282 Millisekunden gebraucht. Lösche die ersten 2500 Indexes aus den Listen. Einfachverkettete Liste hat 62 Millisekunden gebraucht. Doppeltverkettete Liste hat 47 Millisekunden gebraucht. interface List 1 /** 2 * Algorithmen und Programmierung III WS2006 /07 3 * 3. Aufgabenblatt 4 * Aufgabe 2 5 */ 6 package alp3. zettel03. a2; 7 8 /** 9 * Dies ist das Interface für eine generische Liste. 10 * 11 Christian Grümme 12 * 13 <T> Typ der Elemente 14 */ 15 public interface List <T> { /** 18 * Fügt gegebenes Element hinten an die Liste an. 19 value Das hinten einzufügende Element 20 */ 21 public void add ( T value ); /** 24 * Fügt gegebenes Element an die Stelle index in die Liste ein 25 * und verschiebt alle nachfolgenden Elemente einen Index nach hinten. 26 value Das vorne einzufügende Element 27 IndexOutOfBoundsException Wenn der Index kein Listenelement 28 * entspricht 29 * ( index < 0 index > size ()) 30 */ 31 public void add ( int index, T value ) throws IndexOutOfBoundsException ; /** 34 * Methode um zu überprüfen, ob der übergebene Wert in der Liste 35 * existiert. 36 value Der zu überprüfende Wert 37 */ 38 public boolean contains ( T value ); /** 41 * Gibt den Wert des Elementes an der gegebenen Position zurück. 42 index Index des gesuchten Element 43 Wert des gesuchtes Element 44 IndexOutOfBoundsException Wenn der Index kein Listenelement 45 * entspricht 46 * ( index < 0 index >= size ()) 47 */ 48 public T get ( int index ) throws IndexOutOfBoundsException ; /** 51 * Löscht das Listenelement mit dem gegebenen Index.

5 52 index Index des zu löschenden Listenelements 53 Wert des gelöschten Elementes 54 IndexOutOfBoundsException Wenn der Index kein Listenelement 55 * entspricht 56 * ( index < 0 index >= size ()) 57 */ 58 public T remove ( int index ) throws IndexOutOfBoundsException ; /** 61 * Löscht alle Listenelemente mit dem gegebenen Wert. 62 value Wert der zu löschenden Listenelemente 63 Gibt an, ob mindestens ein Element gelöscht wurde 64 */ 65 public boolean removeall ( T value ); /** 68 * Löscht alle Elemente aus der Liste. 69 */ 70 public void clear (); /** 73 * Prüft, ob die Liste leer ist. 74 Falsch, wenn mindestens ein Element vorhanden ist 75 */ 76 public boolean isempty (); /** 79 * Gibt die Anzahl der in der Double - Ended - Queue enthaltenen Elemente 80 * zurück. 81 Anzahl der Elemente in der Double - Ended - Queue 82 */ 83 public int size (); 84 } class LinkedList 1 /** 2 * Algorithmen und Programmierung III WS2006 /07 3 * 3. Aufgabenblatt 4 * Aufgabe 2 5 */ 6 package alp3. zettel03. a2; 7 8 /** 9 * Dies ist eine einfach verkettete Liste, die das List - Interface 10 * implementiert. 11 * <br > 12 * <br > 13 * Die Methoden add ( T value ) und size () haben eine 14 * asymptotische Laufzeit von O (1) 15 * <br > 16 * Die Methoden add ( int index, T value ), remove ( int index ) 17 * und get ( int index ) haben jeweils für den ersten und aktuell 18 * letzten Index eine Laufzeit von O (1), sonst O( index ). 19 * <br > 20 * Die übrigen Methoden haben eine Laufzeit von O( n), wobei n 21 * die Anzahl der Elemente in der Liste ist. 22 * 23 * <br > 24 * <br > 25 Christian Grümme 26 * 27 <T> Typ der Elemente 28 */ 29 public class LinkedList <T> implements List <T> { /** 32 * Klasse für die Listenelemente 33 */ 34 private class ListElement { 35 /** Zeiger auf das Nachfolgerelement */ 36 private ListElement next = null ; 37 /** wert des Elementes */ 38 private T value = null ; 39

6 40 /** 41 * Konstruktor des Listenelements 42 next Nachfolger des Listenelements 43 value Wert des Listenelements 44 */ 45 ListElement ( ListElement next, T value ) { 46 this. next = next ; 47 this. value = value ; 48 } /** 51 * Gibt den Wert des Listenelements zurück. 52 Wert des Listenelements 53 */ 54 T getvalue () { 55 return this. value ; 56 } /** 59 * Gibt den Nächfolger des Listenelements zurück. 60 Nächfolger des Listenelements 61 */ 62 ListElement getnext () { 63 return this. next ; 64 } /** 67 * Setzt den Nächfolger des Listenelements zurück. 68 next Nächfolger des Listenelements 69 */ 70 void setnext ( ListElement next ) { 71 this. next = next ; 72 } /** 75 * Löscht alle Verweise aus dem Element. 76 * Dies wird gemacht, damit diese Verweise nicht noch auf nicht 77 * mehr verwendete Objekte zeigen, damit der Garbish Collector sie 78 * abräumen kann. 79 */ 80 public void clear () { 81 this. next = null ; 82 this. value = null ; 83 } 84 } 85 /** Zeiger auf das erste Listenelement */ 86 private ListElement head = null ; 87 /** Zeiger auf das letzte Listenelement */ 88 private ListElement tail = null ; 89 /** Anzahl der Listenelemente in der Liste */ 90 private int size = 0; /* (non - Javadoc ) 93 alp3. zettel03.a2. List # add ( java. lang. Object ) 94 */ 95 public void add ( T value ) { 96 // Erzeuge neues Listenelement 97 ListElement newelement = new ListElement ( null, value ); 98 // Fall : Liste ist leer 99 if( this. tail == null ) { 100 this. head = newelement ; 101 } else { 102 // Setzte Nachfolger vom aktuellen letzten Listenelement 103 this. tail. setnext ( newelement ); 104 } 105 // Setze Listenende neu 106 this. tail = newelement ; 107 // Inkrementiere Listenelementzähler 108 this. size ++; 109 } /* (non - Javadoc ) 112 alp3. zettel03.a2. List # add (int, java. lang. Object ) 113 */ 114 public void add ( int index, T value ) throws IndexOutOfBoundsException {

7 115 // Überprüfe Gültigkeit des Indexes 116 if( index < 0 index > size ) { 117 throw new IndexOutOfBoundsException (" Index " + index +" is invalid "); 118 } 119 if( index == this. size ) { 120 // Füge hinten an bzw. wenn die Liste leer ist, dann auch vorne 121 this. add ( value ); 122 } else if ( index == 0) { 123 // Füge vorne an, wenn die Liste nicht leer ist 124 // Erzeuge neues Listenelement 125 ListElement newelement = new ListElement ( this. head, value ); 126 this. head = newelement ; 127 // Inkrementiere Listenelementzähler 128 this. size ++; 129 } else { 130 ListElement current = this. head ; 131 // Traversiere zum Listenelement mit Index ( index -1) 132 for ( int i = 0; i < ( index -1) ; i ++) { 133 current = current. getnext (); 134 } 135 // Erzeuge neues Listenelement 136 ListElement newelement = new ListElement ( current. getnext (), value ); 137 current. setnext ( newelement ); 138 // Inkrementiere Listenelementzähler 139 this. size ++; 140 } 141 } /* (non - Javadoc ) 144 alp3. zettel03.a2. List # clear () 145 */ 146 public void clear () { 147 // Aktuelles Listenelement 148 ListElement current = this. head ; 149 // Für die temporäre Speicherung des nächsten Listenelement 150 ListElement next = this. head ; 151 while ( current!= null ) { 152 next = current. getnext (); 153 // Lösche alle Verweise aus den Elementen 154 current. clear (); 155 current = next ; 156 } 157 // Setzte Membervariabeln zurück 158 this. head = null ; 159 this. tail = null ; 160 this. size = 0; 161 } /* (non - Javadoc ) 164 alp3. zettel03.a2. List # contains ( java. lang. Object ) 165 */ 166 public boolean contains ( T value ) { 167 ListElement current = this. head ; 168 while ( current!= null ) { 169 if( current. getvalue (). equals ( value )) { 170 return true ; 171 } else { 172 current = current. getnext (); 173 } 174 } 175 return false ; 176 } /* (non - Javadoc ) 179 alp3. zettel03.a2. List # get ( int ) 180 */ 181 public T get ( int index ) throws IndexOutOfBoundsException { 182 // Überprüfe Gültigkeit des Indexes 183 if( index < 0 index >= size ) { 184 throw new IndexOutOfBoundsException (" Index " + index +" is invalid "); 185 } 186 // Überprüfung auf letztes Listenelement 187 if ( index == ( size - 1)) { 188 return this. tail. getvalue (); 189 } else {

8 190 ListElement current = this. head ; 191 // Traversiere zum Listenelement mit Index index 192 for ( int i = 0; i < index ; i ++) { 193 current = current. getnext (); 194 } 195 return current. getvalue (); 196 } 197 } /* (non - Javadoc ) 200 alp3. zettel03.a2. List # isempty () 201 */ 202 public boolean isempty () { 203 return this. size () == 0; 204 } /* (non - Javadoc ) 207 alp3. zettel03.a2. List # remove ( int ) 208 */ 209 public T remove ( int index ) throws IndexOutOfBoundsException { 210 // Überprüfe Gültigkeit des Indexes 211 if( index < 0 index >= size ) { 212 throw new IndexOutOfBoundsException (" Index " + index +" is invalid "); 213 } 214 T result ; 215 ListElement current = this. head ; 216 if( index == 0) { 217 // Das zu löschende ist das erste Element 218 this. head = current. getnext (); 219 if( current. getnext () == null ) { 220 // Es ist auch das einzige Element 221 this. tail = null ; 222 } 223 result = current. getvalue (); 224 current. clear (); 225 } else if ( index == ( this. size -1) ) { 226 // Das zu löschende ist das letzte Element, aber nicht das einzige 227 // Traversiere zum vorletztem Element 228 for ( int i = 0; i < ( index -1) ; i ++) { 229 current = current. getnext (); 230 } 231 current. setnext ( null ); 232 result = this. tail. getvalue (); 233 this. tail. clear (); 234 this. tail = current ; 235 } else { 236 // Traversiere zum Listenelement mit Index ( index -1) 237 for ( int i = 0; i < ( index -1) ; i ++) { 238 current = current. getnext (); 239 } 240 ListElement todelete = current. getnext (); 241 current. setnext ( todelete. getnext ()); 242 result = todelete. getvalue (); 243 todelete. clear (); 244 } 245 // Dekrementiere Listenelementezähler 246 this.size - -; 247 return result ; 248 } /* (non - Javadoc ) 251 alp3. zettel03.a2. List # removeall ( java. lang. Object ) 252 */ 253 public boolean removeall ( T value ) { 254 boolean wasdeleted = false ; 255 ListElement current = this. head ; 256 while ( value. equals ( this. head. getvalue ())) { 257 current = this. head. getnext (); 258 this. head. clear (); 259 this.size - -; 260 wasdeleted = true ; 261 this. head = current ; 262 if( this. head == null ) { 263 this. tail = null ; 264 }

9 265 } 266 ListElement priv = null ; 267 while ( current!= null ) { 268 if( value. equals ( current. getvalue ())) { 269 // Lösche Element 270 ListElement next = current. getnext (); 271 if( current == this. head ) { 272 this. head = next ; 273 } 274 if( current == this. tail ) { 275 this. tail = priv ; 276 } 277 current. clear (); 278 this.size - -; 279 wasdeleted = true ; 280 priv. setnext ( next ); 281 current = next ; 282 } else { 283 priv = current ; 284 current = current. getnext (); 285 } 286 } 287 return wasdeleted ; 288 } /* (non - Javadoc ) 291 alp3. zettel03.a2. List # size () 292 */ 293 public int size () { 294 return this. size ; 295 } /* (non - Javadoc ) 298 java. lang. Object # tostring () 299 */ 300 public String tostring () { 301 StringBuffer sb = new StringBuffer (); 302 ListElement current = this. head ; 303 sb. append (" Head == "); 304 if ( current == null ) { 305 // Es existiert kein Element in der Liste 306 sb. append (" null "); 307 } 308 // Laufvariabel für den Index 309 int index = 0; 310 while ( current!= null ) { 311 sb. append ( index +": "); 312 sb. append ( current. getvalue ()); 313 sb. append (" --> "); 314 current = current. getnext (); 315 index ++; 316 } 317 sb. append (" == Tail Size : "+ this. size ); 318 return sb. tostring (); 319 } 320 } class DoubleLinkedList 1 /** 2 * Algorithmen und Programmierung III WS2006 /07 3 * 3. Aufgabenblatt 4 * Aufgabe 2 5 */ 6 package alp3. zettel03. a2; 7 8 /** 9 * Dies ist eine doppelt verkettete Liste, die das List - Interface 10 * implementiert. 11 * <br > 12 * <br > 13 * Die Methoden add ( T value ) und size () haben eine 14 * asymptotische Laufzeit von O (1). 15 * <br > 16 * Die Methoden add ( int index, T value ), remove ( int index ) und

10 17 * get ( int index ) haben jeweils für den ersten und aktuell letzten 18 * Index eine Laufzeit von O (1), sonst O( index ) für index < n/2 19 * und O(n- index ) für index > n/2, wobei n die Anzahl der Elemente 20 * in der Liste ist. 21 * <br > 22 * Die übrigen Methoden haben eine Laufzeit von O( n). 23 * 24 * <br > 25 * <br > 26 Christian Grümme 27 * 28 <T> Typ der Elemente 29 */ 30 public class DoubleLinkedList <T> implements List <T> { /** 33 * Klasse für die Listenelemente 34 */ 35 private class ListElement { 36 /** Zeiger auf das Vorgängerelement */ 37 private ListElement priv = null ; 38 /** Zeiger auf das Nachfolgerelement */ 39 private ListElement next = null ; 40 /** wert des Elementes */ 41 private T value = null ; /** 44 * Konstruktor des Listenelements 45 priv Vorgänger des Listenelements 46 next Nachfolger des Listenelements 47 value Wert des Listenelements 48 */ 49 ListElement ( ListElement priv, ListElement next, T value ) { 50 this. priv = priv ; 51 this. next = next ; 52 this. value = value ; 53 } /** 56 * Gibt den Wert des Listenelements zurück. 57 Wert des Listenelements 58 */ 59 T getvalue () { 60 return this. value ; 61 } /** 64 * Gibt den Vorgänger des Listenelements zurück. 65 Vorgänger des Listenelements 66 */ 67 ListElement getpriv () { 68 return this. priv ; 69 } /** 72 * Setzt den Vorgänger des Listenelements zurück. 73 priv Vorgänger des Listenelements 74 */ 75 void setpriv ( ListElement priv ) { 76 this. priv = priv ; 77 } /** 80 * Gibt den Nachfolger des Listenelements zurück. 81 Nachfolger des Listenelements 82 */ 83 ListElement getnext () { 84 return this. next ; 85 } /** 88 * Setzt den Nachfolger des Listenelements zurück. 89 next Nachfolger des Listenelements 90 */ 91 void setnext ( ListElement next ) {

11 92 this. next = next ; 93 } /** 96 * Löscht alle Verweise aus dem Element. 97 * Dies wird gemacht, damit diese Verweise nicht noch auf nicht 98 * mehr verwendete Objekte zeigen, damit der Garbish Collector 99 * sie abräumen kann. 100 */ 101 public void clear () { 102 this. priv = null ; 103 this. next = null ; 104 this. value = null ; 105 } 106 } /** Erstes Listenelement */ 109 private ListElement head = null ; 110 /** Letztes Listenelement */ 111 private ListElement tail = null ; 112 /** Anzahl der Listenelemente */ 113 private int size = 0; /* (non - Javadoc ) 116 alp3. zettel03.a2. List # add ( java. lang. Object ) 117 */ 118 public void add ( T value ) { 119 // Erzeuge neues Listenelement 120 ListElement newelement = new ListElement ( this. tail, null, value ); 121 // Fall : Liste ist leer 122 if( this. tail == null ) { 123 this. head = newelement ; 124 } else { 125 // Setzte Nachfolger vom aktuellen letzten Listenelement 126 this. tail. setnext ( newelement ); 127 } 128 // Setze Listenende neu 129 this. tail = newelement ; 130 // Inkrementiere Listenelementzähler 131 this. size ++; 132 } /* (non - Javadoc ) 135 alp3. zettel03.a2. List # add (int, java. lang. Object ) 136 */ 137 public void add ( int index, T value ) throws IndexOutOfBoundsException { 138 // Überprüfe Gültigkeit des Indexes 139 if( index < 0 index >= size ) { 140 throw new IndexOutOfBoundsException (" Index " + index +" is invalid "); 141 } 142 // Überprüfung, ob hinten angefügt werden soll 143 if( index == this. size -1) { 144 this. add ( value ); 145 return ; 146 } 147 ListElement current ; 148 // Traversiere zum Platz wo das neue Listenelement gefügt werden soll 149 if( index < size /2) { 150 current = this. head ; 151 // Traversiere vorwärts 152 for ( int i = 0; i < index ; i ++) { 153 current = current. getnext (); 154 } 155 } else { 156 current = this. tail ; 157 // Traversiere rückwärts 158 for ( int i = ( this.size -1) ; i > index ;i - -) { 159 current = current. getpriv (); 160 } 161 } 162 // Erzeuge neues Listenelement 163 ListElement newelement = 164 new ListElement ( current. getpriv (),current, value ); 165 // Setze den Nachfolger vom Vorgänger neu 166 if( newelement. getpriv ()!= null ) {

12 167 newelement. getpriv (). setnext ( newelement ); 168 } else { 169 this. head = newelement ; 170 } 171 // Setze dev Vorgänger vom Nachfolger neu 172 current. setpriv ( newelement ); 173 // Inkrementiere Listenelementzähler 174 this. size ++; 175 } /* (non - Javadoc ) 178 alp3. zettel03.a2. List # clear () 179 */ 180 public void clear () { 181 // Aktuelles Listenelement 182 ListElement current = this. head ; 183 // Für die temporäre Speicherung des nächsten Listenelement 184 ListElement next = this. head ; 185 while ( current!= null ) { 186 next = current. getnext () ; 187 // Lösche alle Verweise aus den Elementen 188 current. clear (); 189 current = next ; 190 } 191 // Setzte Membervariabeln zurück 192 this. head = null ; 193 this. tail = null ; 194 this. size = 0; 195 } /* (non - Javadoc ) 198 alp3. zettel03.a2. List # contains ( java. lang. Object ) 199 */ 200 public boolean contains ( T value ) { 201 ListElement current = this. head ; 202 while ( current!= null ) { 203 if( current. getvalue (). equals ( value )) { 204 return true ; 205 } else { 206 current = current. getnext (); 207 } 208 } 209 return false ; 210 } /* (non - Javadoc ) 213 alp3. zettel03.a2. List # get ( int ) 214 */ 215 public T get ( int index ) throws IndexOutOfBoundsException { 216 // Überprüfe Gültigkeit des Indexes 217 if( index < 0 index >= size ) { 218 throw new IndexOutOfBoundsException (" Index " + index +" is invalid "); 219 } 220 ListElement current ; 221 // Traversiere zum zu löschendegefordertem Listenelement 222 if( index < size /2) { 223 current = this. head ; 224 // Traversiere vorwärts 225 for ( int i = 0; i < index ; i ++) { 226 current = current. getnext (); 227 } 228 } else { 229 current = this. tail ; 230 // Traversiere rückwärts 231 for ( int i = ( this.size -1) ; i > index ;i - -) { 232 current = current. getpriv (); 233 } 234 } 235 return current. getvalue (); 236 } /* (non - Javadoc ) 239 alp3. zettel03.a2. List # isempty () 240 */ 241 public boolean isempty () {

13 242 return this. size () == 0; 243 } /* (non - Javadoc ) 246 alp3. zettel03.a2. List # remove ( int ) 247 */ 248 public T remove ( int index ) throws IndexOutOfBoundsException { 249 // Überprüfe Gültigkeit des Indexes 250 if( index < 0 index >= size ) { 251 throw new IndexOutOfBoundsException (" Index " + index +" is invalid "); 252 } 253 // Hole zu löschendes Element 254 ListElement current ; 255 // Traversiere zum zu löschendem Listenelement 256 if( index < size /2) { 257 current = this. head ; 258 // Traversiere vorwärts 259 for ( int i = 0; i < index ; i ++) { 260 current = current. getnext (); 261 } 262 } else { 263 current = this. tail ; 264 // Traversiere rückwärts 265 for ( int i = ( this.size -1) ; i > index ;i - -) { 266 current = current. getpriv (); 267 } 268 } 269 T result = current. getvalue (); 270 ListElement next = current. getnext (); 271 // Setzte Nachfolger vom Vorgänger neu 272 if( current. getpriv () == null ) { 273 this. head = current. getnext (); 274 } else { 275 current. getpriv (). setnext ( next ); 276 } 277 // Setzte Vorgänger vom Nachfolger neu 278 if( next == null ) { 279 this. tail = current. getpriv (); 280 } else { 281 next. setpriv ( current. getpriv ()); 282 } 283 // Lösche Element 284 current. clear (); 285 // Dekrementiere Listenelementezähler 286 this.size - -; 287 return result ; 288 } /* (non - Javadoc ) 291 alp3. zettel03.a2. List # removeall ( java. lang. Object ) 292 */ 293 public boolean removeall ( T value ) { 294 boolean wasdeleted = false ; 295 ListElement current = this. head ; 296 while ( current!= null ) { 297 if( value. equals ( current. getvalue ())) { 298 ListElement next = current. getnext (); 299 // Setzte Nachfolger vom Vorgänger neu 300 if( current. getpriv () == null ) { 301 this. head = current. getnext (); 302 } else { 303 current. getpriv (). setnext ( next ); 304 } 305 // Setzte Vorgänger vom Nachfolger neu 306 if( next == null ) { 307 this. tail = current. getpriv (); 308 } else { 309 next. setpriv ( current. getpriv ()); 310 } 311 // Lösche Element 312 current. clear (); 313 this.size - -; 314 wasdeleted = true ; 315 current = next ; 316 } else {

14 317 current = current. getnext (); 318 } 319 } 320 return wasdeleted ; 321 } /* (non - Javadoc ) 324 alp3. zettel03.a2. List # size () 325 */ 326 public int size () { 327 return this. size ; 328 } /* (non - Javadoc ) 331 java. lang. Object # tostring () 332 */ 333 public String tostring () { 334 StringBuffer sb = new StringBuffer (); 335 ListElement current = this. head ; 336 sb. append (" Head == "); 337 if ( current == null ) { 338 // Es existiert kein Element in der Liste 339 sb. append (" null "); 340 } 341 // Laufvariabel für den Index 342 int index = 0; 343 while ( current!= null ) { 344 sb. append ( index +": "); 345 sb. append ( current. getvalue (). tostring ()); 346 sb. append (" <--> "); 347 current = current. getnext (); 348 index ++; 349 } 350 sb. append (" == Tail Size : "+ this. size ); 351 return sb. tostring (); 352 } 353 } Die asymptotischen Laufzeiten für das Einfügen am Ende und Anfang sind konstant, T (n) O(1). Da bei jeder der beiden Löschoperationen und beim Überprüfen, ob ein Element in der Liste enthalten ist, muss jedes Mal die ganze Liste durchlaufen werden, wenn sich das gesuchte Element am Ende der List befindet, T (n) O(n). Also bei diesen Operationen unterscheiden sich die asymptotischen Laufzeiten der einfach verketteten Liste und der doppelt verketteten Liste nicht. Aufgabe 3 Rekursionsgleichungen 10 Punkte Zunächst führe ich den Rekursionsschritt solange aus bis ich zum Rekursionsanker

15 gelange. ( n ) T (n) at + f (n) ( 2 ( n ) ( n )) a at + f + f (n) ( ( 4 ( 2 n ) ( n )) ( n )) a a at + f + f + f (n) ( n ) = a 3 T ( n ) a i f 2 i ( n ) k 1 ( n ) a k T + a i f 2 k 2 i ( a log 2 n n T + n) (log 2 n) 1 ( n ) a i f 2 i Nun betrachte ich den Spezialfall f Θ ( n log 2 a) also o.b.d.a.: f = n log 2 a. Also speziell für a = 2: T (n) a log 2 n T (1) + a i ( n 2 i ) log2 a a i a log 2( n 2 i ) a i+log 2 n i log 2 2 a log 2 n n log 2 a (log 2 (n)) n log 2 a T (n) O ( n log 2 a log 2 n ) T (n) nt (1) + (log 2 (n)) n T (n) O (n log 2 n) Für a = 3: T (n) O ( n 1,58 log 2 n )

16 Betrachte nun f O ( n (log 2 a) ɛ) mit ɛ 1: In diesem Fall dominiert der linke Teil der Gleichung, d.h. f(n) spielt keine Rolle mehr. Für a = 2: T (n) a log 2 n T (1) + a i ( n 2 i ) (log2 a) ɛ a i n (log 2 a) ɛ (2 i ) (log 2 a) ɛ a i n(log 2 a) ɛ 2 log 2 ai iɛ a i n(log 2 a) ɛ a i 2 iɛ n (log 2 a) ɛ (2 ɛ ) i n(log 2 a) (2 ɛ ) log2 n 1 n ɛ 2 ɛ 1 n(log 2 a) n ɛ 1 n ɛ 2 ɛ 1 n(log 2 a) a) 2 ɛ 1 n(log2 n ɛ (2 ɛ 1) T (n) O ( n log 2 a) T (n) O (n) Für a = 3: T (n) O ( n 1,58) Betrachte nun f Ω ( n (log 2 a)+ɛ) mit ɛ 1, o.b.d.a. f(n) = (n) log 2 a : T (n) a log 2 n T (1) + a i ( n 2 i ) ɛ+log2 a a i nɛ+log 2 a 2 iɛ+log 2 ai a i nɛ+log 2 a a i 2 iɛ (log 2 n) 1 n ɛ+log 2 a n ɛ+log 2 a geom. Reihe n log 2 a T (1) + n ɛ+log 2 a ɛ 1 (2 ɛ ) i 1 (2 ɛ ) i

17 T (n) O ( n log 2 (a)+ɛ) T (n) O (f (n)) Für a = 2: T (n) O (n ɛ ) Für a = 3: T (n) O ( n 1,58+ɛ)