Lösungsvorschlag (PDF)

Algorithmik II4. ÜbungAufgabe 11Ausnahmebehandlunga) Erläutern Sie die Vorteile der Konstrukte zur Fehlerbehandlung in Java.Lösungsvorschlag:• Wartbarkeit und Übersichtlichkeit des Programmcodes:Durch die Fehlerbehandlung mit Ausnahmen ist es möglich, den normale Ausführungscodevom Ablauf im Fehlerfall zu trennen. Dadurch gewinnt der Code an Übersichtlichkeitund ist besser wartbar. Durch die Möglichkeit Fehlerarten zu kategorisieren und zugruppieren kann man gezielt auf bestimmte Fehlerarten reagieren.• Flexibilität der Fehlerbehandlung:Fehler müssen nicht dort behandelt werden wo sie auftreten. Es ist möglich, Fehler entlangder Aufrufkette weiterzureichen, so dass Sie an einer anderen Stelle behandelt werden.• Unterstützung bei der Programmierung:Der Java-Compiler überprüft ob alle angegebene Ausnahmen im Methodenrumpf auchauftreten können. Weiterhin erzwingt der Compiler die Behandlung bestimmter Fehlertypenbei der Programmierung (z.B. IO-Fehler beim Zugriff auf Dateien).b) Wie wird sichergestellt, dass bestimmte Anweisungen trotz Exception ausgeführt werden?Lösungsvorschlag:Mit dem finaly-Block werden Anweisungen angegeben, die auf jeden Fall noch ausgeführtwerden. Anweisungen, die nach Ausnahmen noch ausgeführt werden sollten sind z.B.• Datenbankverbindungen beenden• Geöffnete Dateien schliessen19. Mai - 23. Mai 2003 - 1 - Sommersemester 2003

Algorithmik II4. ÜbungAufgabe 12Arrays, sequentielle und binäre Suchea) Definieren Sie eine Klasse SearchInArray und die Methoden getMin, getMax, die jeweilsdas größte bzw. das kleinste Element aus einem Array (bestehend aus Integer-Werte) zurückliefern.Lösungsvorschlag:public class SearchInArray {int getMin(int [] array){int min = array[0];int index = 0;for (int i = 1; i < array.length; i++){if (array[i] < min) {index = i;min = array[i];}}System.out.println("Minimum = "+ min+ " an Position "+ index);return min;}int getMax(int [] array){int max = array[0];int index = 0;for (int i = 1; i < array.length; i++){if (array[i] > max) {}}index = i;max = array[i];}}System.out.println("Max = "+ max+ " an Position "+ index);return max;19. Mai - 23. Mai 2003 - 2 - Sommersemester 2003

Algorithmik II4. Übungb) Erweitern sie die in Teil a) definierte Klasse um Methoden zur sequentiellen und binären Suchein Arrays. Schreiben Sie eine Hilfsmethode zum Ausgeben aller Elementen eines Arrays.Lösungsvorschlag:public class SearchInArray {public final int NO_KEY = -1;int SeqSearch (int[] array, int key) {for (int i = 0; i < array.length; i++)if (array[i] == key)return i;return NO_KEY;}int BinSearch (int[] array, int key) {int u = 0, o = array.length ;while (u < o) {int m = (u + o) / 2;if (key == array[m] )return m;else if (key < array[m] )o = m-1;elseu = m+1;}return NO_KEY;}}19. Mai - 23. Mai 2003 - 3 - Sommersemester 2003

Algorithmik II4. ÜbungAufgabe 13Sortierena) Erklären Sie die Funktionsweise der in der Vorlesung vorgestellten Sortierverfahren Insertionsort,Selectionsort, Bubblesort, Mergesort und Quicksort.Lösungsvorschlag:• Insertionsort (Sortieren durch Einfügen)Das Prinzip von Insertionsort orientiert sich an der meschliche Vorgehensweise beimSortieren eines Stapels von Spielkarten: Man startet mit der ersten Karte einen neuenStapel und nimmt jeweils die nächste Karte des Originalstapels und fügt diese an derrichtigen Stelle in den neuen Stapel ein– Beginne mit dem zweiten Element (Element m) aus dem Array.– Alle Elemente links von diesem Element, die größer sind sollen um eine Positionnach rechts verschoben werden– Füge Element m vor dem ersten Element x links von m ein, so dass x kleiner m– Setze das Verfahren mit den weiteren Elementen fort.• Selectionsort (Sortieren durch Selektion)Das Prinzip von Selectionsort basiert auf dem Auswählen oder Selektieren des größtenElementes aus dem Array. Das größte Element wird jeweils am Ende der Folge gesetzt.Im nächsten Schritt wird die Folge ohne das größte Element betrachtet. Das Verfahrenwird solange fortgesetztt, bis nur noch ein einzelnes Element übrig bleibt• Bubblesort (Sortieren durch Vertauschen) Das Prinzip von Bubblesort basiert auf dasVertauschen von benachbarten Elementen in der Folge, die nicht in der gewünschtenSortierreihenfolge sind. Dabei wird die Folge immer wieder durchlaufen. Elemente, diegrößer sind als ihre Nachfolger überholen diese und steigen zum Ende der Folge hinauf• Mergesort (Sortieren durch Mischen)Das Mergesort-Verfahren löst das Problem der Sortierung umfangreicher Daten, die u.U.nicht mehr in den Hauptspreicher passen. Dazu wird die Folge in separate Teile zerlegt,die jeweils in den Hauptspeicher passen und getrennt voneinander sortiert werdenkönnen. Anschließend werden die sortierten Teilfolgen eingelesen und gemischt, in demdas jeweils kleinste Element der Teilfolgen gelesen und in die sortierte Folge geschriebenwird. Dabei erfordert das Mischen i.d.R. doppelten Speicherplatz.• QuicksortQuicksort ist das am häufigsten angewandte Sortierverfahren und basiert auf dem Prinzip’Teile und Herrsche’: Eine Folge wird (genauso wie bei Mergesort) in zwei Teile zerlegt,die unabhängig voneinader sortiert werden. Im Gegensatz zu Mergesort wird derMischvorgang vermieden. Bei der Zerlegung der Folge muss beim Quicksort-Verfahrenein Referenz-Element ausgewählt werden (Pivot-Element), wobei alle Elemente in dereinen Teilfolge kleiner sein sollen als das Pivot-Element und alle Elemente der anderenTeilfolge größer als das Pivot-Element sind. Das Pivot-Element kann beliebig ausgewähltwerden. Überlicherweise wird das mittlere Element ausgewählt. Nachdem einPivot-Element ausgewählt wurde, wird die Folge von links beginnend durchsucht, bisein Element gefunden wird, das größer oder gleich dem Pivot-Element ist. Gleichzeitigwird die Folge von rechts nach links durchsucht, bis ein Element gefunden wurde, das19. Mai - 23. Mai 2003 - 4 - Sommersemester 2003

Algorithmik II4. Übungkleiner als das Pivot-Element ist. Wenn die beiden gefundenen Positionen nicht gekreuztsind, bedeutet dies, dass die beiden Elemente sich in den falschen Teilfolgen befindenund vertauscht werden müssen. Die beiden Teilfolgen werden rekursiv sortiert, bis Teilfolgender Länge 0 entstehen.b) Wenden Sie schrittweise jedes dieser Verfahren auf folgende Folge an: (4, 9, 3, 2, 5, 1)Lösungsvorschlag:• Insertionsort– F=(4, 9, 3, 2, 5, 1); S=(4, 9, 3, 2, 5, 1)– F=(4, 9, 3, 2, 5, 1); S=(3, 4, 9, 2, 5, 1)– F=(3, 4, 9, 2, 5, 1); S=(2, 3, 4, 9, 5, 1);– F=(2, 3, 4, 9, 5, 1); S=(2, 3, 4, 5, 9, 1)– F=(2, 3, 4, 9, 5, 1); S=(1, 2, 3, 4, 5, 9)• Selectionsort– F=(4, 9, 3, 2, 5, 1); S=(4, 3, 2, 5, 1, 9)– F=(4, 3, 2, 5, 1, 9); S=(4, 3, 2, 1, 5, 9)– F=(4, 3, 2, 1, 5, 9); S=(3, 2, 1, 4, 5, 9)– F=(3, 2, 1, 4, 5, 9); S=(2, 1, 3, 4, 5, 9)– F=(2, 1, 3, 4, 5, 9); S=(1, 2, 3, 4, 5, 9)– F=(1, 2, 3, 4, 5, 9); S=(1, 2, 3, 4, 5, 9)• Bubblesort– Durchlauf∗ Ausgangszustand: F=(4, 9, 3, 2, 5, 1)∗ Vertauschungen: (9, 3); (9, 2); (9, 5); (9, 1)∗ Sortiere Folge: S=(4, 3, 2, 5, 1, 9)Nach dem 1. Durchlauf ist das größte Element am Ende der Folge. Damit wird nachjedem Durchlauf die zu betrachtende Folge um ein Element kleiner!– Durchlauf∗ Ausgangszustand: F=(4, 3, 2, 5, 1, 9)∗ Vertauschungen: (4, 3); (4, 2); (5,1 )∗ Sortierte Folge: S=(3, 2, 4, 1, 5, 9)– Durchlauf∗ Ausgangszustand: F=(3, 2, 4, 1, 5, 9)∗ Vertauschungen: (3, 2); (4, 1)∗ Sortierte Folge: S=(2, 3, 1, 4, 5, 9)19. Mai - 23. Mai 2003 - 5 - Sommersemester 2003

Algorithmik II4. Übung– Durchlauf∗ Ausgangszustand: F=(2, 3, 1, 4, 5, 9)∗ Vertauschungen: (3, 1)∗ Sortierte Folge: S=(2, 1, 3, 4, 5, 9)– Duchlauf∗ Ausgangszustand: F=(2, 1, 3, 4, 5, 9)∗ Vertauschungen: (2, 1)∗ Sortierte Folge: S=(1, 2, 3, 4, 5, 9)– Duchlauf∗ Ausgangszustand: F=S=(1, 2, 3, 4, 5, 9)∗ Vertauschungen: Keine, also Sortierung fertig!∗ Sortierte Folge: S=( 1, 2, 3, 4, 5, 9)• Mergesort– Split∗ F=(4, 9, 3, 2, 5, 1);∗ (4, 9, 3) (2, 5, 1)∗ (4) (9,3) (2) (5, 1)∗ (4) (9) (3) (2) (5) (1)– Merge∗ (4) (3,9) (2) (1, 5)∗ (3, 4, 9) (1, 2, 5)∗ (1, 2, 3, 4, 5, 9)Rechnerübung 6 — staticSchreiben Sie eine Klasse MeineKlasse, dieintern mitzählt, wie viele Objekte dieser Klasseerzeugt wurden. Weiterhin soll diese Klasse eineMethode anzahlObjekte() besitzen, die dieAnzahl der bisher erzeugten Objekte dieses Typsausgibt. Testen Sie die Implementierung anhand vonBeispielen.Lösungsvorschlag:public class MeineKlasse {private static int anzahlObjErzeugt = 0;19. Mai - 23. Mai 2003 - 6 - Sommersemester 2003

Algorithmik II4. ÜbungMeineKlasse() {// jedes Mal wenn ein Objekt erzeugt wird,// wird die Klassenvariable inkrementiertanzahlObjErzeugt++;}public static int anzahlObjekteErzeugt () {}return anzahlObjErzeugt;public static void main (String[] args) {MeineKlasse k1 = new MeineKlasse();MeineKlasse k2 = new MeineKlasse();}System.out.println ("Anzahl Objekte erzeugt: "+ MeineKlasse.anzahlObjekteErzeugt() );}Rechnerübung 7Bemerkung: Die folgende Aufgabe wurde im selben Wortlaut in der Algorithmik-Klausurim Frühjahr 2001 gestellt.Zur Darstellung vonVektoren in einem kartesischen Koordinatensystem sei die folgende Klasse Vektorin der Programmiersprache Java gegeben:public class Vektor {19. Mai - 23. Mai 2003 - 7 - Sommersemester 2003

Algorithmik II4. Übungprivate double komponenten[];public Vektor(int length) {if(length > 0)komponenten = new double[length];elsekomponenten = null;}}a) Schreiben sie eine Methode setKoordinate(int i, double wert),die die i-te Komponente des Vektors auf den Wert wert setzt,wenn der für i übergebene Wert korrekt ist. Im anderen Fall solldie Methode nichts tun.public void setKoordinate(int i, double wert) {if(komponenten != null&& komponenten.length > i && i >= 0)komponenten[i] = wert;}b) Ergänzen sie die Implementierung durch eine statische Methodeadd, die zwei Vektoren ⃗a und ⃗ b als Eingabeparameter hatund den Vektor ⃗a + ⃗ b zurückliefert, sofern die Vektoren⃗a und ⃗ b die gleiche Länge haben. Andernfalls sollnull zurückgeliefert werden.Hinweis: In einem kartesischen Koordinatensystem werden Vektorenkomponentenweise addiert, das heißt:19. Mai - 23. Mai 2003 - 8 - Sommersemester 2003

Algorithmik II4. Übung⎛ ⎞a 1 + b 1⃗a + ⃗ b = ⎜ ⎟⎝ . ⎠a n + b npublic static Vektor add(Vektor a, Vektor b) {if(a.komponenten.length != b.komponenten.length)return null;Vektor n = new Vektor(a.komponenten.length);for(int i=0; i < a.komponenten.length; i++)n.setKoordinate(i, a.komponenten[i] + b.komponenten[i]);return n;}c) Schreiben Sie nun eine Methode betrag, die den Betrag einesVektors berechnet und zurückliefert.Der Betrag eines Vektors ⃗a errechnet sich wie folgt:|⃗a| =√a 2 1 + ... + a 2 nVerwenden Sie zur Lösung dieser Aufgabe die Methodepublic static double Math.sqrt(double a),die das Java-System zur Verfügung stellt.public double betrag() {double summe = 0.0;for(int i=0; i < komponenten.length; i++)19. Mai - 23. Mai 2003 - 9 - Sommersemester 2003

Algorithmik II4. Übungsumme += komponenten[i];return Math.sqrt(summe);}d) Überschreiben sie außerdem die Methode public String toString(),so daß sie die Daten eines Vektors ⃗a in einen String der folgenden Formschreibt:a 1 /a 2 /.../a npublic String toString() {String s = "";for(int i=0; i

Algorithmik II4. ÜbungRechnerübung 8Schreiben Sie (entsprechend Aufgabe 12) ein Java-Programm zur Suche in Arrays und testenSie alle Methoden (getMin, getMax, sequentielle und binäre Suche) anhand des Arrays ( 2, 4, 5, 6,7, 8, 9, 11).Lösungsvorschlag:public class SearchInArray {public final int NO_KEY = -1;int SeqSearch (int[] array, int key) {for (int i = 0; i < array.length; i++)if (array[i] == key)return i;return NO_KEY;}int BinSearch (int[] array, int key) {int u = 0, o = array.length ;while (u < o) {int m = (u + o) / 2;if (key == array[m] )return m;else if (key < array[m] )o = m-1;elseu = m+1;}return NO_KEY;}int getMin(int [] array){int min = array[0];// Minimum ist erster Wertint index = 0;// durchlaufe gesamte Folgefor (int i = 1; i < array.length; i++){// falls neues Minimumif (array[i] < min) {// merke Positionindex = i;// und Wert des Minimumsmin = array[i];}}System.out.println("Minimum = "+ min19. Mai - 23. Mai 2003 - 11 - Sommersemester 2003

Algorithmik II4. Übung+ " an Position "+ index);return min;}int getMinIndex(int [] array){int min = array[0];int index = 0;for (int i = 1; i < array.length; i++){if (array[i] < min) {index = i;min = array[i];}}System.out.println("Minimum = "+ min+ " an Position "+ index);return index;}int getMax(int [] array){int max = array[0];// Minimum ist erster Wertint index = 0;}// durchlaufe gesamte Folgefor (int i = 1; i < array.length; i++){// falls neues Maximumif (array[i] > max) {// merke Positionindex = i;// und Wert des Maximumsmax = array[i];}}System.out.println("Max = "+ max+ " an Position "+ index);return max;int getMaxIndex(int [] array){int max = array[0];int index = 0;for (int i = 1; i < array.length; i++){19. Mai - 23. Mai 2003 - 12 - Sommersemester 2003

Algorithmik II4. Übungif (array[i] > max) {index = i;max = array[i];}}System.out.println("Max = "+ max+ " an Position "+ index);return index;}public static void main (String[] args) {int[] f = { 2, 4, 5, 6, 7, 8, 9, 11 };SearchInArray searchObj = new SearchInArray();int k = 7; //beliebiges Array-ElementsearchObj.BinSearch(f, k);System.out.println ("Binär: " + searchObj.BinSearch(f, k));System.out.println ("Sequentiell: " + searchObj.SeqSearch(f, k));searchObj.getMin(f);searchObj.getMax(f);}}Rechnerübung 9Schreiben Sie eine Klasse zum Testen aller in der Vorlesung vorgestellten Sortieralgorithmen.Testen Sie die Sortierverfahren anhand eines Arrays mit 100, 1000 und 10000 zufälligen Zahlen(Integer). Protokollieren Sie für jedes Sortierverfahren wie viel Zeit das Verfahren benötigt undvergleichen Sie die unterschiedlichen Zeiten.Hinweis: Für die Zeitmessung kann die Methode System.currentTimeMillis() verwendet werden.Sie liefert die aktuelle Zeit in Millisekunden.Lösungsvorschlag:public class Sort {public Sort() {}/*19. Mai - 23. Mai 2003 - 13 - Sommersemester 2003

Algorithmik II4. Übung* Hilfsmethode: Initialisierung eines Feldes mit Zufallszahlen*/int[] initArray (int num) {int[] result = new int[num];for (int i = 0; i < num; i++)result[i] = (int) (Math.random () * 100.0);return result;}/** Hilfsmethode: Ausgabe der Elemente eines Feldes*/void printArray (int[] array) {for (int i = 0; i < array.length; i++)System.out.print (array[i] + " ");System.out.println ();}/** Hilfsmethode: Austauch zweier Feldelemente*/void swap (int[] array, int idx1, int idx2) {int tmp = array[idx1];array[idx1] = array[idx2];array[idx2] = tmp;}/** Verbesserte Implementierung des Bubble-Sort*/void bubbleSort (int[] array) {boolean swapped; // Vertauschung ?int max = array.length - 1; // obere Feldgrenzedo {swapped = false;for (int i = 0; i < max; i++) {if (array[i] > array[i + 1]) {// Elemente vertauschenswap (array, i, i + 1);swapped = true;}}max--;// solange Vertauschung auftritt} while (swapped);19. Mai - 23. Mai 2003 - 14 - Sommersemester 2003

Algorithmik II4. Übung}void insertionSort (int[] array) {for (int i = 1; i < array.length; i++) {int marker = i;int temp = array[i];// für alle Elemente links vom Marker-Feldwhile (marker > 0 && array[marker - 1] > temp) {// verschiebe alle größeren Element nach hintenarray[marker] = array[marker - 1];marker--;}// setze temp auf das freie Feldarray[marker] = temp;}}void selectionSort (int[] array) {int marker = array.length - 1;while (marker >= 0) {// bestimme größtes Elementint max = 0;for (int i = 1; i array[max])max = i;}}// tausche array[marker] mit diesem Elementswap (array, marker, max);marker--;// Hilfsmethode für rekursives Sortieren durch Mischenvoid msort (int[] array, int le, int ri) {int i, j, k;int[] b = new int[array.length];if (ri > le) {// zu sortierendes Feld teilenint mid = (ri + le) / 2;// Teilfelder sortierenmsort (array, le, mid);msort (array, mid + 1, ri);// Hilfsfeld aufbauenfor (k = le; k

Algorithmik II4. Übungb[ri + mid - k] = array[k + 1];// Ergebnisse mischen über Hilfsfeld bi = le; j = ri;for (k = le; k lo) {// Pivotelement bestimmenint mid = array[(lo + hi) / 2];while (lo le && array[hi] > mid)--hi;// Wenn Indexe nicht gekreuzt --> Inhalte vertauschenif (lo

Algorithmik II4. Übung}}if (lo < ri)qsort( array, lo, ri);void quickSort (int[] array) {qsort (array, 0, array.length - 1);}public static void main (String[] args) {if (args.length != 1) {System.out.println ("Array-Größe wurde nicht übergeben!"+" Aufruf: Sort ");return;}int array_size = Integer.parseInt (args[0]);int[] array1 = null;Sort sortArray = new Sort();array1 =sortArray.initArray(array_size);// Kopie von Array1 erzeugenint [] array2 = (int []) array1.clone();int [] array3 = (int []) array1.clone();int [] array4 = (int []) array1.clone();long Tstart=System.currentTimeMillis();sortArray.insertionSort(array1);long Tend = System.currentTimeMillis();System.out.println("Insertionsort dauerte: "+(Tend-Tstart)+" Millisekunden");Tstart=System.currentTimeMillis();sortArray.selectionSort(array1);Tend = System.currentTimeMillis();System.out.println("Selectionsort dauerte: "+(Tend-Tstart)+" Millisekunden");Tstart=System.currentTimeMillis();sortArray.bubbleSort (array2);Tend = System.currentTimeMillis();System.out.println("Bubblesort dauerte: "+(Tend-Tstart)+" Millisekunden");Tstart=System.currentTimeMillis();19. Mai - 23. Mai 2003 - 17 - Sommersemester 2003

Algorithmik II4. ÜbungsortArray.mergeSort(array3);Tend = System.currentTimeMillis();System.out.println("Mergesort dauerte: "+(Tend-Tstart)+" Millisekunden");Tstart=System.currentTimeMillis();sortArray.quickSort(array4);Tend = System.currentTimeMillis();System.out.println("Quicksort dauerte: "+(Tend-Tstart)+" Millisekunden");}}Ausgabe:• Array-Größe=100– Insertionsort: 0 Millisekunden– Selectionsort: 0 Millisekunden– Bubblesort: 10 Millisekunden– Mergesort: 0 Millisekunden– Quicksort: 0 Millisekunden• Array-Größe=1000– Insertionsort: 10 Millisekunden– Selectionsort: 50 Millisekunden– Bubblesort: 40 Millisekunden– Mergesort: 80 Millisekunden– Quicksort: 0 Millisekunden• Array-Größe=10000– Insertionsort: 812 Millisekunden– Selectionsort: 1552 Millisekunden– Bubblesort: 5107 Millisekunden– Mergesort: 11597 Millisekunden– Quicksort: 20 Millisekunden19. Mai - 23. Mai 2003 - 18 - Sommersemester 2003