Praktische Informatik I Der Imperative Kern Suchen, Selektieren und Sortieren

Transkript

1 Praktische Informatik I Der Imperative Kern Suchen, Selektieren und Sortieren Prof. Dr. Stefan Edelkamp Institut für Künstliche Intelligenz Technologie-Zentrum für Informatik und Informationstechnik (TZI) Am Fallturm 1, Bremen +49-(0) Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

2 Suchen, Selektieren und Sortieren In diesem Abschnitt werden schnelle Verfahren auf geordneten Mengen besprochen, wobei die Effizienz in der Anzahl der Schlüsselvergleiche gemessen wird. Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

3 Outline 1 Gleichzeitige Suche von Mini- und Maximum 2 Schnelles Suchen 3 Schnelles Sortieren 4 Kryptogramme 5 Nimm Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

4 Zwei auf einen Streich Das gleichzeitige Finden vom Minimum und vom Maximum in einem Feld (engl. array) der Größe n kann mit wenigen Vergleichen elegant durch Rekursion gelöst werden kann. Dazu wird das Feld in zwei gleich große Teile geteilt und das Minimum und Maximum in beiden Teilen bestimmt. Nach dem rekursiven Aufruf kann man nun das Maximum beider Maxima und das Minimum beider Minima berechnen und an die aufrufende Rekursionsstufe weiterleiten. Der Abbruch erfolgt, wenn die Aufteilung zu einem Feld mit nur einem Element führt. Der Einfachheit halber nehmen wir im Programm 1 an, dass n eine Zweierpotenz ist. Für den Rückgabe wurde ein Verbund genutzt. Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

5 Programm 1: Mini- und Maximum-Berechnung. import java.util.random; public class MinMax { int [] a; public class MM { int min; int max; ; public MinMax(int N) { Random r = new Random(); a = new int[n]; for (int i=0;i<n;i++) { a[i] = r.nextint(1000); System.out.print(a[i]+ ","); System.out.println(); MM search(int x, int y) { MM m = new MM(); if (y <= x+1) { m.min = a[x]<a[y]? x : y; m.max = a[x]<a[y]? y : x; else { // y > x+1, recursive call required MM l = search(x,(x+y)/2), r = search((x+y)/2+1,y); m.min = a[l.min] < a[r.min]? l.min : r.min; m.max = a[l.max] > a[r.max]? l.max : r.max; return m; Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

6 Outline 1 Gleichzeitige Suche von Mini- und Maximum 2 Schnelles Suchen 3 Schnelles Sortieren 4 Kryptogramme 5 Nimm Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

7 Partitionierung Die Partition eines Arrays der Länge n bzgl. eines ausgewählten Pivotelements ist eine Aufteilung in zwei Bereiche: 1 eines mit Elementen, die kleiner als das Pivotelement sind 2 eines mit Elementen, die größer als das Pivotelement sind Elemente, die gleich dem Pivotelement sind, können sich beliebig auf die Teillisten verteilen. Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

8 Selektion Die Selektionsaufgabe sucht nach dem k.-kleinsten Element (z.b. ist die 3.-kleinste Zahl von 5, 1, 3, 7 die 5). Dabei rekurriert Programm 7 nach dem Partitionierungsschritt. Für Permutationen von 1,..., n ist das k.-kleinste Element in der aufsteigend sortierten Reihenfolge der Zahlen gleich k, d.h., bei der Eingabe 3 sollte die Ausgabe vergleichbar mit 3,6,1,7,8,4,9,5,2,0, Quickselect 3 = 3 sein. Das mittlere Element in der sortierten Reihenfolge heißt Median. Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

9 Programm 2: Selektion mit Quickselect und Sortieren mit Quicksort. import java.util.random; public class Quick { private int a[]; / Constructor for objects of class n number of array k position k for k th element selection / public Quick(int n, int k) { a = new int[n]; Random r = new Random(); for (int i=0;i<n;i++) a[i] = i; for (int i=1;i<n;i++) swap(i,r.nextint(i)); System.out.println("Quickselect "+ select(0,n 1,k)); for (int i=1;i<n;i++) swap(i,r.nextint(i)); sort(0,n 1); for (int i=0;i<n;i++) System.out.print(a[i]+" "); System.out.println(); void swap(int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

10 Programm 3: Selektion mit Quickselect. public int select(int left, int right, int k) { int i,j,v; i = left; j = right+1; v=a[left]; // set pivot do { // partition wrt. pivot do j ; while (j>=i && v < a[j]); do i++; while (i<=j && a[i] < v); if (j > i) swap(i,j); while(j >= i); swap(left,j); // move pivot, end of partitioning if (k == j) return a[k]; // element found return k < j? select(left,j,k) : select(j+1,right,k); Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

11 Outline 1 Gleichzeitige Suche von Mini- und Maximum 2 Schnelles Suchen 3 Schnelles Sortieren 4 Kryptogramme 5 Nimm Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

12 Quicksort Das Programm Quicksort nutzt den gleichen Partionierungsschritt und rekurriert jedoch in beide Arrayhälften, um das Elementarray letztendlich vollständig anzuordnen. Quicksort ist noch immer eines der in der Praxis schnellsten Sortierverfahren Es gibt oft fertige Bibliotheksfunktionen, wie Introsort Diese Verfahren wählen für ein (oder zwei) Pivotelement(e) den Median aus mehreren Elementen aus. Introsort weicht für spezielle Fälle auf andere Sortierverfahren aus. Die im Erwartungsfall beste Wahl für das Pivotelement ist der Median aus n vielen Elementen. Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

13 Programm 4: Sortieren mit Quicksort. public void sort(int left, int right) { int i,j,v; // two indices and one temporary if (right left > 0) { // interval is non trivial i = left; j = right+1; v=a[left]; // set pivot do { // partition wrt. pivot do j ; while (j>=i && v < a[j]); do i++; while (i<=j && a[i] < v); if (j > i) swap(i,j); while(j >= i); swap(left,j); // move pivot, end of partitioning if (j left < right i+1) { sort(left,j 1); sort(j+1,right); else { sort(j+1,right); sort(left,j 1); Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

14 QuickXSort Eine Verallgemeinerung ist QuickXSort, bei dem in einem Teil des Arrays ein Sortierverfahren X angewendet wird und im anderen Teil rekuriert wird. Die Aufteilung der Elemente geschieht umgekehrt zu Quicksort. Da X nur auf den kleineren der beiden Teile angewendet wird, darf X sich Elemente aus dem größeren Teil und somit auf Zusatzspeicher zurückgreifen. Eine gute Wahl für X mit geringer Vergleichsanzahl ist Mergesort einem klassischen Divide-and-Conquer Verfahren, das die zu sortierenden Daten rekursiv in kleinere Teile zerlegt Die sortierten Teile werden dann im Reißverschlussverfahren zu größeren Teilen zusammengefügt (engl. (to) merge), bis eine sortierte Gesamtsequenz erreicht ist. Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

15 Outline 1 Gleichzeitige Suche von Mini- und Maximum 2 Schnelles Suchen 3 Schnelles Sortieren 4 Kryptogramme 5 Nimm Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

16 SEND + MORE = MONEY Ein Kryptogramm (engl. Cryptarithm) ist eine mathematische Gleichung, deren Ziffern durch Variablen ersetzt wurden. Aufgabe Finde eine die Gleichung erfüllende Variablenbelegung. BLAU * ROT VITA * MAX YIN WEG * STADT YANG ANLR WXXX DDAET OINL MWTX TEILT TTGNZ ALNE WIWG WCIG DISTANZ ANTENNE WICHTIG Das Problem gehört zur Klasse der Constraint-Satisfaction Probleme Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

17 Programm 5: Lösung eines Kryptogramms. public class Arithmetics { public Arithmetics() { for (int B=1;B<=9;B++) for (int L=0;L<=9;L++) if (L!=B) for (int A=1;A<=9;A++) if (A!=L && A!=B) for (int U=0;U<=9;U++) if (U!=A && U!=B && U!=L) for (int R=1;R<=9;R++) if (R!= U && R!=A && R!=B && R!=L) for (int N=0;N<=9;N++) if (N!=R && N!= U && N!=A && N!=B && N!=L) for (int T=0;T<=9;T++) if (T!= N && T!=R && T!= U && T!=A && T!=B && T!=L) for (int E=0;E<=9;E++) if (E!=T && E!= N && E!=R && E!= U && E!=A && E!=B && E!=L) for (int O=1;O<=9;O++) if (O!=E && O!=T && O!= N && O!=R && O!= U && O!=A && O!=B && O!=L) for (int I=0;I<=9;I++) if (I!=O && I!=E && I!=T && I!= N && I!=R && I!= U && I!=A && I!=B && I!=L) if ((B L A 10 + U) (100 R + 10 O + T) == A N T E N N 10 + E && (A N L R O I N L 10 + A L N 10 + E == A N T E N N 10 + E)) System.out.println("B="+B+" L="+L+" A="+A+ " U="+U+" R="+R+" O="+O+" T="+T); Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

18 Outline 1 Gleichzeitige Suche von Mini- und Maximum 2 Schnelles Suchen 3 Schnelles Sortieren 4 Kryptogramme 5 Nimm Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

19 Zwei Personen: Null Summe? Viele Löser im Zweipersonennullsummenspiel wie im Schach beruhen auf Minimax und Alpha-Beta Pruning. Eingabe ist u, Schranken sind α, β. Die Ausgabe ist der ermittelte spieltheoretischer Wert. Procedure NegmaxAlphaBeta if (leaf(u)) return Eval(u) No successor, static evaluation res α Initialize value res for current frame for each v Successors(u) Traverse successor list val NegmaxAlphaBeta(v, β, res) Initialize cut-off value if (val > res) res val Update res if (res β) return res Perform cut-off return res Return final evaluation Manche Probleme lassen sich aber direkt lösen, z.b. TicTacToe oder Nimm... Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

20 Streichholz-Ziehen Nimm ist ein Zweipersonennullsummen-Spiel mit binären Ausgang. Zustand Es gibt k Zeilen mit a i, i = 1,..., k, Streichhölzern. Zug Die Spieler nehmen abwechselnd l Streihölzer aus einer Reihe j {1,..., k, so dass a j l Hölzer verbleiben. Verloren hat derjenige Spieler, der nicht mehr ziehen kann. Retrograde-Klassifikation Zustände lassen sich nach und nach in gewonnen und verloren einteilen (Annahme: Optimales Spiel) Optimale Strategie beruht auf dem XOR-Wert der Binärzahlen der Streichholzzahl Verloren XOR = 0 XOR = bin(a 1 )... bin(a k ) Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

21 Programm 6: Spiellogik im Nimm-Spiel. void print () { for(int i=0;i<size;i++) { System.out.print(i+". ("+ a[i]+ "):\t"); for (int j=0;j<a[i];j++) System.out.print(" "); System.out.println(); System.out.println("xor :" + xor()); public void take(int i, int j) { a[i] = j; print(); public int xor () { int r = 0; for(int i=0;i<size;i++) r = r ^ a[i]; return r; public boolean gameover () { int r = 0; for(int i=0;i<size;i++) r = r + a[i]; return (r==0); Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

22 Programm 7: Löser des Nimm-Spiels. public void solve() { int r = xor(); if (r == 0) { System.out.println("Your move!"); return; System.out.println("My move!"); for (int i=0;i<size;i++) { for (int j=1;j<=a[i];j++) { if (a[i] >= j) { int temp = a[i]; a[i] = j; if (xor() == 0) { System.out.println("Taking " + j + " from " + i); print(); return; a[i] = temp; System.out.println("Error"); Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23

23 Merke: Rekursive Algorithmen verfahren nach dem Prinzip Teile-und-Herrsche (engl. divide-and-conquer) und lösen das übergeordnete Problem durch die rekursive Lösung der Teilprobleme und das Zusammenführen der rekursiv erzielten Lösungen. Diskussion (untereinander): Welche Funktionen (Min/Maximum, Auswählen, Bruchrechnen) braucht man wozu? Welche Funktionen lassen sich iterativ umsetzen? Für die automatische Generierung von zufälligen Zahlen wurde die Funktion rand genommen. Sie liefert bei jedem Programmstart die gleichen Zahlen. Wozu ist das nützlich und wie kann man andere Zahlen generieren? Stefan Edelkamp (IAI) PI 1 Imperativer Kern January 9, / 23