Übungsblatt VU Algorithmen und Datenstrukturen 1 VU 6.0

Transkript

1 Übungsblatt VU Algorithmen und Datenstrukturen 1 VU September 2013 Aufgabe 11 Sortieren Sie die folgende Zahlenfolge mit Hilfe von Quicksort 111, 11, 1, 1, 110, 111, 1 Schreiben Sie dabei nach jedem Schritt des Algorithmus die entstandene Zahlenfolge auf und markieren Sie jeweils die aktuellen Pivotelemente, alle bereits sortierten Elemente und die im jeweiligen Schritt vertauschten Elemente. Geben Sie eine beliebige Eingabefolge an, die für Quicksort (Implementierung laut Skriptum, Pivotlement ist das rechteste Element) einen Worst-Case bezogen auf die Anzahl der Schlüsselvergleiche darstellt. Wie viele Schlüsselbewegungen und Schlüsselvergleiche, in Θ-Notation in Abhängigkeit der Eingabegröße n, werden für Ihre Eingabefolge benötigt? Lösung Folgende Farben werden im folgenden verwendet: Pivotelement, sortierte Elemente, vertauschte Elemente (Java-Code siehe Listing 1) , 11, 1, 1, 110, 111, 1 2. Quicksort(0,6) , 11, 1, 1, 110, 111, , 11, 1, 111, 110, 111, , 1, 11, 111, 110, 111, , 1, 1, 111, 110, 111, Quicksort(0,1) 8. 1, 1, 1, 111, 110, 111, Quicksort(0,-1) 10. Quicksort(1,1) 1

2 11. Quicksort(3,6) 12. 1, 1, 1, 111, 110, 111, , 1, 1, 11, 110, 111, Quicksort(3,2) 15. Quicksort(4,6) 16. 1, 1, 1, 11, 110, 111, Quicksort(4,4) 18. Quicksort(6,6) 19. 1, 1, 1, 11, 110, 111, 111 Folgende Eingabe 1, 2, 3, 4, 5, 6, 7 bewirkt für Quicksort ein Worst-Case-Szenario. Für dieses Worst-Case Szenario kommt es zu Θ(n 1) Θ(n) Schlüsselbewegungen und Θ( n n 2 2) Θ(n 2 ) Schlüsselvergleiche. 1 public class bsp11 2 { Listing 1: Quicksort 3 private static int bew, vgl1, vgl2 ; 4 private static int calls ; 5 6 // would be called on startup... 7 public static void main ( String [] args ) 8 { 9 calls = 0; 10 bew = 0; 11 vgl1 = 0; 12 vgl2 = 0; 13 int [] val1 = {10,11,1,0,101,111,01,00}; 14 quicksort (val1,0, val1. length -1); 15 System. out. println (" Bewegungen :" + bew + ", Vergleiche :" + vgl1 + "+" 16 } public static void quicksort ( int [] values, int l, int r) { if( calls <100) { 21 calls ++; 22 System. out. println (" quicksort (" + values [l] + "," + values [r] + " 23 // System. out. println (" quicksort (" + l + "," + r + ")"); 24 if(l<r) { 25 int x = values [r]; printvalues ( values ); 28 int p = partition ( values, l, r, x); 29 2

3 30 System. out. println (" partition returning : l:" + values [l] + " p:" 31 if(l!=p) { 32 quicksort ( values, l,p -1); 33 } 34 if(p!=r) { 35 quicksort ( values, p+1,r); 36 } 37 } 38 } 39 } public static int partition ( int [] values, int l, int r, int x) { 42 System. out. println (" partition (" + values [l] + "," + values [r] + "," + 43 int i =l -1; 44 int j=r; 45 do { 46 do { 47 i ++; 48 vgl1 ++; 49 } while ( values [i]<x); 50 do { 51 j - -; 52 vgl2 ++; 53 } while (j>i && values [j]>x); 54 System. out. println ("i: "+ values [i] + ", j:" + values [j ]); 55 if(i<j) { 56 int tmp = values [i]; 57 values [i] = values [j]; 58 values [j] = tmp ; 59 printvalues ( values ); 60 bew ++; 61 } 62 } while (i<j); 63 int tmp = values [i]; 64 values [i] = values [r]; 65 values [r] = tmp ; 66 printvalues ( values ); 67 bew ++; 68 return i; 69 } public static void printvalues ( int [] values ) { 72 String out = String. format ( "%2d", values [0]); 73 for ( int i =1; i< values. length ; i ++) { 74 out += String. format ( ", %2d", values [i ]); 75 } 76 System. out. println ( out ); 77 } 3

4 78 } Aufgabe 12 Wie müsen Sie den Algorithmus Quicksort aus dem Skriptum adaptieren, damit für das Pivotelement einer Folge a 1,..., a n der Median von a 1, a n 2, a n verwendet wird? Führen Sie einerseits den veränderten Algorithmus, als auch den unveränderten Algorithmus aus dem Skriptum mit der folgenden Eingabefolge durch: 1, 2, 3, 4, 5, 6, 7, 8, 9 Lösung Man muss nur die Medianstelle (die Stelle, die vom Wert her zwischen den anderen beiden Werten liegt) immer auf die rechteste Stelle verschieben. Anschließend kann man den Algorithmus von vorhin wieder verwenden. (Java-Code siehe Listing 2) Algorithmus Quicksort(var A, l, r): Eingabe: Array A; Indexgrenzen l und r Ausgabe: sortierte Teilfolge in A[l],..., A[r] Variable(n): Schlüsselwert x; Index p 1: falls l < r dann { 2: m = (r l)/2 + l; 3: falls A[l] > A[m] dann { 4: vertausche A[l] und A[m]; 5: } 6: falls A[l] > A[r] dann { 7: vertausche A[l] und A[r]; 8: } 9: falls A[r] > A[m] dann { 10: vertausche A[r] und A[m]; 11: } 12: x = A[r].key; 13: p = P artition(a, l, r, x); 14: p = Quicksort(A, l, p 1); 15: p = Quicksort(A, p + 1, r); 16: } Durch diese Änderung hat das Programm eine wesentlich geringere Laufzeit als ohne. z.b. mit dem Folgenden Datensatz: 1, 2, 3, 4, 5, 6, 7, 8, 9 hat das Programm nur noch 36 anstatt 52 Vergleiche. Weiters wird die Prozedur Quicksort nur noch 11x vs. 17x aufgerufen. 1 public class bsp12 2 { Listing 2: Median-Quicksort 3 private static int bew, vgl1, vgl2 ; 4 4

5 5 // would be called on startup... 6 public static void main ( String [] args ) 7 { 8 bew = 0; 9 vgl1 = 0; 10 vgl2 = 0; 11 double [] val1 = {1,2,3,4,5,6,7,8,9}; 12 printvalues ( val1 ); 13 quicksort (val1,0, val1. length -1); 14 printvalues ( val1 ); 15 System. out. println (" Bewegungen :" + bew + ", Vergleiche :" + vgl1 + "+" 16 } public static void quicksort ( double [] values, int l, int r) { 19 System. out. println (" quicksort (" + l + "," + r + ")"); 20 if(l<r) { 21 int m = ( int ) Math. floor ((r-l )/2+ l); 22 // die folgenden zeilen bringen immer den median der 3 Stellen 23 // auf die r- Stelle und machen es somit zum pivot - element vgl1 +=3; 26 if( values [l]> values [m ]){ 27 bew ++; 28 double tmp = values [l]; values [l]= values [m]; values [m]= tmp ; } 29 if( values [l]> values [r ]){ 30 bew ++; 31 vgl1 - -; 32 double tmp = values [l]; values [l]= values [r]; values [r]= tmp ; } 33 else if( values [r]> values [m ]){ 34 bew ++; 35 double tmp = values [r]; values [r]= values [m]; values [m]= tmp ; } 36 double x = values [r]; 37 int p = partition ( values, l, r, x); 38 quicksort ( values, l,p -1); 39 quicksort ( values, p+1,r); 40 } 41 } public static int partition ( double [] values, int l, int r, double x) { 44 int i =l -1; 45 int j=r; 46 do { 47 do { 48 i ++; 49 vgl1 ++; 50 } while ( values [i]<x); 51 do { 52 j - -; 5

6 53 vgl2 ++; 54 } while (j>i && values [j]>x); 55 if(i<j) { 56 double tmp = values [ i]; 57 values [i] = values [j]; 58 values [j] = tmp ; 59 printvalues ( values ); 60 bew ++; 61 } 62 } while (i<j); 63 double tmp = values [ i]; 64 values [i] = values [r]; 65 values [r] = tmp ; 66 printvalues ( values ); 67 bew ++; 68 return i; 69 } public static void printvalues ( double [] values ) { 72 String out = String. format ( "%2f", values [0]); 73 for ( int i =1; i< values. length ; i ++) { 74 out += String. format ( ", %2f", values [i ]); 75 } 76 System. out. println ( out ); 77 } 78 } Aufgabe 13 Führen Sie auf der Zahlenfolge 12, 9, 10, 8, 7, 11, 6 den Algorithmus Heapsort aus um die Zahlenfolge aufsteigend zu sortieren. Geben sie sowohl das Feld als auch den Heap in seiner Baumform nach dem Aufruf von ErstelleHeap() und dann nach jedem Versickerungschritt an. (Java-Code siehe Listing 3) Lösung i Die Eingangs-Zahlenfolge 12, 9, 10, 8, 7, 11, 6 als Heap dargestellt: siehe Abbildung Abbildung 1: Eingangs-Zahlenfolge 12, 9, 10, 8, 7, 11, 6 als Heap dargestellt. 6

7 ii Die Zahlenfolge nach dem Aufruf von ErstelleHeap: 12, 9, 11, 8, 7, 10, 6 als Heap dargestellt: siehe Abbildung Abbildung 2: Zahlenfolge nach ErstelleHeap: 12, 9, 10, 8, 7, 11, 6 als Heap dargestellt. iii Die Zahlenfolge nach dem Aufruf von Versickere(1,6): 11, 9, 10, 8, 7, 6, 12 als Heap dargestellt: siehe Abbildung Abbildung 3: Zahlenfolge nach Versickere(1,6): 11, 9, 10, 8, 7, 6 als Heap dargestellt. iv Die Zahlenfolge nach dem Aufruf von Versickere(1,5): 10, 9, 6, 8, 7, 11, 12 als Heap dargestellt: siehe Abbildung Abbildung 4: Zahlenfolge nach Versickere(1,5): 10, 9, 6, 8, 7 als Heap dargestellt. v Die Zahlenfolge nach dem Aufruf von Versickere(1,4): 9, 8, 6, 7, 10, 11, 12 als Heap dargestellt: siehe Abbildung Abbildung 5: Zahlenfolge nach Versickere(1,4): 9, 8, 6, 7 als Heap dargestellt. vi Die Zahlenfolge nach dem Aufruf von Versickere(1,3): 8, 7, 6, 9, 10, 11, 12 als Heap dargestellt: siehe Abbildung 6 7

8 8 7 6 Abbildung 6: Zahlenfolge nach Versickere(1,3): 8, 7, 6 als Heap dargestellt. vii Die Zahlenfolge nach dem Aufruf von Versickere(1,2): 7, 6, 8, 9, 10, 11, 12 als Heap dargestellt: siehe Abbildung Abbildung 7: Zahlenfolge nach Versickere(1,2): 7, 6 als Heap dargestellt. viii Die Zahlenfolge nach dem Aufruf von Versickere(1,1): 6, 7, 8, 9, 10, 11, public class bsp13 2 { Listing 3: Heapsort 3 // would be called on startup... 4 public static void main ( String [] args ) 5 { 6 int [] val1 = {12,9,10,8,7,11,6}; 7 printvalues ( val1 ); 8 heapsort (val1, val1. length ); 9 printvalues ( val1 ); 10 } public static void heapsort ( int [] values, int n) { 13 erstelle_heap ( values, n); 14 System. out. println (" heap "); 15 printvalues ( values ); 16 for ( int i=n; i >=2; i - -) { 17 int tmp = values [i -1]; 18 values [i -1] = values [0]; 19 values [0] = tmp ; 20 versickere ( values,1,i -1); 21 } 22 } public static void versickere ( int [] values, int i, int m) { 25 System. out. println (" versickere " + i + ":" + m); 26 while (2*i <=m) { // values [i] hat linkes kind 27 int j =2* i; // values [j] ist linkes kind 28 if(j<m) { // values [i] hat rechtes kind 29 if( values [j -1] < values [j]) { 8

9 30 j ++; // values [ j] ist groesstes kind 31 } 32 } 33 if( values [i -1] < values [j -1]){ 34 int tmp = values [i -1]; 35 values [i -1] = values [j -1]; 36 values [j -1] = tmp ; 37 i=j; // versickere weiter 38 } else { 39 i = m; // Stopp : Heap - Bedingung ist erfuellt 40 } 41 } 42 printvalues ( values ); 43 } public static void erstelle_heap ( int [] values, int n) { 46 for ( int i=( int ) Math. floor (n /2);i >=1;i - -) { 47 versickere ( values,i,n); 48 } 49 } public static void printvalues ( int [] values ) { 52 String out = String. format ( "%2d", values [0]); 53 for ( int i =1; i< values. length ; i ++) { 54 out += String. format ( ", %2d", values [i ]); 55 } 56 System. out. println ( out ); 57 } 58 } Aufgabe 14 Gegeben sind folgenden oktale Zahlen (d.h. Zahlen zur Basis 8): 172, 152, 52, 357, 352, 152, 740, 0 Diese Zahlen sollen mit Hilfe des Verfahrens Sortieren durch Fachverteilung aufsteigend sortiert werden. Wählen Sie die Anzahl der Fächer entsprechend der Zahlenbasis und die Anzahl der Sammel- und Verteilungsphasen basierend auf der maximalen Stellenanzahl. Geben Sie die Inhalte aller Fächer nach jeder Verteilungsphase und die Reihenfolge der Zahlen nach jeder Sammelphase an. 9

10 Lösung Da die maximale Stellenanzahl der Zahlen 3 beträgt, bedeutet das, dass es 3 Verteilungsphasen und 3 Sammelphasen gibt. Weiters muss es, da die Zahlen zur Basis 8 gehören 8 Fächer geben. (Java-Code siehe Listing 4) 1. Verteilungsphase (siehe Tabelle 1) Fach Datensätze F 0 (0) 740, 0, F 1 (1) F 2 (2) 172, 152, 52, 352, 152 F 3 (3) F 4 (4) F 5 (5) F 6 (6) F 7 (7) 357 Tabelle 1: Verteilungsphase 1 Sammelphase: 740, 0, 172, 152, 52, 352, 152, Verteilungsphase (siehe Tabelle 2) Fach Datensätze F 0 (0) 0 F 1 (1) F 2 (2) F 3 (3) F 4 (4) 740 F 5 (5) 152, 52, 352, 152, 357 F 6 (6) F 7 (7) 172 Tabelle 2: Verteilungsphase 2 Sammelphase: 0, 740, 152, 52, 352, 152, 357, Verteilungsphase (siehe Tabelle 3) Fach Datensätze F 0 (0) 0, 52 F 1 (1) 152, 152, 172 F 2 (2) F 3 (3) 352, 357 F 4 (4) F 5 (5) F 6 (6) F 7 (7) 740 Tabelle 3: Verteilungsphase 3 Sammelphase: 0, 52, 152, 152, 172, 352, 357, public class bsp14 Listing 4: Sortieren durch Fachverteilung (Radix-Sort) 10

11 2 { 3 // would be called on startup... 4 public static void main ( String [] args ) 5 { 6 java. util. Vector < Integer > list = new java. util. Vector < Integer >(); 7 java. util. Collections. addall (list,172,152,52,357,352,152,740,0); 8 9 java. util. Vector [] faecher = { 10 new java. util. Vector < Integer >(), new java. util. Vector < Integer >(), 11 new java. util. Vector < Integer >(), new java. util. Vector < Integer >(), 12 new java. util. Vector < Integer >(), new java. util. Vector < Integer >(), 13 new java. util. Vector < Integer >(), new java. util. Vector < Integer >()} 14 for ( int schritt =1; schritt <=3; schritt ++) { 15 java. util. Iterator < Integer > itr = list. iterator (); 16 // verteilen 17 while ( itr. hasnext ()) { 18 Integer value = itr. next (); 19 int fach = value /( int ) Math. pow (10, schritt -1)%10; 20 faecher [ fach ]. add ( value ); 21 } 22 // sammeln 23 list. clear (); 24 for ( int i =0; i< faecher. length ; i ++) { 25 list. addall ( faecher [i ]); 26 faecher [i]. clear (); 27 } 28 System. out. println ("\ nschritt " + schritt + ":"); 29 printvector ( list ); 30 } 31 } 32 public static void printvector ( java. util. Vector < Integer > vector ) { 33 java. util. Iterator itr = vector. iterator (); 34 String output =""; 35 while ( itr. hasnext ()) { 36 output += itr. next (); 37 if(itr. hasnext ()) { 38 output += ","; 39 } 40 } 41 System. out. println ( output ); 42 } 43 } Aufgabe 15 11

12 (a) Sie haben eine nicht sortierte, einfach verkettete lineare Liste. Welches Sortierverfahren verwenden Sie, um die Liste zu sortieren? Begründen Sie Ihre Antwort. (b) Sie haben eine sortierte, einfach verkettete lineare Liste. An diese Liste wird hinten ein beliebig großes Element angehängt. Welches Sortierverfahren verwenden Sie in diesem Fall, um die Liste zu sortieren? Begründen Sie Ihre Antwort. (c) Sie haben eine nicht sortierte, doppelt verkettete lineare Liste. Welches Sortierverfahren verwenden Sie in diesem Fall, um die Liste zu sortieren? Begrüden Sie Ihre Antwort. (d) Sie haben eine absteigend sortierte, doppelt verkettete lineare Liste. Welches Sortierverfahren verwenden Sie in diesem Fall, um die Liste aufsteigend zu sortieren? Begründen Sie Ihre Antwort. Lösung (a) Mergesort, denn Mergesort läuft sequentiell (nacheinander, gegenteil wäre random-access), außerdem entfallen Bewegungen von Datensätzen komplett; stattdessen werden lediglich Listenzeiger geändert. (b) Insertionsort, denn hier wird nacheinander jedes Element in die bereits bestehende sortierte Liste eingefügt. Bei nur einem Element hat man hier eine Laufzeit von maximal Θ(n). (c) Quicksort könnte man hier anwenden, da man hier die Elemente von beiden Richtungen durchläuft. Da Quicksort meist in der Praxis erheblich schneller, als Mergesort ist, würde ich es vorziehen (Außer im Worst-Case) (d) Quicksort/Mergesort da die Liste bereits sortiert ist, ist man mit Quicksort aber bereits im Worst-Case (es ist egal in welche Richtung die Liste Sortiert ist) und hier müsste man sich beispielsweise mit der Median of 3-, oder mit einer Random-Methode aushelfen, um das Pivot zu bestimmen. Wenn man diese Tricks zur bestimmung des Pivotelements nicht anwendet, ist man langsamer als mit Merge-Sort. Somit geht die Sortierung auch mit Mergesort. Aufgabe 16 Schreiben Sie detaillierten Pseudocode für die Funktion merge(l 1, L 2 ). Dabei sind die Parameter L 1 und L 2 jeweils Zeiger auf das erste Element einer aufsteigend sortierten, azyklischen, einfach verketteten Liste. Als Rückgabe soll die Funktion merge(l 1, L 2 ) einen Zeiger auf das erste Element einer aufsteigend sortierten, einfach verketteten Liste liefern, die alle Elemente aus der Liste L 1 und L 2 enthält. Lösung Der folgende Pseudocode erzeugt diese verkettete, aufsteigend sortierte Liste. (Java- Code dazu: siehe Listing 1) Algorithmus merge(l 1, L 2 ): Eingabe: jeweils erstes Element der verketteten Listen L 1 und L 2 12

13 Ausgabe: aufsteigend Sortierte Liste mit Elementen aus Liste L 1 und L 2. 1: falls L 1 = NULL dann { 2: L = L 2 ; 3: } sonst falls L 2 = NULL dann { 4: L = L 1 ; 5: } sonst { 6: falls L 1.Inhalt < L 2.Inhalt dann { 7: L = L 1 ; 8: L 1 = L 1.Nachfolger; 9: } sonst { 10: L = L 2 ; 11: L 2 = L 2.Nachfolger; 12: } 13: h = L; 14: solange L 1 NULL L 2 NULL { 15: falls L 1 = NULL dann { 16: h.nachfolger = L 2 ; 17: L 2 = NULL; 18: } sonst falls L 2 = NULL dann { 19: h.nachfolger = L 1 ; 20: L 2 = NULL; 21: } sonst falls L 1.Inhalt < L 2.Inhalt dann { 22: h.nachfolger = L 1 ; 23: L 1 = L 1.Nachfolger; 24: } sonst { 25: h.nachfolger = L 2 ; 26: L 2 = L 2.Nachfolger; 27: } 28: h = h.nachfolger; 29: } 30: } 31: retourniere L; 1 public class bsp16 2 { 3 public class element { 4 private int inhalt ; 5 private element next ; 6 Listing 5: Merge von 2 verketteten Listen 7 public element ( int inhalt ) { 8 this ( inhalt, null ); 9 } public element ( int inhalt, element next ) { 12 this. inhalt = inhalt ; 13 this. next = next ; 14 } 13

14 15 16 public void setnext ( element next ) { 17 this. next = next ; 18 } public element getnext () { 21 return this. next ; 22 } public int getinhalt () { 25 return this. inhalt ; 26 } public String tostring () { 29 return new String ("" + this. inhalt ); 30 } 31 } // would be called on startup public static void main ( String [] args ) { 35 bsp16 program = new bsp16 (); 36 program. run (); 37 } public void run () { 40 element L1 = new element ( 20); 41 L1 = new element (17, L1 ); 42 L1 = new element (14, L1 ); 43 L1 = new element (10, L1 ); 44 L1 = new element (5, L1 ); 45 L1 = new element (2, L1 ); element L2 = new element ( 16); 48 L2 = new element (13, L2 ); 49 L2 = new element (3, L2 ); element Le = null ; printlist ( merge (L2,L1 )); 54 } public static element merge ( element L1, element L2) { 57 element L; 58 if(l1 == null ) { 59 L=L2; 60 } else if( L2 == null ) { 61 L=L1; 62 } else { 14

15 63 if(l1. getinhalt () < L2. getinhalt ()) { 64 L=L1; 65 L1=L1. getnext (); 66 } else { 67 L=L2; 68 L2=L2. getnext (); 69 } 70 element h= L; 71 while (L1!= null L2!= null ) { 72 if(l1 == null ) { 73 h. setnext (L2 ); 74 L2 = null ; 75 } else if(l2 == null ) { 76 h. setnext (L1 ); 77 L1 = null ; 78 } else if(l1. getinhalt () < L2. getinhalt ()) { 79 h. setnext (L1 ); 80 L1 = L1. getnext (); 81 } else { 82 h. setnext (L2 ); 83 L2 = L2. getnext (); 84 } 85 h=h. getnext (); 86 } 87 } 88 return L; 89 } public static void printlist ( element head ) { 92 System. out. println ( head ); 93 if( head. getnext ()!= null ) { 94 printlist ( head. getnext ()); 95 } 96 } 97 } Aufgabe 17 (a) Zeichnen Sie die angegebene Liste von Zahlen als doppelt verkettete zyklische Liste. 4, 34, 14, 24, 54, 44 (b) Fügen Sie in Ihre Liste das Element 10 direkt nach dem bereits existierenden Element 34 ein. Nennen Sie die dazu notwendigen Zeigeroperationen in der richtigen Reihenfolge, beginnend bei der Suche nach dem Element 34 vom Listenanfang an. Falls Sie eigene Zeiger auf Listenelemente benötigen, geben Sie auch deren Initialisierung an. 15

16 Lösung (a) 4, 34, 14, 24, 54, 44 als doppelt verkettete zyklische Liste (siehe Abbildung 8) L Abbildung 8: Eingangs-Zahlenfolge 4, 34, 14, 24, 54, 44 als doppelt verkettete Liste dargestellt. (b) 4, 34, 10, 14, 24, 54, 44 als doppelt verkettete zyklische Liste (siehe Abbildung 9) Die für das Einfügen benötigten Zeigeroperationen lauten wie folgt: 1: Neues Listenelement neu erzeugen; 2: neu.inhalt = 10; 3: neu.n achf olger = L.N achf olger.n achf olger; 4: neu.v orgaenger = L.N achf olger; 5: neu.n achf olger.v orgaenger = neu; 6: L.Nachfolger.Nachfolger = neu; L Abbildung 9: Eingangs-Zahlenfolge 4, 34, 10, 14, 24, 54, 44 als doppelt verkettete Liste dargestellt. Aufgabe 18 Schreiben Sie einen Algorithmus in Pseudocode, um aus einer aufsteigend sortierten, doppelt verketteten linearen Liste L (siehe Abbildung 10) ein Element x zu entfernen. Fertigen Sie auch eine Skizze hierfür an. L a 1 a 2... a n 16

17 Abbildung 10: Doppelt verkettete Liste Lösung Der Folgende Algorithmus enthält den Code für das entfernen eines Elementes aus einer doppelt verketteten Liste L. (Siehe auch Listing 6 für das Beispiel in Java) Algorithmus delete(l, x): Eingabe: das erste Element der doppelt verketteten Liste L, und der zu löschende Wert x Ausgabe: Liste L, jedoch mit einem Element das den Wert x hatte weniger. 1: falls L NULL dann { 2: falls L.Inhalt = x dann { 3: L = L.Nachfolger; 4: L.V orgaenger = NULL; 5: } sonst { 6: h = L.Nachfolger; 7: solange h NULL { 8: falls h.inhalt = x h.nachfolger = NULL dann { 9: h.v orgaenger.nachfolger = NULL; 10: } sonst falls h.inhalt = x dann { 11: h.v orgaenger.n achf olger = h.n achf olger; 12: h.n achf olger.v orgaenger = h.v orgaenger; 13: } 14: h = h.nachfolger; 15: } 16: } 17: } 18: retourniere L; Die Abbildung 11 enthält noch das Element x, wobei die Abbildung 12 das Element x nicht mehr enthält. L 1 x Abbildung 11: Doppelt verkettete Liste mit dem Element x L x Abbildung 12: Doppelt verkettete Liste mit dem entfernten Element x 17

18 Listing 6: Löschen eines Elementes aus einer doppelt verketteten Liste. 1 public class bsp18 2 { 3 public class element { 4 private int inhalt ; 5 private element next ; 6 private element previous ; 7 8 public element ( int inhalt ) { 9 this ( inhalt, null, null ); 10 } public element ( int inhalt, element next, element previous ) { 13 this. inhalt = inhalt ; 14 this. next = next ; 15 this. previous = previous ; 16 } public void setnext ( element next ) { 19 this. next = next ; 20 } public element getnext () { 23 return this. next ; 24 } public void setprevious ( element previous ) { 27 this. previous = previous ; 28 } public element getprevious () { 31 return this. previous ; 32 } public int getinhalt () { 35 return this. inhalt ; 36 } public String tostring () { 39 return new String ("" + this. inhalt ); 40 } 41 } // would be called on startup public static void main ( String [] args ) { 45 bsp18 program = new bsp18 (); 46 program. run (); 47 } 18

19 48 49 public void run () { 50 element L11 = new element ( 20); 51 element L12 = new element ( 17); 52 element L13 = new element ( 14); 53 element L14 = new element ( 10); 54 element L15 = new element ( 5); 55 L11. setnext ( L12 ); 56 L12. setnext ( L13 ); 57 L13. setnext ( L14 ); 58 L14. setnext ( L15 ); 59 L12. setprevious ( L11 ); 60 L13. setprevious ( L12 ); 61 L14. setprevious ( L13 ); 62 L15. setprevious ( L14 ); element Le = null ; printlist ( delete (L11,5)); 67 } public static element delete ( element L, int x) { 70 if(l!= null ) { 71 if(l. getinhalt ()== x) { 72 L=L. getnext (); 73 L. setprevious ( null ); 74 } else { 75 element h= L. getnext (); 76 while (h!= null ) { 77 if(h. getinhalt ()== x && h. getnext ()== null ) { 78 h. getprevious (). setnext ( null ); 79 } else if(h. getinhalt ()== x){ 80 h. getprevious (). setnext (h. getnext ()); 81 h. getnext (). setprevious (h. getprevious ()); 82 } 83 h=h. getnext (); 84 } 85 } 86 } 87 return L; 88 } public static void printlist ( element head ) { 91 System. out. println ( head ); 92 if( head. getnext ()!= null ) { 93 printlist ( head. getnext ()); 94 } 95 } 19

20 96 } Aufgabe 19 Bei der binären Suche wird immer mit dem mittleren Element des noch aktuellen Bereichs verglichen. Eine Abwandlung ist die sogenannte Exponentielle Suche. Diese kann eingesetzt werden, wenn der zu untersuchende Bereich zwar endlich, die Größe aber nicht bekannt ist. Algorithmus Exp-Search(var A, s, l, r): Eingabe: Array A; Suchschlüssel s; Indexgrenzen l und r Ausgabe: Position des Elements s in A; -1 falls nicht gefunden Variable(n): Potenz p 1: falls A[l].key == s dann { 2: return l; 3: } sonst falls A[r].key == s dann { 4: return r; 5: } sonst falls l > r dann { 6: return -1; 7: } 8: p = 1; 9: solange (l + p r) und (A[l + p].key < s) { 10: p = p*2; 11: } 12: return Exp-Search(A,s,l+p/2,min(r,l+p)); Gegeben ist ein Feld, das die folgenden Elemente in der angebenen Reihenfolge enthält: 2, 4, 5, 13, 14, 20, 27, 28, 33, 44, 45, 50, 51, 57, 59, 60, 64, 65, 78, 80 Führen Sie in dem angegebenen Feld eine Exponentielle Suche nach dem Element 64 durch. Geben Sie dabei in jedem Schritt die jeweiligen Schranken an. Lösung Tabelle 4: Array das durchsucht werden soll. Bereits nach dem 2. Rekursiven Aufruf von Exp-Search bricht die Funktion ab, da der Wert 64 bereits die rechte Grenze ist. (das 17. Element in dem Array) (Siehe auch Listing 7 für das Beispiel in Java) Liste rekursiver Aufrufe, um das Element mit dem Wert 64 zu suchen: Exp-Search(A, 64, 1, 20) (Schranke l=1, r=20); 20

21 Exp-Search(A, 64, 9, 17) (Schranke l=9, r=17); 1 public class bsp19 2 { Listing 7: Exp-Search 3 // would be called on startup... 4 public static void main ( String [] args ) 5 { 6 int [] val1 = {2,4,5,13,14,20,27,28,33,44,45,50,51,57,59,60,64,65,78, 7 System. out. println ( expsearch (val1, 64, 0, val1. length -1)); 8 } 9 10 public static int expsearch ( int [] values, int s, int l, int r) { 11 System. out. println (" expsearch (" + l + "," + r + ")"); 12 if( values [l] == s) { 13 return l; 14 } else if( values [r] == s) { 15 return r; 16 } else if(l>r) { 17 return -1; 18 } 19 int p = 1; 20 while (l+p <=r && values [l+p]<s) { 21 p = p *2; 22 } 23 return expsearch ( values, s, l+p/2, r<l+p?r:l+p); 24 } public static void printvalues ( int [] values ) { 27 String out = String. format ( "%2d", values [0]); 28 for ( int i =1; i< values. length ; i ++) { 29 out += String. format ( ", %2d", values [i ]); 30 } 31 System. out. println ( out ); 32 } 33 } Aufgabe 20 enthält: Gegeben ist ein Feld, das die folgenden Elemente in der angegebenen Reihenfolge 1, 6, 14, 21, 26, 31, 46, 76, 81, 86, 91, 96, 98 Führen Sie in dem angegebenen Feld eine Binärsuche nach dem Schlüssel 81 durch. Geben Sie dabei in jedem Schritt die jeweiligen Bereichsgrenzen an. 21

22 Wie hoch ist im Worst- und im Best-Case der Suchaufwand der Binärsuche in Abhängigkeit der Anzahl n der Elemente in einer Folge in Θ-Notation? Nach welchem(n) Schlüssel(n) müsste man in der oben angeführten Folge suchen, um den höchsten Suchaufwand in Abhängigkeit der Anzahl n der Elemente zu erhalten? Lösung Tabelle 5: Array das binär zu durchsuchen ist. Liste der erforderlichen Schitte, die gegangen werden müssen, um das Element 81 zu finden. (Siehe auch Listing 8 für das Beispiel in Java) l=1, r=13, m=7; l=8, r=13, m=10; l=8, r=9, m=8; l=9, r=9, m=9; Im Best-Case ist der Aufwand zum Suchen immer Θ(1). Im Worst-Case ist der Aufwand zum Suchen Θ(log 2 (n)). Wenn man nach den Schlüsseln 6, 21, 31, 81, 91 und 98 sucht, kommt man auf den höchsten Suchaufwand. 1 public class bsp20 2 { 3 public static int cnt ; 4 Listing 8: Exp-Search 5 // would be called on startup... 6 public static void main ( String [] args ) 7 { 8 int [] val1 = {1, 6, 14, 21, 26, 31, 46, 76, 81, 86, 91, 96, 98}; 9 System. out. println (" Returned Position : " + binarysearch (val1, 81, 0, for ( int i =0; i< val1. length ; i ++) { 12 cnt =0; 13 binarysearch (val1, val1 [i], 0, val1. length -1); 14 System. out. println ( val1 [i] + ": Durchlaeufe : " + cnt ); 15 } 16 } 17 22

23 18 public static int binarysearch ( int [] values, int s, int l, int r) { 19 int m; 20 do { 21 cnt ++; 22 m = (l+r +2)/2-1; 23 System. out. println ("l:" + l + " r:" + r + " m:" + m); 24 if( values [m] > s) { 25 r = m -1; 26 } else { 27 l = m +1; 28 } 29 } while (s!= values [m] && l <=r); 30 if(s == values [m]) { 31 return m; 32 } else { 33 return -1; 34 } 35 } public static void printvalues ( int [] values ) { 38 String out = String. format ( "%2d", values [0]); 39 for ( int i =1; i< values. length ; i ++) { 40 out += String. format ( ", %2d", values [i ]); 41 } 42 System. out. println ( out ); 43 } 44 } 23