algorithmen und datenstrukturen cs1017 th. letscherthg51/veranstaltungen/a_d/folien/ad-02.pdf ·...
TRANSCRIPT
Algorithmen und Datenstrukturen CS1017
Th LetschertTH Mittelhessen Gieszligen
University of Applied Sciences
Erste Algorithmen Iteration und Rekursion ndash Algorithmen und Programme ndash Sortieren Selection-Sort Insertion-Sort Merge-Sort ndash Generische Methoden ndash Java-API Comparable Comparator
Seite 2
Algorithmen und Programme
Algorithmus
DefinitionEin Algorithmus ist eine eindeutige Handlungs-Vorschrift zur Loumlsung eines Problems bzw zur Erreichung eines Ziels
Diese Vorschrift muss einige Bedingungen erfuumlllen
ndash sie muss endlich sein
ndash sie muss eindeutig sein
ndash sie muss ausfuumlhrbar sein
Umfeld eines AlgorithmusDie Formulierung eines Algorithmus haumlngt ab von
ndash den operationalen Faumlhigkeiten Moumlglichkeiten des Ausfuumlhrenden
was kann der Ausfuumlhrende
ndash den sprachlichen Moumlglichkeiten der Sprache Notation in der der Agorithmus formuliert wird
was kann der eine sagen und der andere verstehen
Eine Woche Testen und Debuggen kann glatt einen ganzen Nachmittag Nachdenken ersetzenAlte Hacker-Weisheit
Seite 3
Algorithmen und Programme
Algorithmus
Mathematische ProblemeAlgorithmen werden sehr oft als Berechnungsvorschriften angesehen
die mathematische Problemstellungen loumlsen
zB Cormen et al
So verstanden sind Algorithmen Vorschriften zur Berechnung von Funktionen
Informally an algorithm is any well-defined computational procedure that takes some value or set of values as input and produces some value or set of values as output An algorithm is thus a sequence of computational steps that transform the input into the output
Seite 4
Algorithmen und Programme
Algorithmus
RechenmodellDie Faumlhigkeiten des Ausfuumlhrenden werden durch ein Rechenmodell spezifiziert
Man kann es als abstrakten hypothetischen Computer verstehen
Das Rechenmodell wird in der Regel nicht explizit angegeben
Es ist informal klar dass es sich um einen Computer mit den uumlblichen Faumlhigkeiten handelt
ndash Variablen
ndash arithmetische Operationen
ndash Anweisungen
ndash Prozeduren und Funktionen
Die theoretische Informatik hat bewiesen dass alle explizit formulierten Berechnungs-Modelle aumlquivalent sind
Es ist darum unnoumltig explizit darauf einzugehen
Seite 5
Algorithmen und Programme
Algorithmen
Algorithmen werden meist in Pseudocode formuliert
Pseudocode
ndash ist eine meist mathematisch inspirierte Notation
ndash mit der Berechungsschritte mit Hilfe mathematischer Notation formuliert werden
ndash von denen klar ist dass sie vom (gebildeten) Leser verstanden werden und sich in Basis-Operationen des Rechenmodells uumlbersetzen lassen
Algorithmen in Pseudocodendash koumlnnen voraussetzen dass der Ausfuumlhrer
beliebige exakt definierte berechenbare
Funktionen auszufuumlhren kann
ndash sie sind kompakter und uumlbersichtlicher als Programme
ndash und unabhaumlngig von aktuellen Technologien
Seite 6
Algorithmen und Programme
Pseudocode
Beispiel
Dies ist kein Algorithmus
also auch kein (Algorithmus in) Pseudocode
Analyse
ndash Primfaktoren von m und Primfaktoren von n
ist nicht OK es ist nicht klar ob es sich um Mengen Listen oder Multimengen handelt
ndash Alle Primfaktoren die in fn und f
m vorkommen
ist in der Folge ebenfalls nicht OK was ist gemeint ein Mengenschnitt
Seite 7
Algorithmen und Programme
Programme
DefinitionProgramme sind Algorithmen die in einer bestimmten Programmiersprache geschrieben sind
Programmiersprachen und ihre APIs
Programmiersprachen haben eine enorme Bedeutung fuumlr den praktizierenden Algorithmiker
ndash Jede Sprache kommt mit einer Bibliothek deren effektive Nutzung
einen produktiven (dh bezahlbaren) Entwickler ausmacht
ndash Die Bibliotheken (APIs) sind keine Sammlungen von Funktionen mehr sondern
Frameworks ndash keine Oumlkosysteme ndash in die die eigenen Loumlsungen hineinpassen muumlssen
ndash Algorithmen und Datenstrukturen muumlssen darum im Kontext einer Sprache und ihrer API entwickelt und realisiert werden
ndash Gluumlcklicherweise sind die Sprachen und ihre API sich oft aumlhnlich ndash Wer eine kennt wird die naumlchste leichter lernen
Seite 8
Algorithmen und Programme
Programme
Java-API
httpsdocsoraclecomjavase8docsapiindexhtml
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 2
Algorithmen und Programme
Algorithmus
DefinitionEin Algorithmus ist eine eindeutige Handlungs-Vorschrift zur Loumlsung eines Problems bzw zur Erreichung eines Ziels
Diese Vorschrift muss einige Bedingungen erfuumlllen
ndash sie muss endlich sein
ndash sie muss eindeutig sein
ndash sie muss ausfuumlhrbar sein
Umfeld eines AlgorithmusDie Formulierung eines Algorithmus haumlngt ab von
ndash den operationalen Faumlhigkeiten Moumlglichkeiten des Ausfuumlhrenden
was kann der Ausfuumlhrende
ndash den sprachlichen Moumlglichkeiten der Sprache Notation in der der Agorithmus formuliert wird
was kann der eine sagen und der andere verstehen
Eine Woche Testen und Debuggen kann glatt einen ganzen Nachmittag Nachdenken ersetzenAlte Hacker-Weisheit
Seite 3
Algorithmen und Programme
Algorithmus
Mathematische ProblemeAlgorithmen werden sehr oft als Berechnungsvorschriften angesehen
die mathematische Problemstellungen loumlsen
zB Cormen et al
So verstanden sind Algorithmen Vorschriften zur Berechnung von Funktionen
Informally an algorithm is any well-defined computational procedure that takes some value or set of values as input and produces some value or set of values as output An algorithm is thus a sequence of computational steps that transform the input into the output
Seite 4
Algorithmen und Programme
Algorithmus
RechenmodellDie Faumlhigkeiten des Ausfuumlhrenden werden durch ein Rechenmodell spezifiziert
Man kann es als abstrakten hypothetischen Computer verstehen
Das Rechenmodell wird in der Regel nicht explizit angegeben
Es ist informal klar dass es sich um einen Computer mit den uumlblichen Faumlhigkeiten handelt
ndash Variablen
ndash arithmetische Operationen
ndash Anweisungen
ndash Prozeduren und Funktionen
Die theoretische Informatik hat bewiesen dass alle explizit formulierten Berechnungs-Modelle aumlquivalent sind
Es ist darum unnoumltig explizit darauf einzugehen
Seite 5
Algorithmen und Programme
Algorithmen
Algorithmen werden meist in Pseudocode formuliert
Pseudocode
ndash ist eine meist mathematisch inspirierte Notation
ndash mit der Berechungsschritte mit Hilfe mathematischer Notation formuliert werden
ndash von denen klar ist dass sie vom (gebildeten) Leser verstanden werden und sich in Basis-Operationen des Rechenmodells uumlbersetzen lassen
Algorithmen in Pseudocodendash koumlnnen voraussetzen dass der Ausfuumlhrer
beliebige exakt definierte berechenbare
Funktionen auszufuumlhren kann
ndash sie sind kompakter und uumlbersichtlicher als Programme
ndash und unabhaumlngig von aktuellen Technologien
Seite 6
Algorithmen und Programme
Pseudocode
Beispiel
Dies ist kein Algorithmus
also auch kein (Algorithmus in) Pseudocode
Analyse
ndash Primfaktoren von m und Primfaktoren von n
ist nicht OK es ist nicht klar ob es sich um Mengen Listen oder Multimengen handelt
ndash Alle Primfaktoren die in fn und f
m vorkommen
ist in der Folge ebenfalls nicht OK was ist gemeint ein Mengenschnitt
Seite 7
Algorithmen und Programme
Programme
DefinitionProgramme sind Algorithmen die in einer bestimmten Programmiersprache geschrieben sind
Programmiersprachen und ihre APIs
Programmiersprachen haben eine enorme Bedeutung fuumlr den praktizierenden Algorithmiker
ndash Jede Sprache kommt mit einer Bibliothek deren effektive Nutzung
einen produktiven (dh bezahlbaren) Entwickler ausmacht
ndash Die Bibliotheken (APIs) sind keine Sammlungen von Funktionen mehr sondern
Frameworks ndash keine Oumlkosysteme ndash in die die eigenen Loumlsungen hineinpassen muumlssen
ndash Algorithmen und Datenstrukturen muumlssen darum im Kontext einer Sprache und ihrer API entwickelt und realisiert werden
ndash Gluumlcklicherweise sind die Sprachen und ihre API sich oft aumlhnlich ndash Wer eine kennt wird die naumlchste leichter lernen
Seite 8
Algorithmen und Programme
Programme
Java-API
httpsdocsoraclecomjavase8docsapiindexhtml
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 3
Algorithmen und Programme
Algorithmus
Mathematische ProblemeAlgorithmen werden sehr oft als Berechnungsvorschriften angesehen
die mathematische Problemstellungen loumlsen
zB Cormen et al
So verstanden sind Algorithmen Vorschriften zur Berechnung von Funktionen
Informally an algorithm is any well-defined computational procedure that takes some value or set of values as input and produces some value or set of values as output An algorithm is thus a sequence of computational steps that transform the input into the output
Seite 4
Algorithmen und Programme
Algorithmus
RechenmodellDie Faumlhigkeiten des Ausfuumlhrenden werden durch ein Rechenmodell spezifiziert
Man kann es als abstrakten hypothetischen Computer verstehen
Das Rechenmodell wird in der Regel nicht explizit angegeben
Es ist informal klar dass es sich um einen Computer mit den uumlblichen Faumlhigkeiten handelt
ndash Variablen
ndash arithmetische Operationen
ndash Anweisungen
ndash Prozeduren und Funktionen
Die theoretische Informatik hat bewiesen dass alle explizit formulierten Berechnungs-Modelle aumlquivalent sind
Es ist darum unnoumltig explizit darauf einzugehen
Seite 5
Algorithmen und Programme
Algorithmen
Algorithmen werden meist in Pseudocode formuliert
Pseudocode
ndash ist eine meist mathematisch inspirierte Notation
ndash mit der Berechungsschritte mit Hilfe mathematischer Notation formuliert werden
ndash von denen klar ist dass sie vom (gebildeten) Leser verstanden werden und sich in Basis-Operationen des Rechenmodells uumlbersetzen lassen
Algorithmen in Pseudocodendash koumlnnen voraussetzen dass der Ausfuumlhrer
beliebige exakt definierte berechenbare
Funktionen auszufuumlhren kann
ndash sie sind kompakter und uumlbersichtlicher als Programme
ndash und unabhaumlngig von aktuellen Technologien
Seite 6
Algorithmen und Programme
Pseudocode
Beispiel
Dies ist kein Algorithmus
also auch kein (Algorithmus in) Pseudocode
Analyse
ndash Primfaktoren von m und Primfaktoren von n
ist nicht OK es ist nicht klar ob es sich um Mengen Listen oder Multimengen handelt
ndash Alle Primfaktoren die in fn und f
m vorkommen
ist in der Folge ebenfalls nicht OK was ist gemeint ein Mengenschnitt
Seite 7
Algorithmen und Programme
Programme
DefinitionProgramme sind Algorithmen die in einer bestimmten Programmiersprache geschrieben sind
Programmiersprachen und ihre APIs
Programmiersprachen haben eine enorme Bedeutung fuumlr den praktizierenden Algorithmiker
ndash Jede Sprache kommt mit einer Bibliothek deren effektive Nutzung
einen produktiven (dh bezahlbaren) Entwickler ausmacht
ndash Die Bibliotheken (APIs) sind keine Sammlungen von Funktionen mehr sondern
Frameworks ndash keine Oumlkosysteme ndash in die die eigenen Loumlsungen hineinpassen muumlssen
ndash Algorithmen und Datenstrukturen muumlssen darum im Kontext einer Sprache und ihrer API entwickelt und realisiert werden
ndash Gluumlcklicherweise sind die Sprachen und ihre API sich oft aumlhnlich ndash Wer eine kennt wird die naumlchste leichter lernen
Seite 8
Algorithmen und Programme
Programme
Java-API
httpsdocsoraclecomjavase8docsapiindexhtml
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 4
Algorithmen und Programme
Algorithmus
RechenmodellDie Faumlhigkeiten des Ausfuumlhrenden werden durch ein Rechenmodell spezifiziert
Man kann es als abstrakten hypothetischen Computer verstehen
Das Rechenmodell wird in der Regel nicht explizit angegeben
Es ist informal klar dass es sich um einen Computer mit den uumlblichen Faumlhigkeiten handelt
ndash Variablen
ndash arithmetische Operationen
ndash Anweisungen
ndash Prozeduren und Funktionen
Die theoretische Informatik hat bewiesen dass alle explizit formulierten Berechnungs-Modelle aumlquivalent sind
Es ist darum unnoumltig explizit darauf einzugehen
Seite 5
Algorithmen und Programme
Algorithmen
Algorithmen werden meist in Pseudocode formuliert
Pseudocode
ndash ist eine meist mathematisch inspirierte Notation
ndash mit der Berechungsschritte mit Hilfe mathematischer Notation formuliert werden
ndash von denen klar ist dass sie vom (gebildeten) Leser verstanden werden und sich in Basis-Operationen des Rechenmodells uumlbersetzen lassen
Algorithmen in Pseudocodendash koumlnnen voraussetzen dass der Ausfuumlhrer
beliebige exakt definierte berechenbare
Funktionen auszufuumlhren kann
ndash sie sind kompakter und uumlbersichtlicher als Programme
ndash und unabhaumlngig von aktuellen Technologien
Seite 6
Algorithmen und Programme
Pseudocode
Beispiel
Dies ist kein Algorithmus
also auch kein (Algorithmus in) Pseudocode
Analyse
ndash Primfaktoren von m und Primfaktoren von n
ist nicht OK es ist nicht klar ob es sich um Mengen Listen oder Multimengen handelt
ndash Alle Primfaktoren die in fn und f
m vorkommen
ist in der Folge ebenfalls nicht OK was ist gemeint ein Mengenschnitt
Seite 7
Algorithmen und Programme
Programme
DefinitionProgramme sind Algorithmen die in einer bestimmten Programmiersprache geschrieben sind
Programmiersprachen und ihre APIs
Programmiersprachen haben eine enorme Bedeutung fuumlr den praktizierenden Algorithmiker
ndash Jede Sprache kommt mit einer Bibliothek deren effektive Nutzung
einen produktiven (dh bezahlbaren) Entwickler ausmacht
ndash Die Bibliotheken (APIs) sind keine Sammlungen von Funktionen mehr sondern
Frameworks ndash keine Oumlkosysteme ndash in die die eigenen Loumlsungen hineinpassen muumlssen
ndash Algorithmen und Datenstrukturen muumlssen darum im Kontext einer Sprache und ihrer API entwickelt und realisiert werden
ndash Gluumlcklicherweise sind die Sprachen und ihre API sich oft aumlhnlich ndash Wer eine kennt wird die naumlchste leichter lernen
Seite 8
Algorithmen und Programme
Programme
Java-API
httpsdocsoraclecomjavase8docsapiindexhtml
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 5
Algorithmen und Programme
Algorithmen
Algorithmen werden meist in Pseudocode formuliert
Pseudocode
ndash ist eine meist mathematisch inspirierte Notation
ndash mit der Berechungsschritte mit Hilfe mathematischer Notation formuliert werden
ndash von denen klar ist dass sie vom (gebildeten) Leser verstanden werden und sich in Basis-Operationen des Rechenmodells uumlbersetzen lassen
Algorithmen in Pseudocodendash koumlnnen voraussetzen dass der Ausfuumlhrer
beliebige exakt definierte berechenbare
Funktionen auszufuumlhren kann
ndash sie sind kompakter und uumlbersichtlicher als Programme
ndash und unabhaumlngig von aktuellen Technologien
Seite 6
Algorithmen und Programme
Pseudocode
Beispiel
Dies ist kein Algorithmus
also auch kein (Algorithmus in) Pseudocode
Analyse
ndash Primfaktoren von m und Primfaktoren von n
ist nicht OK es ist nicht klar ob es sich um Mengen Listen oder Multimengen handelt
ndash Alle Primfaktoren die in fn und f
m vorkommen
ist in der Folge ebenfalls nicht OK was ist gemeint ein Mengenschnitt
Seite 7
Algorithmen und Programme
Programme
DefinitionProgramme sind Algorithmen die in einer bestimmten Programmiersprache geschrieben sind
Programmiersprachen und ihre APIs
Programmiersprachen haben eine enorme Bedeutung fuumlr den praktizierenden Algorithmiker
ndash Jede Sprache kommt mit einer Bibliothek deren effektive Nutzung
einen produktiven (dh bezahlbaren) Entwickler ausmacht
ndash Die Bibliotheken (APIs) sind keine Sammlungen von Funktionen mehr sondern
Frameworks ndash keine Oumlkosysteme ndash in die die eigenen Loumlsungen hineinpassen muumlssen
ndash Algorithmen und Datenstrukturen muumlssen darum im Kontext einer Sprache und ihrer API entwickelt und realisiert werden
ndash Gluumlcklicherweise sind die Sprachen und ihre API sich oft aumlhnlich ndash Wer eine kennt wird die naumlchste leichter lernen
Seite 8
Algorithmen und Programme
Programme
Java-API
httpsdocsoraclecomjavase8docsapiindexhtml
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 6
Algorithmen und Programme
Pseudocode
Beispiel
Dies ist kein Algorithmus
also auch kein (Algorithmus in) Pseudocode
Analyse
ndash Primfaktoren von m und Primfaktoren von n
ist nicht OK es ist nicht klar ob es sich um Mengen Listen oder Multimengen handelt
ndash Alle Primfaktoren die in fn und f
m vorkommen
ist in der Folge ebenfalls nicht OK was ist gemeint ein Mengenschnitt
Seite 7
Algorithmen und Programme
Programme
DefinitionProgramme sind Algorithmen die in einer bestimmten Programmiersprache geschrieben sind
Programmiersprachen und ihre APIs
Programmiersprachen haben eine enorme Bedeutung fuumlr den praktizierenden Algorithmiker
ndash Jede Sprache kommt mit einer Bibliothek deren effektive Nutzung
einen produktiven (dh bezahlbaren) Entwickler ausmacht
ndash Die Bibliotheken (APIs) sind keine Sammlungen von Funktionen mehr sondern
Frameworks ndash keine Oumlkosysteme ndash in die die eigenen Loumlsungen hineinpassen muumlssen
ndash Algorithmen und Datenstrukturen muumlssen darum im Kontext einer Sprache und ihrer API entwickelt und realisiert werden
ndash Gluumlcklicherweise sind die Sprachen und ihre API sich oft aumlhnlich ndash Wer eine kennt wird die naumlchste leichter lernen
Seite 8
Algorithmen und Programme
Programme
Java-API
httpsdocsoraclecomjavase8docsapiindexhtml
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 7
Algorithmen und Programme
Programme
DefinitionProgramme sind Algorithmen die in einer bestimmten Programmiersprache geschrieben sind
Programmiersprachen und ihre APIs
Programmiersprachen haben eine enorme Bedeutung fuumlr den praktizierenden Algorithmiker
ndash Jede Sprache kommt mit einer Bibliothek deren effektive Nutzung
einen produktiven (dh bezahlbaren) Entwickler ausmacht
ndash Die Bibliotheken (APIs) sind keine Sammlungen von Funktionen mehr sondern
Frameworks ndash keine Oumlkosysteme ndash in die die eigenen Loumlsungen hineinpassen muumlssen
ndash Algorithmen und Datenstrukturen muumlssen darum im Kontext einer Sprache und ihrer API entwickelt und realisiert werden
ndash Gluumlcklicherweise sind die Sprachen und ihre API sich oft aumlhnlich ndash Wer eine kennt wird die naumlchste leichter lernen
Seite 8
Algorithmen und Programme
Programme
Java-API
httpsdocsoraclecomjavase8docsapiindexhtml
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 8
Algorithmen und Programme
Programme
Java-API
httpsdocsoraclecomjavase8docsapiindexhtml
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 9
Interation und Rekursion
Wiederholung ist eine zentrale Faumlhigkeit der Computer und ein fundamentales Grundkonzept der Informatik
Wiederholung tritt in unterschiedlichen Formen aufndash im Tun Schleifen Rekursionndash in der Struktur Induktive (bdquorekursiveldquo) Strukturen
IterationSchleifenkonstrukte
RekursionRekursion ist ein Wiederholungskonzept Verallgemeinerung der Iteration
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 10
Iteration Sortieren und die Java-API
Iteration (in Form von Schleifen unterschiedlicher Art) bildet den Kern vieler Algorithmen
Beispiel Selection-SortDefinition Sortieren
Permutiere eine Liste vergleichbarer Objekte derart dass alle Elemente in auf- (ab-) steigender Reihenfolge auftreten
Prinzip des Selection-Sort-Algorithmus
Teile die Liste in zwei Teile sortiert unsortiert
Wiederhole Nimm das kleinste (groumlszligte) Element im unsortierten Teil und fuumlge es ndash durch Tauschen ndash in den sortierten Teil ein
Beginn
der sortierte Teil ist leer
Ende
der unsortierte Teil ist leer
sortiert unsortiert
1 7 3 5 9 00 7 3 5 9 10 1 3 5 9 70 1 3 5 9 70 1 3 5 9 70 1 3 5 7 90 1 3 5 7 9
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 11
Iteration Sortieren und die Java-API
Selection-Sort ndash Pseudocode (Notation nach Cormen amp al)
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 12
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Implementierung Algorithmus an ndash eine genaue Problemstellung und ndash eine Implementierungssprache
anpassen
Problemstellungndash Was genau soll sortiert werdenndash Welche Ordnungsrelation (lt) wird verwendet
Beispiele fuumlr Sortieraufgabenndash Ganze Zahlenndash Beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash Beliebige Daten mit einer speziell definierten Ordnungsrelation
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 13
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1
ndash Implementierungssprache Javandash Sortiere ganze Zahlen
package selection_sort
public class SortInts
public static void sort(int[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]lta[small]) small = j
swap a[i] and a[small] int t = a[small]a[small] = a[i]a[i] = t
sortiert unsortiert
i
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 14
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 1 Anwendung in einem Test
package selection_sort
import static orgjunitAssert
import orgjunitTest
public class SortIntsTest
Test public void test()
int[] a1 = new int[] 0 1 2 3 4 5 6 7 8 9 int[] a2 = new int[] 9 8 7 6 5 4 3 2 1 0 int[] a3 = new int[] 9 0 7 6 5 1 3 2 4 8 int[] a4 = new int[] 9 0 0 6 5 1 3 2 4 8
SortIntssort(a1)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a1)
SortIntssort(a2)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a2)
SortIntssort(a3)assertArrayEquals(new int[] 0 1 2 3 4 5 6 7 8 9 a3)
SortIntssort(a4)assertArrayEquals(new int[] 0 0 1 2 3 4 5 6 8 9 a4)
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 15
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 2
ndash Implementierungssprache Javandash Sortiere beliebige Daten mit einer natuumlrlichen Ordnungsrelationndash natuumlrliche Ordnungsrelation Objekte implementieren javalangComparable
Sortiert Felder mit Objekten vom Typ T die mit Objekten vom gleichen Typ vergleichbar sind
public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (a[j]compareTo(a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 16
Iteration Sortieren und die Java-API
Kenne Deine Sprache Generics
Algorithmen muumlssen mit den Mitteln einer Sprache ausgedruumlckt und in den Kontext einer API eingebettet werden
Generische Klassen und Methoden
Die Klasse Methode hat einen Typ-Parameter
Beschraumlnkte Typ-Parameter
Nicht jeder Typ ist als aktuelles Argument erlaubt
Comparable
Vergleichbar mit
T extends ComparableltTgt ~ T ist mit T vergleichbar
genauer T-Objekte mit T-Objekten vergleichbar
public static ltT extends ComparableltTgtgt void genSort(T[] a) hellip
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
a[j] ist kleiner als a[small]a[j] lt a[small] geht nicht da lt
nicht auf jedem Typ definiert ist
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 17
Iteration Sortieren und die Java-API
Kenne Deine API Comparable
Comparable
Ein Interface der Java-API Vergleichbar
Jeder ernsthafte SW-Entwickler muss seine Sprache
und deren API kennen und richtig nutzen
public static ltT extends ComparableltTgtgt void genSort(T[] a) helliphellip a[j]compareTo(a[small]) lt 0 hellip hellip
httpsdocsoraclecomjavase8docsapi
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 18
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3
ndash Implementierungssprache Javandash Sortiere Daten ohne natuumlrlichen Ordnungsrelationndash Ordnung muss zusaumltzlich als Comparator uumlbergeben werden
Sortiert Felder mit Objekten vom beliebigem Typ T Die Vergleichsoperation liefert der Comparator c
import javautilComparator
public class SortInts
public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c) final int n = alength
for (int i= 0 iltn i++) INV a[0i-1] is sorted
find the index of the smallest in a[in]int small = ifor (int j= i+1 jltn j++)
if (ccompare(a[j] a[small]) lt 0) small = j
swap a[i] and a[small] T t = a[small]a[small] = a[i]a[i] = t
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 19
Iteration Sortieren und die Java-API
Kenne Deine API Comparator
Comparator
Ein Interface der Java-API Vergleicher public static ltTgt void sortWithComparator(T[] a Comparatorlt super Tgt c)
hellip hellip if (ccompare(a[j] a[small]) lt0) small = j hellip
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 20
Iteration Sortieren und die Java-API
Selection-Sort ndash Implementierung
Beispiel 3 Anwendung mit Comparator in einem Test
class Record String name int age
public Record(String name int age) thisname = name thisage = age
Override public boolean equals(Object that) if (that instanceof Record) return thisequals((Record) that) else return false
public boolean equals(Record that) return thisnameequals(thatname) ampamp thisage == thatage
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
Record[] a1 = new Record(a 1) new Record(a 2) new Record(b 1) new Record(b 2) new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 new RecordComparator())
Klasse ohne definierte Ordnung auf den Objekten Sortieren erfordert einen Comparator
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 21
Iteration Sortieren und die Java-API
Kenne Deine API functional Interface
Comparator ist ein
funktionales Interface
Record[] a1 = new Record(a 1)new Record(a 2) new Record(b 1) new Record(b 2)new Record(d 10) new Record(d 11)
SelectionSortsortWithComparator(a1 (r1 r2) -gt
if (r1namecompareTo(r2name) == 0) return r1age - r2age
else return r1namecompareTo(r2name)
)
class RecordComparator implements ComparatorltRecordgt Override public int compare(Record r1 Record r2) if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name)
new RecordComparator()
nicht notwendig
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 22
Iteration Sortieren und die Java-API
Insertion-Sort
Sortiere indem Du fuumlr das naumlchste Element den richtigen Platz zum Einfuumlgen findest
bdquoSpielkarten-Sortier-Verfahrenldquo
public final class InsertionSort private InsertionSort() public static ltT extends ComparableltTgtgt void genSort(T[] a)
final int n = alength for (int i= 0 iltn i++) INV a[0i-1] is sorted
find j in a[0i-1] with a[j] gt= a[i] int j = 0 while (j lt i ampamp a[j]compareTo(a[i]) lt 0) j++ Assert i = j ampamp a[j] gt= a[j] || j == i if (j=i) insert a[i] at position j T insertee = a[i] for(int k=i k gt j k--) a[k] = a[k-1] a[j] = insertee
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 23
Iteration Sortieren und die Java-API
Sortieren ndash Bemerkung
In einer realen Anwendung wird man immer das Collections-Framework zum Sortieren nutzen (Selbst geschriebene Sortier-Methoden werden von Profis moumlglichst vermieden)
static ltTgt void sort(T[ ] a Comparatorlt super Tgt c)
static void sort(Object[] a)
static void sort(int[] a)
package selection_sort
import javautilArrays
public class Standard
public static void main(String[] args)
int[] a1 = new int[] 9 0 7 6 5 1 3 2 4 8 Arrayssort(a1)
String[] a2 = g h i a a j a a e f Arrayssort(a2)
Record[] a3 = new Record(a 2) new Record(d 10) new Record(d 11) new Record(b 2) new Record(b 1) new Record(a 1)
Arrayssort(a3 (r1 r2) -gt if (r1namecompareTo(r2name) == 0) return r1age - r2age else return r1namecompareTo(r2name) )
verwendete API-Funktion
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 24
Iteration
Korrektheit einer Schleife
Warum ist der Algorithmus bdquoSelection-Sortldquo korrekt
Selection-Sort(A)
1 for i larr 1 to length[A] do2 j larr Index of smallest in A[ilength(A)]3 swap(a[i] a[j])
Korrektheit
ndash Wie ist die Aufgabe spezifiziert
ndash Warum erfuumlllt der Algorithmus die Spezifikation
Spezifikation des Sortierens
ndash Erzeuge eine Permutation der Ausgangsfolge
ndash bei der alle Elemente groumlszliger kleiner oder gleich ihrem Vorgaumlnger sind
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 26
Rekursive Definition von Algorithmen
Mit einer rekursiven Definition wird ein Algorithmus definiert durch
ndash Angabe eines Verfahrensndash das das gleiche Verfahren als Teilaktion enthaumllt
Beispiel Fakultaumltsberechnung ndash n = 1 falls n==1 sonst (n-1) n
Aufgabe
Das Quadrieren von natuumlrlichen Zahlen kann rekursiv definiert werden als
(n + 1)2 = n2 + 2n + 1
mit 12 = 1
Schreiben Sie eine Implementierung (in Java) dieses Algorithmus
Testen Sie Ihre Implementierung mit einem Junit-Test
Rekursion
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 27
Teile-und-Herrsche (Divide-and-Conquer)
Eine wichtige algorithmische Technik besteht darin
ein komplexes Problem in eine Serie von einfacheren Problemen gleicher Art zu zergliedern deren Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten besiegt wenn sie in kleine Trupps aufgespalten werden und diese dann getrennt besiegt werden)
Das Verfahren funktioniert nur wenn Subprobleme einfacher sind als das Gesamtproblem und wenn das Zergliedern ein Ende in sehr einfachen Problemen findet
Rekursion und Teile-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoTeile-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 28
Reduziere-und-Herrsche (Reduce-and-Conquer)
Eine Variante der Technik Teile-und-Herrsche besteht darin
ein komplexes Problem auf ein einfacheres Problem gleicher Art zu reduzieren dessen Loumlsung zu einer Loumlsung des Gesamtproblems kombiniert werden kann
(Ein Trupp von Feinde werden am besten einer nach dem anderen besiegt)
Das Verfahren funktioniert nur wenn das Subprobleme einfacher sind als das Gesamtproblem und wenn das Reduzierten ein Ende in einem sehr einfachen Problemen findet
Rekursion und Reduziere-und-HerrscheEine Loumlsungsstrategie nach dem Prinzip bdquoReduziere-und-Herrscheldquo kann sofort in einen rekursiven Algorithmus umgesetzt werden
Rekursion
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 29
Rekursion als Reduziere-und-Herrschendash Basisfall Loumlse das Problem fuumlr den (einen) einfachsten Fall
Beispiel fakultaumlt(0) = 1
ndash Loumlse das Problem fuumlr jeden bdquogroszligenldquo Fall durch Reduktion auf einen kleineren Fall
Reduktion auf = unter Zuhilfenahme von
Beispiel fakultaumlt(n) = fakultaumlt(n-1)n
Induktionsbeweisndash Basisfall Beweise die Behauptung fuumlr einen einfachen Fall
ndash Induktionsschritt Beweise die Behauptung fuumlr den allgemeinen Fall unter der Annahmen dass die Behauptung fuumlr den kleineren Fall bewiesen ist
Rekursion und Induktionsbeweise
Hinweis 1 Das Entwickeln von Algorithmen ist wie Radfahren man lernt es nicht durch Zuschauen sondern durch selbst tun
Hinweis 2 Das gilt insbesondere fuumlr rekursive Algorithmen
Hinweis 3 Informatiker die ohne Rekursion auskommen sind wie ein Adler ohne Fluumlgel Im Prinzip schon irgendwie denkbar aber doch sehr sehr stark behindert
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 30
Merge-Sort
ndash Merge-Sort Sortieren durch Vermischen ndash Ein Sortier-Algorithmus nach dem Prinzip Teile-und-Herrschendash Algorithmus
Die Aufgabe Sortiere die Folge f wird reduziert auf die Einfacheren Teilaufgaben
Sortiere eine Teilfolge f1
Sortiere eine Teilfolge f2
Deren Ergebnis dann vermischt wird
Beispielsort ([1 9 7 2 7 4 7 2 8]) teile
=gt merge (
sort([1 9 7 2 7]) herrsche uumlber Teilproblem 1 (rekursiv)
sort([4 7 2 8])) herrsche uumlber Teilproblem 2 (rekursiv)
= merge ( [1 2 7 7 9] [2 4 7 8] ) kombiniere zur Gesamtloumlsung
= [1 2 2 4 7 7 7 8 9]
Aufgabendash Merge-Sort ist ein Algorithmus auf einer induktiv definierten Menge ndash Welcher
Geben Sie die induktive Definition an
Rekursion
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 31
Merge-Sort
Definition des Algorithmus (Cromen amp al)
Rekursion
Merge-Sort(Apr)
1 if p lt r then2 q larr ⎣(p+r)2⎦3 Merge-Sort(Apq)4 Merge-Sort(Aq+1r)5 Merge(A p q r)
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 32
Merge-Sort Java-Implementierung fuumlr int-Arrays
Rekursion
public final class MergeSort
private MergeSort()
static public void sort(int[] a) sortR(a 0 alength-1)
private static void sortR(int[] a int p int r) if (r lt= p) return int q = (r+p)2 sortR(a p q) sortR(a q+1 r) merge(a p q r)
private static void merge(int[] a int p int q int r) int p1 = p runs through left part int p2 = q+1 runs through right part int d = 0 runs through destination int[] temp = new int[(r-p)+1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1] lt= a[p2]) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i=0 ilt=r-p i++) a[p+i] = temp[i]
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-
Seite 33
Merge-Sort Java-Implementierung fuumlr generische Arrays
Rekursion
import javalangreflectArray
public final class MergeSort private MergeSort() static public ltT extends ComparableltTgtgt void sort(T[] a) sortR(a 0 alength - 1) private static ltT extends ComparableltTgtgt void sortR(T[] a int p int r) if (r lt= p) return int q = (r + p) 2 sortR(a p q) sortR(a q + 1 r) merge(a p q r)
private static ltT extends ComparableltTgtgt void merge(T[] a int p int q int r) int p1 = p runs through left part int p2 = q + 1 runs through right part int d = 0 runs through destination
SuppressWarnings(unchecked) T[] temp = (T[]) ArraynewInstance(a[0]getClass() (r - p) + 1) oder T[] temp = (T[]) new Comparable[(r - p) + 1]
while (p1 lt= q ampamp p2 lt= r) if (a[p1]compareTo(a[p2]) lt= 0) temp[d++] = a[p1++] else temp[d++] = a[p2++] while (p1 lt= q) temp[d++] = a[p1++] while (p2 lt= r) temp[d++] = a[p2++]
for (int i = 0 i lt= r - p i++) a[p + i] = temp[i]
- Slide 1
- Slide 2
- Slide 3
- Slide 4
- Slide 5
- Slide 6
- Slide 7
- Slide 8
- Slide 9
- Slide 10
- Slide 11
- Slide 12
- Slide 13
- Slide 14
- Slide 15
- Slide 16
- Slide 17
- Slide 18
- Slide 19
- Slide 20
- Slide 21
- Slide 22
- Slide 23
- Slide 24
- Slide 26
- Slide 27
- Slide 28
- Slide 29
- Slide 30
- Slide 31
- Slide 32
- Slide 33
-