10. Vorlesung (19.11.2013)

Algorithmen und Datenstrukturen
Wintersemester 2013/14
10. Vorlesung
Algorithmen in Java
Krzysztof Fleszar
Lehrstuhl für Informatik I
1
Übersicht
• Berechnung der Potenz für zwei ganze Zahlen
• Klausuraufgabe SS 2010 !
• Berechnung der Cosinus-Funktion
• Klausuraufgabe WS 2010/2011 !
• Standard- und Referenzdatentypen
• Sortieren mit InsertionSort und MergeSort
• Anwendung: Zählen von falsch geordneten Paaren
• Anpassung der Algorithmen
2
Iterative Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
public class Potenz {
public static void main(String[] args) {
int x = 3;
int y = 4;
int potenz = 1;
for (int i = 0; i < y; i++) { //wird y-mal ausgefuehrt
potenz *= x;
}
System.out.println(x + " hoch " + y + " ist " + potenz);
}
}
3
Iterative Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
public class Potenz {
public static void main(String[] args) {
int x = 3;
int y = 4;
Besser:
Potenzberechnung
in eigener Methode
System.out.println(x + " hoch " + y + " ist " + potenz(x,y));
}
}
4
Iterative Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
public class Potenz {
public static void main(String[] args) {
int x = 3;
int y = 4;
System.out.println(x + " hoch " + y + " ist " + potenz(x,y));
}
public static int potenz(int x, int y) {
int potenz = 1;
for (int i = 0; i < y; i++) { //wird y-mal ausgefuehrt
potenz *= x;
}
return potenz;
}
}
5
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
public class Potenz {
public static void main(String[] args) {
int x = 3;
int y = 4;
System.out.println(x + " hoch " + y + " ist " + potenz(x,y));
}
public static int potenz(int x, int y) {
if (y == 0) return 1;
return x * potenz(x, y - 1);
}
}
An Basisfall denken!
𝑦
𝑥
=𝑥⋅
𝑦−1
𝑥
6
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
public class Potenz {
public static void main(String[] args) {
int x = 3;
int y = 4;
System.out.println(x + " hoch " + y + " ist " + potenz(x,y));
}
public static int potenz(int x, int y) {
if (y == 0) return 1;
return x * potenz(x, y - 1);
}
}
𝑦
𝑥
=𝑥⋅
Wie oft wird potenz aufgerufen?
𝑦−1
𝑥
𝑦 + 1 -mal
7
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Geht es besser?
𝑦
𝑥 =𝑥
𝑦
𝑥 =𝑥
𝑦 ⁄2
⋅𝑥
𝑦 ⁄2
𝑦 ⁄2
⋅𝑥
𝑦 ⁄2
falls 𝑦 gerade
⋅ 𝑥 falls 𝑦 ungerade
8
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Geht es besser?
𝑦
𝑥 =𝑥
𝑦
𝑥 =𝑥
𝑦 ⁄2
𝑦 ⁄2
⋅𝑥
⋅𝑥
𝑦 ⁄2
𝑦 ⁄2
falls 𝑦 gerade
⋅ 𝑥 falls 𝑦 ungerade
public static int potenz(int x, int y) {
if (y == 0) return 1;
int p = potenz(x, y / 2) * potenz(x, y / 2);
if (y % 2 == 0) return p;
return p * x;
9
}
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Rekursionsgleichung (𝑛 = 𝑦):
𝑇 𝑛 = 2𝑇 𝑛⁄2 + Θ 1
public static int potenz(int x, int y) {
if (y == 0) return 1;
int p = potenz(x, y / 2) * potenz(x, y / 2);
if (y % 2 == 0) return p;
return p * x;
10
}
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Rekursionsgleichung:
𝑇 𝑛 = 2𝑇 𝑛⁄2 + Θ 1
𝑎
𝑏
𝑓 𝑛
𝑓 ∈ 𝑂 𝑛1−𝜀
log 𝑏 𝑎 = log 2 2 = 1
z.B. für 𝜀 = 0,5
Also gilt mit Fall 1 des Master-Theorems:
𝑇∈Θ 𝑛
11
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Geht es besser?
𝑦
𝑥 =𝑥
𝑦
𝑥 =𝑥
𝑦 ⁄2
𝑦 ⁄2
⋅𝑥
⋅𝑥
𝑦 ⁄2
𝑦 ⁄2
falls 𝑦 gerade
⋅ 𝑥 falls 𝑦 ungerade
public static int potenz(int x, int y) {
if (y == 0) return 1;
int p = potenz(x, y / 2) * potenz(x, y / 2);
if (y % 2 == 0) return p;
return p * x;
12
}
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Geht es besser?
𝑦
𝑥 =𝑥
𝑦
𝑥 =𝑥
𝑦 ⁄2
𝑦 ⁄2
⋅𝑥
⋅𝑥
𝑦 ⁄2
𝑦 ⁄2
falls 𝑦 gerade
⋅ 𝑥 falls 𝑦 ungerade
public static int potenz(int x, int y) {
if (y == 0) return 1;
int p = potenz(x, y / 2);
if (y % 2 == 0) return p * p;
return p * p * x;
}
13
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Rekursionsgleichung (𝑛 = 𝑦):
𝑇 𝑛 = 𝑇 𝑛⁄2 + Θ 1
𝑎
𝑏
𝑓 𝑛
log 𝑏 𝑎 = log 2 1 = 0
𝑓∈Θ 1
Also gilt mit Fall 2 des Master-Theorems:
𝑇 ∈ Θ log 𝑛
14
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Wie oft wird potenz aufgerufen?
𝑦 wird in jedem Aufruf mindestens um
die Hälfte verringert.
Für 𝑦 = 2𝑘 gibt es 𝑘 + 2 = log 2 𝑦 + 2 Aufrufe.
public static int potenz(int x, int y) {
if (y == 0) return 1;
int p = potenz(x, y / 2);
if (y % 2 == 0) return p * p;
return p * p * x;
}
15
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Wie oft wird potenz aufgerufen?
𝑦 wird in jedem Aufruf mindestens um
die Hälfte verringert.
Es gibt
log 2 𝑦 + 2
Aufrufe!
public static int potenz(int x, int y) {
if (y == 0) return 1;
int p = potenz(x, y / 2);
if (y % 2 == 0) return p * p;
return p * p * x;
}
16
Rekursive Berechnung der Potenz
Berechnung der Potenz 𝑥 𝑦 für zwei ganze Zahlen 𝑥 und 𝑦.
Wie oft wird potenz aufgerufen?
𝑦 wird in jedem Aufruf mindestens um
die Hälfte verringert.
Es gibt
Θ log 𝑦
Aufrufe!
public static int potenz(int x, int y) {
if (y == 0) return 1;
int p = potenz(x, y / 2);
if (y % 2 == 0) return p * p;
return p * p * x;
}
17
Übersicht
• Berechnung der Potenz für zwei ganze Zahlen
• Klausuraufgabe SS 2010 !
• Berechnung der Cosinus-Funktion
• Klausuraufgabe WS 2010/2011 !
• Standard- und Referenzdatentypen
• Sortieren mit InsertionSort und MergeSort
• Anwendung: Zählen von falsch geordneten Paaren
• Anpassung der Algorithmen
18
Berechnung der Cosinus-Funktion
cos 71.356° =
180°
360°
?
19
Berechnung der Cosinus-Funktion
1
cos 𝑥 cos 𝑦 = cos 𝑥 − 𝑦 + cos 𝑥 + 𝑦
2
20
Berechnung der Cosinus-Funktion
1
cos 𝑥 cos 𝑦 = cos 𝑥 − 𝑦 + cos 𝑥 + 𝑦
2
⟺ cos 𝑥 + 𝑦 = 2cos 𝑥 cos 𝑦 − cos 𝑥 − 𝑦
⇒ cos 2𝑥 = 2cos 2 𝑥 −1
𝑥
2
⇒ cos 𝑥 = 2cos −1
2
21
Berechnung der Cosinus-Funktion
𝑥
cos 𝑥 = 2cos −1
2
2
public class Cosinus {
public static void main(String[] args) {
for (double i = 0; i <= 360; i += 15) {
System.out.println("cos " + i + " = "
+ cos(i * Math.PI / 180.0));
}
}
public static double cos(double x) {
return 2.0 * cos(x / 2.0) * cos(x / 2.0) - 1;
}
}
22
Berechnung der Cosinus-Funktion
𝑥
cos 𝑥 = 2cos −1
2
2
public class Cosinus {
public static void main(String[] args) {
for (double i = 0; i <= 360; i += 15) {
System.out.println("cos " + i + " = "
+ cos(i * Math.PI / 180.0));
}
}
public static double cos(double x) {
double cosX2 = cos(x / 2.0);
return 2.0 * cosX2 * cosX2 - 1;
}
}
23
Berechnung der Cosinus-Funktion
𝑥
cos 𝑥 = 2cos −1
2
2
Näherung für kleine Winkel (𝑥 < 0.001): cos 𝑥 = 1
public static double cos(double x) {
if (x < 0.001) return 1;
double cosX2 = cos(x / 2.0);
return 2.0 * cosX2 * cosX2 - 1;
}
180°
360°
24
Berechnung der Cosinus-Funktion
𝑥
cos 𝑥 = 2cos −1
2
2
Ausgabe:
cos
cos
cos
cos
0.0 = 1.0
15.0 = 1.0
30.0 = 1.0
45.0 = 1.0
⋮
cos 360.0 = 1.0
public static double cos(double x) {
if (x < 0.001) return 1;
double cosX2 = cos(x / 2.0);
return 2.0 * cosX2 * cosX2 - 1;
}
25
Berechnung der Cosinus-Funktion
𝑥
cos 𝑥 = 2cos −1
2
2
Näherung für kleine Winkel (𝑥 < 0.001):
1 2
cos 𝑥 = 1 − 𝑥
2
public static double cos(double x) {
if (x < 0.001) return 1 – 0.5 * x * x;
double cosX2 = cos(x / 2.0);
return 2.0 * cosX2 * cosX2 - 1;
}
180°
360°
26
Berechnung der Cosinus-Funktion
𝑥
cos 𝑥 = 2cos −1
2
2
Näherung für kleine Winkel (𝑥 < 0.001):
1 2
cos 𝑥 = 1 − 𝑥
2
1,5
1
0,5
0
0
50
100
150
200
250
300
350
400
-0,5
-1
-1,5
27
Berechnung der Cosinus-Funktion
𝑥
cos 𝑥 = 2cos −1
2
Achtung: Verwende besser Methode cos
der Klasse java.lang.Math
2
28
Übersicht
• Berechnung der Potenz für zwei ganze Zahlen
• Klausuraufgabe SS 2010 !
• Berechnung der Cosinus-Funktion
• Klausuraufgabe WS 2010/2011 !
• Standard- und Referenzdatentypen
• Sortieren mit InsertionSort und MergeSort
• Anwendung: Zählen von falsch geordneten Paaren
• Anpassung der Algorithmen
29
Methoden mit Standarddatentypen
Inkrementieren einer Zahl a .
public class Zaehler {
public static void main(String[] args) {
int a = 1;
inkrementiere(a);
System.out.println("a = " + a);
}
public static void inkrementiere(int a) {
a++;
}
}
Ausgabe:
a = 1
30
Methoden mit Standarddatentypen
Inkrementieren einer Zahl a .
public class Zaehler {
public static void main(String[] args) {
int a = 1;
inkrementiere(a);
System.out.println("a = " + a);
}
public static void inkrementiere(int a) {
a++;
}
}
Bei Standarddatentypen wird Wert
von Variablen übergeben.
31
Methoden mit Standarddatentypen
Inkrementieren einer Zahl a .
public class Zaehler {
public static void main(String[] args) {
int a = 1;
a = inkrementiere(a);
System.out.println("a = " + a);
}
public static int inkrementiere(int a) {
return a + 1;
}
}
32
Methoden mit Referenzdatentypen
Inkrementieren der Zahlen in einem Feld.
public class FeldZaehler {
public static void main(String[] args) {
int[] A = {1, 3, 2, 4};
inkrementiere(A);
for (int i = 0; i < A.length; i++)
System.out.println("A" + i + " = " + A[i]);
}
public static void inkrementiere(int[] A) {
for (int i = 0; i < A.length; i++) A[i]++;
}
}
33
Methoden mit Referenzdatentypen
Inkrementieren der Zahlen in einem Feld.
public class FeldZaehler {
public static void main(String[] args) {
int[] A = {1, 3, 2, 4};
inkrementiere(A);
for (int i = 0; i < A.length; i++)
System.out.println("A" + i + " = " + A[i]);
}
public static void inkrementiere(int[] a) {
for (int i = 0; i < A.length; i++) a[i]++;
}
}
34
Ausgabe:
A0 = 2
A1 = 4
A2 = 3
A3 = 5
Methoden mit Referenzdatentypen
Inkrementieren der Zahlen in einem Feld.
public class FeldZaehler {
public static void main(String[] args) {
int[] A = {1, 3, 2, 4};
inkrementiere(A);
for (int i = 0; i < A.length; i++)
System.out.println("A" + i + " = " + A[i]);
}
public static void inkrementiere(int[] A) {
for (int i = 0; i < A.length; i++) A[i]++;
}
}
35
Bei Feldern wird Referenz übergeben.
Methoden mit Referenzdatentypen
Sortieren der Zahlen in einem Feld.
public class Sortierverfahren {
public static void main(String[] args) {
int[] A = {1, 3, 2, 4};
sort(A);
for (int i = 0; i < A.length; i++)
System.out.println("A" + i + " = " + A[i]);
}
public static void sort(int[] A) {
//TODO: Sortierverfahren Deines Vertrauens
}
}
36
Übersicht
• Berechnung der Potenz für zwei ganze Zahlen
• Klausuraufgabe SS 2010 !
• Berechnung der Cosinus-Funktion
• Klausuraufgabe WS 2010/2011 !
• Standard- und Referenzdatentypen
• Sortieren mit InsertionSort und MergeSort
• Anwendung: Zählen von falsch geordneten Paaren
• Anpassung der Algorithmen
37
Sortieren mit InsertionSort
public static void insertionSort(int[] A) {
for(int j = 1; j < A.length; j++) {
int key = A[j];
int i = j - 1;
while (i >= 0 && A[i] > key) {
A[i + 1] = A[i];
i--;
InsertionSort(array of int 𝐴)
}
for 𝑗 = 2 to 𝐴.𝑙𝑙𝑙𝑙𝑙𝑙 do
A[i + 1] = key;
}
𝑘𝑘𝑘 = 𝐴 𝑗
}
𝑖 =𝑗 −1
while 𝑖 > 0 and 𝐴 𝑖 > 𝑘𝑘𝑘 do
𝐴 𝑖+1 =𝐴 𝑖
𝑖 = 𝑖−1
38
𝐴 𝑖 + 1 = 𝑘𝑘𝑘
Wohlstände und Fehlstände
Sei 𝐴 = 𝑎1 , 𝑎2 , … , 𝑎𝑛 eine Folge natürlicher Zahlen.
Wir nennen ein Indexpaar 𝑖, 𝑗 mit 0 < 𝑖 < 𝑗 ≤ 𝑛
• genau dann einen Wohlstand von 𝐴, wenn 𝑎𝑖 < 𝑎𝑗 .
• genau dann einen Fehlstand von 𝐴, wenn 𝑎𝑖 > 𝑎𝑗 .
Beispiel:
4,7,1,4,5,6
Wohlstand: 1,2
39
Wohlstände und Fehlstände
Sei 𝐴 = 𝑎1 , 𝑎2 , … , 𝑎𝑛 eine Folge natürlicher Zahlen.
Wir nennen ein Indexpaar 𝑖, 𝑗 mit 0 < 𝑖 < 𝑗 ≤ 𝑛
• genau dann einen Wohlstand von 𝐴, wenn 𝑎𝑖 < 𝑎𝑗 .
• genau dann einen Fehlstand von 𝐴, wenn 𝑎𝑖 > 𝑎𝑗 .
Beispiel:
4,7,1,4,5,6
Fehlstand: 1,3
40
Wohlstände und Fehlstände
Sei 𝐴 = 𝑎1 , 𝑎2 , … , 𝑎𝑛 eine Folge natürlicher Zahlen.
Wir nennen ein Indexpaar 𝑖, 𝑗 mit 0 < 𝑖 < 𝑗 ≤ 𝑛
• genau dann einen Wohlstand von 𝐴, wenn 𝑎𝑖 < 𝑎𝑗 .
• genau dann einen Fehlstand von 𝐴, wenn 𝑎𝑖 > 𝑎𝑗 .
Die Folge 𝑛, 𝑛 − 1, … , 1 hat die meisten
Fehlstände aller Folgen mit 𝑛 Zahlen,
𝑛 𝑛−1
nämlich:
2
41
Wohlstände und Fehlstände
Sei 𝐴 = 𝑎1 , 𝑎2 , … , 𝑎𝑛 eine Folge natürlicher Zahlen.
Wir nennen ein Indexpaar 𝑖, 𝑗 mit 0 < 𝑖 < 𝑗 ≤ 𝑛
• genau dann einen Wohlstand von 𝐴, wenn 𝑎𝑖 < 𝑎𝑗 .
• genau dann einen Fehlstand von 𝐴, wenn 𝑎𝑖 > 𝑎𝑗 .
Anzahl Fehlstände + Anzahl Wohlstände =
(bei verschiedenen
𝑛 𝑛−1
Elementen in 𝐴)
2
42
Wohlstände und Fehlstände
Sei 𝐴 = 𝑎1 , 𝑎2 , … , 𝑎𝑛 eine Folge natürlicher Zahlen.
Wir nennen ein Indexpaar 𝑖, 𝑗 mit 0 < 𝑖 < 𝑗 ≤ 𝑛
• genau dann einen Wohlstand von 𝐴, wenn 𝑎𝑖 < 𝑎𝑗 .
• genau dann einen Fehlstand von 𝐴, wenn 𝑎𝑖 > 𝑎𝑗 .
Jeder Algorithmus zur Ausgabe aller Fehlstände in
𝑨 braucht also im schlechtesten Fall alleine für die
Ausgabe
𝑛 𝑛−1
Operationen.
2
43
Wohlstände und Fehlstände
Sei 𝐴 = 𝑎1 , 𝑎2 , … , 𝑎𝑛 eine Folge natürlicher Zahlen.
Wir nennen ein Indexpaar 𝑖, 𝑗 mit 0 < 𝑖 < 𝑗 ≤ 𝑛
• genau dann einen Wohlstand von 𝐴, wenn 𝑎𝑖 < 𝑎𝑗 .
• genau dann einen Fehlstand von 𝐴, wenn 𝑎𝑖 > 𝑎𝑗 .
Idee: Fehlstände zählen, nicht ausgeben
44
Fehlstände zählen mit InsertionSort
public static void insertionSort(int[] A) {
for(int j = 1; j < A.length; j++) {
int key = A[j];
int i = j - 1;
while (i >= 0 && A[i] > key) {
A[i + 1] = A[i];
i--;
}
A[i + 1] = key;
}
}
45
Fehlstände zählen mit InsertionSort
//sortiert a und gibt anzahl fehlstaende zurueck
public static int insertionSort(int[] A) {
int fehlstaende = 0;
for(int j = 1; j < A.length; j++) {
int key = A[j];
int i = j - 1;
while (i >= 0 && A[i] > key) {
A[i + 1] = A[i];
i--;
fehlstaende++;
}
A[i + 1] = key;
}
return fehlstaende;
}
46
Fehlstände zählen mit InsertionSort
//sortiert a und gibt anzahl fehlstaende zurueck
public static int insertionSort(int[] A) {
int fehlstaende = 0;
for(int j = 1; j < A.length; j++) {
int key = A[j];
int i = j - 1;
In Java
while (i >= 0 && A[i] > key) {
A[i + 1] = A[i];
i--;
fehlstaende++;
}
A[i + 1] = key;
}
return fehlstaende;
}
j = 4
1 2 5 7 3 6
Sortierter Bereich
47
Fehlstände zählen mit InsertionSort
//sortiert a und gibt anzahl fehlstaende zurueck
public static int insertionSort(int[] A) {
int fehlstaende = 0;
for(int j = 1; j < A.length; j++) {
int key = A[j];
int i = j - 1;
Im Pseudocode!
while (i >= 0 && A[i] > key) {
A[i + 1] = A[i];
i--;
fehlstaende++;
}
A[i + 1] = key;
}
return fehlstaende;
}
𝑗 = 5
1 2 5 7 3 6
Sortierter Bereich
48
Fehlstände zählen mit InsertionSort
//sortiert a und gibt anzahl fehlstaende zurueck
public static int insertionSort(int[] A) {
int fehlstaende = 0;
for(int j = 1; j < A.length; j++) {
int key = A[j];
int i = j - 1;
while (i >= 0 && A[i] > key) {
Behebt alle
A[i + 1] = A[i];
Fehlstände
i--;
fehlstaende++;
𝑖, 5
}
A[i + 1] = key;
}
return fehlstaende;
}
1 2 5 7 3 6
Sortierter Bereich
49
Fehlstände zählen mit InsertionSort
//sortiert a und gibt anzahl fehlstaende zurueck
public static int insertionSort(int[] A) {
int fehlstaende = 0;
for(int j = 1; j < A.length; j++) {
int key = A[j];
int i = j - 1;
while (i >= 0 && A[i] > key) {
Behebt alle
A[i + 1] = A[i];
Fehlstände
i--;
fehlstaende++;
𝑖, 5
}
A[i + 1] = key;
}
return fehlstaende;
}
1 2 3 5 7 6
Sortierter Bereich
50
Fehlstände zählen mit InsertionSort
//sortiert a und gibt anzahl fehlstaende zurueck
public static int insertionSort(int[] A) {
int fehlstaende = 0;
Jeder
for(int j = 1; j < A.length; j++) {
Schleifenint key = A[j];
int i = j - 1;
durchlauf
while (i >= 0 && A[i] > key) {
behebt
A[i + 1] = A[i];
i--;
einen
fehlstaende++;
Fehlstand
}
A[i + 1] = key;
}
return fehlstaende;
}
1 2 3 5 7 6
Sortierter Bereich
51
Fehlstände zählen mit InsertionSort
Anzahl Fehlstände
≤ Anzahl Vergleiche bei InsertionSort
≤ Anzahl Fehlstände + 𝑛 − 1
52
Fehlstände zählen mit MergeSort
MergeSort(array of int 𝐴, int ℓ = 1, int 𝑟 = 𝐴.𝑙𝑙𝑙𝑙𝑙𝑙)
if ℓ < 𝑟 then
𝑚 = ℓ + 𝑟 ⁄2
MergeSort(𝐴, ℓ, 𝑚)
MergeSort(𝐴, 𝑚 + 1, 𝑟)
Merge (𝐴, ℓ, 𝑚, 𝑟)
public static void mergeSort(int[] A, int l, int r) {
if (l < r) {
int m = (l + r) / 2;
mergeSort(A, l, m);
mergeSort(A, m + 1, r);
merge(A, l, m, r);
}
53
}
Fehlstände zählen mit MergeSort
MergeSort(array of int 𝐴, int ℓ = 1, int 𝑟 = 𝐴.𝑙𝑙𝑙𝑙𝑙𝑙)
public static void mergeSort(int[] A) {
mergeSort(A, 0, A.length - 1);
}
public static void mergeSort(int[] A, int l, int r) {
if (l < r) {
int m = (l + r) / 2;
mergeSort(A, l, m);
mergeSort(A, m + 1, r);
merge(A, l, m, r);
}
54
}
Fehlstände zählen mit MergeSort
MergeSort(array of int 𝐴, int ℓ = 1, int 𝑟 = 𝐴.𝑙𝑙𝑙𝑙𝑙𝑙)
public static void mergeSort(int[] A) {
mergeSort(A, 0, A.length - 1);
}
2x gleicher Methodenname erlaubt? Ja, solange Signatur verschieden!
public static void mergeSort(int[] A, int l, int r) {
if (l < r) {
int m = (l + r) / 2;
mergeSort(A, l, m);
mergeSort(A, m + 1, r);
merge(A, l, m, r);
}
55
}
Fehlstände zählen mit MergeSort
Merge(array of int 𝐴, int ℓ, int 𝑚, int 𝑟)
𝑛1 = 𝑚 − ℓ + 1
𝑛2 = 𝑟 − 𝑚
let 𝐿 1 … 𝑛1 + 1 and 𝑅[1 … 𝑛2 + 1] be new arrays of int
𝐿 1 … 𝑛1 = 𝐴[ℓ … 𝑚]
𝑅 1 … 𝑛2 = 𝐴[𝑚 + 1 … 𝑟]
𝐿 𝑛1 + 1 = 𝑅 𝑛2 + 1 = ∞
𝑖=𝑗=1
for 𝑘 = ℓ to 𝑟 do
if 𝐿 𝑖 ≤ 𝑅 𝑗 then
𝐴𝑘 =𝐿 𝑖
𝑖=𝑖 + 1
else
𝐴[𝑘] = 𝑅[𝑗]
𝑗 =𝑗+1
1 4 7 2 3 6
𝑚
𝑟
ℓ
56
Fehlstände zählen mit MergeSort
Merge(array of int 𝐴, int ℓ, int 𝑚, int 𝑟)
𝑛1 = 𝑚 − ℓ + 1
𝑛2 = 𝑟 − 𝑚
let 𝐿 1 … 𝑛1 + 1 and 𝑅[1 … 𝑛2 + 1] be new arrays of int
𝐿 1 … 𝑛1 = 𝐴[ℓ … 𝑚]
𝑅 1 … 𝑛2 = 𝐴[𝑚 + 1 … 𝑟]
𝐿 𝑛1 + 1 = 𝑅 𝑛2 + 1 = ∞
𝑖=𝑗=1
for 𝑘 = ℓ to 𝑟 do
if 𝐿 𝑖 ≤ 𝑅 𝑗 then
𝐴𝑘 =𝐿 𝑖
𝑖=𝑖 + 1
else
𝐴[𝑘] = 𝑅[𝑗]
𝑗 =𝑗+1
1 4 7 2 3 6
𝑚
𝑟
ℓ
1 4 7∞ 2 3 6∞
𝑖
𝐿
𝑗
𝑅
57
Fehlstände zählen mit MergeSort
Merge(array of int 𝐴, int ℓ, int 𝑚, int 𝑟)
𝑛1 = 𝑚 − ℓ + 1
𝑛2 = 𝑟 − 𝑚
let 𝐿 1 … 𝑛1 + 1 and 𝑅[1 … 𝑛2 + 1] be new arrays of int
𝐿 1 … 𝑛1 = 𝐴[ℓ … 𝑚]
𝑅 1 … 𝑛2 = 𝐴[𝑚 + 1 … 𝑟]
𝐿 𝑛1 + 1 = 𝑅 𝑛2 + 1 = ∞
𝑖=𝑗=1
for 𝑘 = ℓ to 𝑟 do
if 𝐿 𝑖 ≤ 𝑅 𝑗 then
𝐴𝑘 =𝐿 𝑖
𝑖=𝑖 + 1
else
𝐴[𝑘] = 𝑅[𝑗]
𝑗 =𝑗+1
1 4 7∞
𝑖
2 3 6∞
𝑗
58
Fehlstände zählen mit MergeSort
Merge(array of int 𝐴, int ℓ, int 𝑚, int 𝑟)
𝑛1 = 𝑚 − ℓ + 1
𝑛2 = 𝑟 − 𝑚
let 𝐿 1 … 𝑛1 + 1 and 𝑅[1 … 𝑛2 + 1] be new arrays of int
𝐿 1 … 𝑛1 = 𝐴[ℓ … 𝑚]
𝑅 1 … 𝑛2 = 𝐴[𝑚 + 1 … 𝑟]
𝐿 𝑛1 + 1 = 𝑅 𝑛2 + 1 = ∞
𝑖=𝑗=1
for 𝑘 = ℓ to 𝑟 do
if 𝐿 𝑖 ≤ 𝑅 𝑗 then
𝐴𝑘 =𝐿 𝑖
𝑖=𝑖 + 1
else
𝐴[𝑘] = 𝑅[𝑗]
𝑗 =𝑗+1
1
1 4 7∞
𝑖
2 3 6∞
𝑗
59
Fehlstände zählen mit MergeSort
Merge(array of int 𝐴, int ℓ, int 𝑚, int 𝑟)
𝑛1 = 𝑚 − ℓ + 1
𝑛2 = 𝑟 − 𝑚
let 𝐿 1 … 𝑛1 + 1 and 𝑅[1 … 𝑛2 + 1] be new arrays of int
𝐿 1 … 𝑛1 = 𝐴[ℓ … 𝑚]
𝑅 1 … 𝑛2 = 𝐴[𝑚 + 1 … 𝑟]
𝐿 𝑛1 + 1 = 𝑅 𝑛2 + 1 = ∞
𝑖=𝑗=1
for 𝑘 = ℓ to 𝑟 do
if 𝐿 𝑖 ≤ 𝑅 𝑗 then
𝐴𝑘 =𝐿 𝑖
𝑖=𝑖 + 1
else
𝐴[𝑘] = 𝑅[𝑗]
𝑗 =𝑗+1
1 2
1 4 7∞
𝑖
2 3 6∞
𝑗
60
Fehlstände zählen mit MergeSort
Merge(array of int 𝐴, int ℓ, int 𝑚, int 𝑟)
𝑛1 = 𝑚 − ℓ + 1
𝑛2 = 𝑟 − 𝑚
let 𝐿 1 … 𝑛1 + 1 and 𝑅[1 … 𝑛2 + 1] be new arrays of int
𝐿 1 … 𝑛1 = 𝐴[ℓ … 𝑚]
𝑅 1 … 𝑛2 = 𝐴[𝑚 + 1 … 𝑟]
𝐿 𝑛1 + 1 = 𝑅 𝑛2 + 1 = ∞
𝑖=𝑗=1
for 𝑘 = ℓ to 𝑟 do
if 𝐿 𝑖 ≤ 𝑅 𝑗 then
𝐴𝑘 =𝐿 𝑖
𝑖=𝑖 + 1
else
𝐴[𝑘] = 𝑅[𝑗] Wird von Feld 𝑅 gewählt, so werden
𝑗 =𝑗+1
𝑛 – 𝑖 + 1 Fehlstände beseitigt. 61
1 2
1 4 7∞
1
𝑖
2 3 6∞
𝑗
Fehlstände zählen mit MergeSort
𝑓=0
for 𝑘 = ℓ to 𝑟 do
if 𝐿 𝑖 ≤ 𝑅 𝑗 then
𝐴𝑘 =𝐿 𝑖
𝑖=𝑖 + 1
else
𝐴[𝑘] = 𝑅[𝑗]
𝑓 = 𝑓 + 𝑛1 − 𝑖 + 1
𝑗 =𝑗+1
return 𝑓
Fehlstände
lassen sich mit
MergeSort zählen!
Wird von Feld 𝑅 gewählt, so werden
𝑛1– 𝑖 + 1 Fehlstände beseitigt.
62
Fehlstände zählen mit MergeSort
public static int mergeSort(int[] A, int l, int r) {
int fehlstaende = 0;
if (l < r) {
int m = (l + r) / 2;
fehlstaende += mergeSort(A, l, m);
fehlstaende += mergeSort(A, m + 1, r);
fehlstaende += merge(A, l, m, r);
}
return fehlstaende;
}
63
Schluss
Bei Rekursionen
• denkt an den Basisfall/Rekursionsabbruch!
• vermeidet Mehrfachaufrufe mit gleichem Argument
• leitet die Rekursionsgleichungen her!
Aufgabe Wohlstände/Fehlstände
• passt bekannte Algorithmen an
• Ausgabe aller Fehlstände
≠ Ausgabe Anzahl Fehlstände
64