HEUTE. Effizienzbeispiel: bekannte Version (Übung ) Mathematik: Was ist Effizienz? vollständige Induktion

Transkript

1 HEUTE Effizienzbeispiel: bekannte Version (Übung ) Mathematik: was ist Effizienz? vollständige Induktion JAVA: Arrays die for -Schleife die Sprunganweisungen break und continue Verzweigung mit switch findprimeswithdifference( diff ) Input: diff Output: lo, hi benachbarte Primzahlen mit hi lo = diff Sonderfall überprüfen if diff = 1 then return ( 2, 3 ) endif hi mit kleinster ungerader Primzahl initialisieren hi := 3 do while hi lo diff lo := hi hi := hi + 2 while hi ist keine Primzahl do hi := hi + 2 endwhile while hi lo diff return ( lo, hi ) Was ist Effizienz? bildliche Funktionsweise mit diff = es gibt zumeist mehrere Algorithmen für dasselbe Problem sie unterscheiden sich in ihrer Fortschrittsgeschwindigkeit es gibt zumeist mehrere Programme für denselben Algorithmus sie unterscheiden sich in ihrer Rechengeschwindigkeit je schneller ein Algorithmus oder ein Programm mit der Aufgabe fertig wird, desto effizienter ist er bzw. es (unabhängig vom Zeittakt des Computers) 47 prim Tests lo hi

2 algorithmische Idee bildliche Funktionsweise mit diff = Bedingungen für Lösung: Paar von Primzahlen die aufeinander folgen mit gegebener Differenz Idee der bekannten Version: erzeuge Paare von benachbarten Primzahlen prüfe jeweils, ob sie geg. Differenz haben alternative Idee: 57 prim Tests erzeuge Paare von Primzahlen mit geg. Differenz prüfe jeweils, ob sie benachbart sind lo i hi Effizienzbeispiel: alternative Version findprimeswithdifference( diff ) Input: diff Output: lo, hi ben. prim: hi lo = diff Sonderfall überprüfen if diff = 1 then return ( 2, 3 ) endif lo mit kleinster ungerader Primzahl initialisieren lo := 3 while true do hi := lo + diff if lo prim and hi prim then i := lo + 2 while i < hi and i nicht prim do i := i + 2 endwhile if i hi then return ( lo, hi ) endif lo := hi lo := lo + 2 endif endwhile bildliche Funktionsweise mit diff = 8 ohne Doppelte prim Tests lo i hi

3 Implementation von isprime() bei diff = die Vollständige Induktion obere Zeiten: bekannte Version von findprimeswithdifference() Aufrufe von isprime() untere Zeiten: alternative Version Aufrufe von isprime() 59 % ohne Zeiten: alternative Version ohne doppelte Aufrufe Aufrufe von isprime() 56 % wichtiges Beweisverfahren in der Mathematik funktioniert wie eine Dominokette: ++candidate candidate += 2 while ( candidate <= 36.3 s 18.3 s Math.sqrt( number ) ) 22.8 s 11.5 s while ( candidate 21.9 s 11.5 s * candidate <= number ) 13.7 s 7.3 s maxcand = Math.sqrt( number ) ; 20.5 s 11.7 s while ( candidate <= maxcand ) 12.7 s 7.4 s was beeinflusst Effizienz? die Vollständige Induktion die algorithmische Idee Wiederverwendung von berechneten Daten gewählte Rechenoperationen / Formel-Formulierung Laufbereiche von Schleifenvariablen der erste Stein muss umfallen: Induktionsanfang (IA) jeder Stein muss einen Nachfolger treffen: Induktionsschluss (IS) die Auftreffstelle genau bezeichnen: Induktionsvoraussetzung (IV)

4 die Vollständige Induktion Arrays in JAVA Behauptung: n Objekte lassen sich in genau n! verschiedenen Reihenfolgen (Permutationen) anordnen. Beweis: per vollständiger Induktion. (IA) n = 1: ein Objekt lässt sich in genau 1! = 1 Reihenfolgen anordnen. (IS) n n + 1: Die Behauptung gelte für alle Anzahlen 1,..., n von Objekten (IV). Wir betrachten nun n + 1 Objekte. Nach (IV) gibt es für die ersten n Objekte n! Reihenfolgen. Für jede davon gibt es genau n + 1 Möglichkeiten, das n + 1. Objekt einzufügen: Obj. 1 Obj. 2 Obj. n für n + 1 Objekte gibt es n! (n + 1) = (n + 1)! Reihenfolgen. Mathematik: indizierte Variablen z.b. bei Vektorkomponenten x i Folgegliedern a n indizierten Funktionswerten f k Permutationswerten π(i) JAVA: der Objekttyp Array Deklaration z.b. int a[] ; Definition z.b. int a[] = new int[ 3 ] ; Zugriff auf Wert durch []-Operator: a[ i ] Index ist allg. int-ausdruck: a[ 2 * i - 1 ] Arrayvariablen sind Referenztypen die Vollständige Induktion Eigenschaften von Arrays Behauptung: Jede Potenz von 4 ist genau um 1 größer als ein Vielfaches von 3. Beweis: z.z.: 4 k mod 3 = 1 für alle k 0. Durch vollständige Induktion. (IA) k = 0: 4 0 mod 3 = 1 mod 3 = 1 ist korrekt. (IS) k k + 1: es gelte die Beh. für alle Exponenten 0,..., k (IV). Dann gilt: 4 k+1 mod 3 = (4 4 k ) mod 3 = [(4 mod 3) (4 k mod 3)] mod 3 (IV) = (1 1) mod 3 = 1. können von jedem Typ angelegt werden, z.b. int[], double[], Complex[], String[], int[][] werden entsprechend ihres Typs per default initialisiert, z.b. int mit 0, double mit 0., Referenztypen mit null können bei Deklaration literal initialisiert werden, z.b. int a[] = 1, 2, 3, 4 ; boolean b[] = true, false ; true false die Länge wird zur Laufzeit unveränderlich festgelegt

5 Eigenschaften von Arrays zweidimensionale Arrays Länge ist verfügbar durch Datum length, z.b. int a[] = new int[ 5 ] ; System.out.println( "Array a hat Länge " + a.length ) ; "Array a hat Länge 5" der gültige Indexbereich ist immer 0,..., length - 1: int a[] = 3, -1 ; System.out.println( "Array a hat Werte " + a[ 0 ] + " und " + a[ 1 ] ) ; "Array a hat Werte 3 und -1" der Index wird zur Laufzeit auf Gültigkeit geprüft int[][] table = new int[ 5 ][] ; alloziert ein Array der Länge 5 von Referenzen des Typs table die Referenzen sind alle mit null initialisiert int[] zweidimensionale Arrays zweidimensionale Arrays int[][] table = new int[ 5 ][ 10 ] ; int[][] table = new int[ 5 ][] ; // Init. der Gesamtreferenz alloziert eine 5 10-Tabelle vom Eintragtyp table[0] table[1][6] int (1. Zeile) table[ 0 ] = new int[ 1 ] ; table[ 1 ] = new int[ 2 ] ; table[ 2 ] = new int[ 3 ] ; table[ 3 ] = new int[ 4 ] ; table[ 4 ] = new int[ 5 ] ; table[4] (5. Zeile) alloziert jeweils verschieden lange Arrays vom Typ int Speicherbild dazu: table table[4] table[1][6] table i = überschaubares Bild: table[3][1]

6 Schleifen in JAVA ihr kennt initialization ; initialization ; while ( condition ) do... ;... ; increment ; increment ; while ( condition ) ; Steuermechanismus: initialization: die Steuervariable erstmals setzen condition: die Steuervariable überprüfen increment: die Steuervariable verändern Vergleich der Schreibweisen: int sum = 0 ; int sum = 0 ; int prod = 1 ; int prod = 1 ; int k = 1 ; while ( k <= n ) for ( int k = 1 ; k <= n ; ++k ) sum += a[ k ] ; sum += a[ k ] ; prod *= a[ k ] ; prod *= a[ k ] ; ++k ; while, do reichen aus, um alle iterativen Algorithmen zu beschreiben Nachteil: Steuermechanismus ist verteilt Übersicht nicht immer leicht dazu gibt es for ( initialization ; condition ; increment )... ; Vorteil: Steuermechanismus steht zusammen man erkennt Funktion der Schleife mit einem Blick for ( int k = 1 ; k <= n ; ++k ) sum += a[ k ] ; prod *= a[ k ] ; Ähnlichkeit zur mathematischen Notation: sum = n a k prod = k=1 eine deklarierte Steuervariable gilt nur innerhalb des Schleifenblocks kein übrig gebliebener Wert außerhalb n k=1 Steuervariable darf im Schleifenblock nicht verändert werden! a k

7 zyklische Vertauschung in einem eindimensionalen Array: gegeben: array[] = gesucht: array[] = int[][] table = new int[ 5 ][] ; // Init. der Gesamtreferenz for ( int i = 0 ; i < table.length ; ++ i ) int[] temp = new int[ i + 1 ] ; // Init. der Zeilenreferenzen for ( int j = 0 ; j < temp.length ; ++j ) temp[ j ] = i + j ; // Init. der Werte table[ i ] = temp ; // in Tabelle einhängen alloziert und initialisiert verschieden lange Arrays vom Typ int table überschaubares Bild: zyklische Vertauschung in einem eindimensionalen Array: gegeben: array[] = gesucht: array[] = public void rotate ( int array[] ) int firstelement = array[ 0 ] ; for ( int i = 1 ; i < array.length ; ++i ) array[ i - 1 ] = array[ i ] ; array[ array.length - 1 ] = firstelement ; // end rotate() jeder der Steuerteile darf auch leer sein, z.b.: int n = Integer.valueOf( args[ 1 ] ).intvalue() ; if ( n < 1 ) System.out.println( "eingegebene Zahl muss >= 1 sein!" ) ; for ( ; n >= 1 ; --n )... for ( ; ; ) entspricht while ( true ) echte Endlosschleife

8 eine Schleife vorzeitig verlassen sinnvolle Endlosschleife public boolean containsnegativeentry ( int array[] ) boolean returnvalue = false ; Benutze break, um Schleifenbedingung in der Mitte zu prüfen, z.b.: for ( int i = 0 ; i < array.length ; ++i ) if ( array[ i ] < 0 ) returnvalue = true ; // for ( i ) abbrechen return returnvalue ; // end containsnegativeentry() while ( true ) int nvalue = readintfromuser() ; if ( nvalue < 0 )... // int-wert einlesen // Signal: soll aufhören // while ( true ) beenden zwei Schleifen vorzeitig verlassen public boolean containsnegativeentry ( int array[][] ) boolean returnvalue = false ; for ( int i = 0 ; i < array.length ; ++i ) for ( int j = 0 ; j < array[ i ].length ; ++j ) if ( array[ i ][ j ] < 0 ) returnvalue = true ; // for ( j ) abbrechen einen Laufwert überspringen Summe der Nichtdiagonalelemente bilden: array[4][4] = if ( returnvalue ) // for ( i ) abbrechen return returnvalue ; // end containsnegativeentry()

9 einen Laufwert überspringen Verzweigung mit if public void sumintodiagonal ( int array[][] ) for ( int i = 0 ; i < array.length ; ++i ) a[ i ][ i ] = 0 ; for ( int j = 0 ; j < array[ i ].length ; ++j ) if ( j == i ) continue ; // restlichen for(j)-block überspringen if kennt nur 2 Entscheidungsalternativen if ( B )... // optional true... B false a[ i ][ i ] += a[ i ][ j ] ; B muss ein (beliebiger) boolean-ausdruck sein // end sumintodiagonal() break und continue Verzweigung mit if beziehen sich immer auf den innersten Schleifenblock werden beide nicht oft benötigt nur einsetzen, wenn wirklich sinnvoll ihren Sinn immer kommentieren! break ist jedoch obligatorisch in der switch-anweisung mehrwertige Entscheidung nur möglich durch Verkettung: if ( B 1 )... if ( B 2 ) // hier gilt B 1... if ( B 3 ) // hier gilt B 1 B 2... // letzte Alternative (optional)... false false false B B B true true true

10 Verzweigung mit if Achtung: ein bezieht sich immer auf das letzte if! Programmierer meint: Compiler versteht: Verzweigung mit switch Beispiel: einen String so ausgeben, dass alle Spaces als Underscores erscheinen, bei Tabulatoren und Zeilenumbrüchen eine neue Zeile anfängt. String mystr = "Dies ist\tein Beispiel\nzur Demonstration\t." ; vorher: nachher: Dies ist ein Beispiel Dies_ist zur Demonstration. ein_beispiel zur_demonstration Verzweigung mit switch mehrwertige Entscheidung möglich für beliebig viele Werte: Verzweigung mit switch public void printchanged ( String mystr ) for ( int i = 0 ; i < mystr.length() ; ++i ) char letter = mystr.charat( i ) ; A a a a a n A muss ein (beliebiger) byte, short, char oder int-ausdruck sein die Vergleichswerte a i müssen Konstanten desselben Typs sein switch ( letter ) case : System.out.print( _ ) ; case \t : case \n : System.out.println( "" ) ; default: System.out.print( letter ) ; // end printchanged() // break obligatorisch! // mehrere Labels möglich // print \n // break obligatorisch! // alle restlichen Fälle