Einführung in die Informatik I Kapitel 6: Reihungen, Sortieren und ...

Einführung in die Informatik I
Prof. Bernd Brügge, Ph.D.
Technis/che Universität München
Wintersemester 2003/2004
Kapitel 6:
Reihungen, Sortieren und Suchen
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 1
2

Überblick über diesen Vorlesungsblock
v Themen:
– Reihungen (arrays): ein- und mehrdimensionale Reihungen
– Werte und Referenzsemantik
– Parameterübergaben (Wert und Referenzübergaben)
– Sortieren von Reihungen
– Suchen in Reihungen
v Ziele:
– Sie sind in der Lage, Probleme zu lösen, die eine Menge von Daten
erfordern.
– Sie verstehen den Unterschied zwischen einfachen Variablen und
Referenzvariablen.
– Sie können aktiv mit Reihungen umgehen, insbesondere in der
Implementation von Algorithmen.
– Sie sind in der Lage, Probleme zu lösen, die Daten mit mehreren
Dimensionen erfordern.
– Sie beherrschen erste Sortierverfahren: bubble sort, selection sort,
insertion sort
– Sie können in Reihungen effizient suchen.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 2

Reihungen
v Eine Reihung (array) ist eine Menge von Variablen, die Werte
desselben Typs speichern.
v Eine einzelne Variable wird nicht durch ihren Namen benannt,
sondern durch ihre Position innerhalb der Reihung.
v Beispiel: Ausgabe der Studentennamen, die in einem Verzeichnis
gespeichert sind:
Ohne Reihung
System.out.println(student1);
System.out.println(student2);
System.out.println(student3);
System.out.println(student4);
System.out.println(student5);
System.out.println(student6);
System.out.println(student7);
Mit Reihung
for (int k = 1; k

1-dimensionale Reihungen
v Eine Variable in einer Reihung wird durch ihre Position innerhalb der
Reihung bezeichnet, nicht durch einen eigenen Bezeichner.
– In einer Reihung von n Variablen mit dem Bezeichner arr werden die
Variablen so benannt: arr[0],arr[1],arr[2],…,arr[n-1].
v Die folgende Reihung umfasst 8 Variablen vom Typ int.
Die Indizierung
von Reihungen
beginnt in Java
immer bei 0
arr:
Index
0 1 2 3 4 5 6 7
-2 8 -1 16 16 45 21 -3
Reihungsname
Syntax einer Reihungsdeklaration:
typbezeichner[] arrayname;
wobei
- arrayname der Name der Reihung ist, und
- typbezeichner der Typ der Reihungsvariablen.
Elementwert
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 4

Terminologie
v Eine leere Reihung enthält keine Variablen.
v Die Variablen in einer Reihung heißen auch Reihungselemente oder
kurz Elemente.
v Jedes Element in einer Reihung hat denselben Typ, auch Elementtyp
genannt.
v Die Länge einer Reihung ist die Anzahl ihrer Elemente.
v Jedes Reihungsobjekt hat ein Attribut length, das die Länge der
Reihung angibt.
– arr.length ist im Beispiel der vorigen Folie gleich 8.
v Reihungselemente können beliebige Typen sein, einschließlich
Reihungen und Klassen.
– In Java: Eine 2-dimensionale Reihung ist eine Reihung von
Reihungen von Elementen eines Typs
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 5

Zugriff auf Elemente in einer Reihung
arr:
Gegeben seien die Deklarationen: int j = 5, k = 2;
Gültige Elementzugriffe sind:
arr[1] // Bezeichnet den Wert 8
arr[0] // Bezeichnet den Wert -2
arr[j + k] // Ergibt arr[5+2], d.h. arr[7], also -3
arr[j % k] // Ergibt arr[5%2], d.h. arr[1], also 8
Ungültige Elementzugriffe:
-2 8 -1 16 16 45 21 -3
arr[5.0] // 5.0 ist eine Gleitkommazahl (double),
// kann also nicht Index sein.
arr['5'] // '5' ist vom Typ char, nicht von Typ int
arr[-1] // Negative Indizes sind nicht möglich.
arr[8] // Das letzte Element von arr hat Index 7
arr[j*k] // j*k ist gleich 10, als außerhalb des
// Indexbereiches
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 6

Deklaration und Instantiierung einer Reihung
v Um eine 1-dimensionale Reihung zu deklarieren, müssen wir den
Namen der Reihung und auch den Typ der Elemente angeben.
v Um eine Reihung zu instantiieren, müssen wir den new-Operator
benutzen, der den Elementtyp und die Länge der Reihung benötigt.
int[] arr;
// Deklaration einer Reihung
arr = new int[15]; // Instantiierung einer Reihung von 15
// Elementen
Wir können beide Aktivitäten in einem Schritt vereinen:
int[] arr = new int[15];
Der Name der
Reihung ist arr.
Die Reihung enthält 15
Variablen vom Typ int.
Die 15 Variablen: arr[0], arr[1], .., arr[14]
Indexwerte von 0 bis arr.length-1 zulässig.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 7

Was genau passiert bei Deklaration und
Instantiierung einer Reihung?
Deklaration einer Reihungsvariable:
int[] arr;
Nach der Deklaration ist der Wert
der Reihungsvariable null.
arr: null
Die new-Operation instantiiert eine
Reihung, deren Inhalte mit dem
Default-Wert 0 vorbesetzt sind.
new int[8]
0 0 0 0 0 0 0 0
Die Zuweisung ersetzt den null-Wert durch einen Verweis auf das
Reihungsobjekt.
arr = new int[8];
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 8

Initialisierung von Reihungen
v Bei der Deklaration werden Reihungen und Reihungselemente in
Java mit Voreinstellungswerten (default values) initialisiert:
– Reihungsvariablen werden auf den Wert null initialisiert.
– Reihungselemente mit Typen int, boolean, … werden auf 0,
false, ... initialisiert.
v Reihungselemente kann man bereits bei der Deklaration der
Reihung mit initialen Werten versehen:
int[] arr = {-2,8,-1,-3,16,20,25,16,16,8,18,19,45,21,-2};
Regel: Wenn eine Reihung bereits bei der Deklaration initialisiert wird,
dann brauchen wir den new-Operator nicht mehr, um die Reihung zu
kreieren (die Instantiierung der Reihung hat bereits bei der Deklaration
stattgefunden!).
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 9

Zuweisung und Benutzung von Reihungswerten
Indizierte Reihungsariablen benutzen wir genauso wie andere
Variablen:
arr[0] = 5;
arr[5] = 10;
arr[2] = 3;
Ein Programmstück, das die ersten 15 Quadratzahlen (1, 4, 9, 16, …)
der Reihung arr zuweist:
int[] array = new int[15];
for (int k = 0; k < arr.length; k++)
arr[k] = (k+1) * (k+1);
Eine Schleife zum Drucken der Werte von arr:
for (int k = 0; k < arr.length; k++)
System.out.println(arr[k]);
Wichtig: length
ist ein Attribut von
arr, keine Methode.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 10

Beispiel: Ausdruck von Werten
Drucke eine Reihung für Elemente vom Typ int und eine Reihung
für Elemente vom Typ double:
public class PrintArrays {
public static void main(String[] args) {
int intArr[] = new int[10]; // Kreiere die Reihung intArr
double realArr[] = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8,
9.9, 10.10 }; // und eine vorinitialisierte
// Reihung von Gleitkommawerten
System.out.println("Int \t Double");
Int Double
for (int k = 0; k < intArr.length; k++)
0 1.1
System.out.println( intArr[k] + " \t " + realArr[k]);
0 2.2
0 3.3
0 4.4
0 5.5
0 6.6
0 7.7
0 8.8
0 9.9
0 10.1
} // main()
} // PrintArrays
Die Reihung intArr ist nicht initialisiert,
alle Elemente haben also
Voreinstellungswerte 0.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 11

Beispiel: Speichere und drucke 100 Quadratzahlen
public class Squares {
public static void main(String args[]) {
final int ARRSIZE = 100;
// Größe der Reihung ist eine Konstante
int intArr[] = new int[ARRSIZE]; // Deklariere und kreiiere die
// Reihung
for (int k = 0; k < intArr.length; k++) // Initialisierung der Reihung
intArr[k] = (k+1) * (k+1);
System.out.print("Die ersten 100 Quadratzahlen:"); // Kopf der Tabelle
for (int k = 0; k < intArr.length; k++) {
// Drucke die Reihung
if (k % 10 == 0)
// 10 Elemente pro Reihe
System.out.println(" ");
System.out.print( intArr[k] + " ");
} // for
} // main()
} // Squares
Die ersten 100 Quadratzahlen:
1 4 9 16 25 36 49 64 81 100
121 144 169 196 225 256 289 324 361 400
441 484 529 576 625 676 729 784 841 900
961 1024 1089 1156 1225 1296 1369 1444 1521 1600
1681 1764 1849 1936 2025 2116 2209 2304 2401 2500
2601 2704 2809 2916 3025 3136 3249 3364 3481 3600
3721 3844 3969 4096 4225 4356 4489 4624 4761 4900
5041 5184 5329 5476 5625 5776 5929 6084 6241 6400
6561 6724 6889 7056 7225 7396 7569 7744 7921 8100
8281 8464 8649 8836 9025 9216 9409 9604 9801 10000
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 12

Zuweisung von Reihungen
Wir kennen schon die Situation nach folgender Deklaration und
Instantiierung: int[] a = new int[8];
a:
0 0 0 0 0 0 0 0
Was passiert nun, wenn wir eine zweite Reihungsvariable
deklarieren und ihr den Wert von a zuweisen? int[] b = a;
Das Reihungsobjekt wird in Java nicht etwa kopiert,
a:
b:
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
sondern es entsteht ein zweiter Verweis auf dasselbe Objekt!
a:
0 0 0 0 0 0 0 0
b: Änderungen an b wirken sich ab sofort auch auf a aus!
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 13

Reihungen sind Objekte
v In Java werden Reihungen (arrays) wie Objekte behandelt:
– Sie werden mit dem new Operator instantiiert.
– Sie haben Attribute (instance variables), z.B. length.
– Allerdings: Es gibt keine "Klasse" Array in Java.
v In Java gibt es 2 Arten von Variablen:
– Einfache Variable:
u Variable vom Typ int, float, double, boolean
– Referenzvariable:
u Variable vom Typ array oder einer benutzerdefinierten Klasse
(z.B. Student) oder einer vordefinierten Klasse (z.B. String).
v Die Semantik bei Zuweisungen an diese Variablen ist verschieden:
– Wertesemantik für einfache Variable
– Referenzsemantik für Referenzvariablen
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 14

Wertesemantik von Variablen
v Eine Variable ist definiert als ein Tupel (Name, Wert).
– Der Name ist genauer gesagt eine Zugriffsfunktion,
mit der wir den "Platz" der Variablen berechnen, und
dann den Wert lesen oder ihn schreiben.
Name
a :
Wert
5
int a, b; a = 5; b = 8;
Zugriffsfunktion
v Wir nennen diese Auffassung die Wertsemantik von
Variablen:
– Wir bezeichnen Variablen mit Wertsemantik auch als
Wertobjekte und ihre Typen als Werttypen.
– Beispiele von Wertobjekten: Variable vom Typ boolean, int,
char, float, double.
v Bei Wertobjekten kann man direkt auf die Werte über den
Namen zugreifen.
b :
8
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 15

Referenzsemantik von Variablen
Verweisvariable
v Eine Variable mit Referenzsemantik ist immer noch ein
Tupel (Name, Wert). Allerdings
– Der Wert ist jetzt eine Referenz (Verweis,
"Addresse", "Pointer") auf eine Variable die
als Wert ein Objekt hat (z.B. die Instanz
einer Klasse oder eine Reihung).
u Diese Variable wird auch Verweisvariable
genannt.
Name
stud1
:
Student
x45454423
Student stud1, stud2;
stud1 = new Student()
Zugriffsfunktionen
studiert
denkt
schlaeft
studiere()
denke()
schlafe()
true
false
false
stud2
:
null
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 16

Variable mit Referenzsemantik:
Das Ganze noch einmal
Verweisvariable
Name
student stud1, stud2;
stud1 = new Student();
Zugriffsfunktionen
stud1
:
x45454423 null
Der Wert der Verweisvariablen
ist eine Referenz
auf ein Objekt vom Typ
Student
Student
studiert
denkt
schlaeft
true
false
false
Verweisvariable
studiere()
denke()
schlafe()
Name
stud2
:
null
Die Verweisvariable
hat noch den Wert null
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 17

Folie 43 aus Kapitel 5:
Zuweisung von Referenzen auf Objekte
v Eine Variable kann nicht nur Werte wie false oder 100 speichern,
sondern auch einen Verweis (“Referenz”, “Addresse”) auf ein Objekt.
Student stud1, stud2; // Deklaration von 2 Variablen
stud1 = new Student(); // Erzeugt Objekt vom Typ Student
Nach der Instantiierung
verweist stud1 auf ein
Objekt vom Typ Student.
stud1
Die andere Variable stud2 kann irgendwann
mal auf ein Student-Objekt verweisen, aber
ihre Referenz ist zur Zeit nicht definiert (null).
stud2
Student
studiert
denkt
schlaeft
studiere()
denke()
schlafe()
true
false
false
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 18

Referenzsemantik in Java
v Für Reihungsvariable und für alle Objekte von
benutzerdefinierten Klassen gilt die Referenzsemantik.
v Bei der Parameterübergabe von Referenzvariablen wird die
Referenz zur Reihung oder zum Objekt übergeben (call by
reference), nicht eine Kopie (call by value) der ganzen Elemente.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 19

Parameterübergabe bei Methodenaufrufen:
Wertesemantik
Call by Value: Beim Methodenaufruf übergeben wir der Wert des
aktuellen Parameters (z.B. einer Variablen) aus dem aufrufenden
Programm an den formalen Parameter der Methode: Hierbei wird der
Parameter durch eine Kopie des Variablenwertes ersetzt. Zuweisungen an
die Kopie haben keinen Effekt auf die Variable:
n bekommt den
Wert von Num
public void add1(int n) {
System.out.println("n = " + n);
n = n + 1;
System.out.println("n = " + n);
}
Alle Zuweisungen an den Parameter n innerhalb der Methode add1() sind
lokal, und existieren nicht ausserhalb des Methodenaufrufes.
int Num = 5;
System.out.println("Num = " + Num);
add1(Num);
System.out.println("Num = " + Num);
ergibt
Num = 5
n = 5
n = 6
Num = 5
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 20

Parameterübergabe bei Methodenaufrufen: (18.11.2003)
Referenzsemantik
Call by Reference: In diesem Fall wird nicht der Wert, sondern die
Referenz ("Addresse") des aktuellen Parameters (z.B. einer Objektes
oder einer Reihung) einer Methode übergeben. Zuweisungen an das
Objekt existieren auch ausserhalb des Methodenaufrufs.
int[] intArr = { 21, 20, 27, 24, 19 }; // Initialisierung
Sort sorter = new Sort();
sorter.print(intArr);
// Drucke
sorter.bubbleSort(intArr);
// Sortiere
sorter.print(intArr);
// Drucke noch mal
ergibt
21 20 27 24 19
19 20 21 24 27
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 21

Zusammenfassung: Referenzvariablen in Java
v In Java sind Variablen in der Regel Referenzvariablen!
– Ausnahme: Variablen einfacher Typen wie int, double,
boolean
v Bei der Zuweisung werden nicht die referenzierten Objekte kopiert
sondern lediglich die Verweise auf diese Objekte.
– Es entstehen mehrfache Verweise auf dasselbe Objekt.
– Änderungen über den einen Verweis (über die eine Variable)
beeinflussen also Objekte, die auch über den anderen Verweis (über
die andere Variable) erreicht werden.
– Es entsteht also das sogenannnte Aliasnamen-Problem.
v Auch bei der Parameterübergabe (call by value) werden nur Verweise
kopiert, nicht jedoch die referenzierten Objekte.
v In Programmiersprachen wie Pascal dagegen werden bei der Zuweisung
von Reihungsvariablen auch die Inhalte kopiert.
– Das Referenzkonzept muss dort explizit angefordert werden.
– Z.B. bei der Parameterübergabe in Pascal mittels var.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 22

Mehrdimensionale Reihungen
v Mehrdimensionale Reihungen sind in Java Reihungen, deren Elemente
Reihungen sind, deren Elemente wiederum Reihungen sind, usw.
v Beispiel: 2-dimensionale
Matrix aus 3 Zeilen und
4 Spalten ganzer Zahlen:
1 2 3 4
2 4 6 8
3 6 9 12
v Die Matrix wird in Java folgendermaßen
deklariert, instantiiert und besetzt:
int[][] matrix = new int[3][4];
for (int row = 0; row < 3; row++)
for (int col = 0; col < 4; col++)
matrix[row][col] = (row+1) * (col+1);
v Die entstehenden Reihungsobjekte lassen sich so veranschaulichen:
matrix:
3 6 9 12
2 4 6 8
1 2 3 4
Das Element
matrix[2][2]
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 23

mehrdimensionale Reihungen (cont‘d)
v Dasselbe Ergebnis bekommt man, wenn man die 3 Zeilen einzeln
instantiiert:
int[][] matrix;
= new int[3][];
for (int row = 0; row < 3; row++){
matrix[row] = new int[4];
} for (int col = 0; col < 4; col++)
matrix[row][col] = (row+1) * (col+1);
}
matrix:
3 6 9 12
2 4 6 8
1 2 3 4
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 24

Dreiecksmatrizen
v Wenn die Zeilen 2-dimensionaler Reihungen einzeln instantiiert werden
können, müssen sie auch nicht gleiche Länge haben.
v Damit lassen sich z.B. Dreiecksmatrizen darstellen:
int[][] dreieck = new int[3][];
dreieck[0] = new int[1];
dreieck[1] = new int[2];
dreieck[2] = new int[3];
dreieck:
0 0 0
0
0 0
0 0
0 0 0
0
Das Element
dreieck[2][0]
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 25

2-dimensionale Reihungen
Motivation: Berechne die durchschnittliche monatliche
Regenmenge in München.
Mit einer 1-dimensionalen Reihung wäre das möglich, aber sehr
kompliziert:
double[] rainfall = new double[365];
Eine 2-dimensionale Reihung ist eine Reihung von Reihungen (an
array of arrays) ist besser geeignet.
Die erste Reihung sind die 12 Monate, indiziert von 0 bis 11.
Jeder Monat ist wieder eine Reihung von 31 Tagen, indiziert von 0
bis 30.
double[][] rainfall = new double[12][31];
Monatsindex
Tagesindex
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 26

Eine 2-D-Repräsentation
Der Regenfall am 3. Januar ist mit dieser Repräsentation
rainfall[0][2] (schlechte Lesbarkeit durch Null-Indizierung).
Wir können die Lesbarkeit erhöhen, indem wir eine extra Reihe und
Spalte erlauben und die 0-Indizes ignorieren:
Wir ignorieren
diese Spalte
double[][] rainfall = new double[13][32];
.
.
.
0,0 0,1 0,2 0,3 ... 0,29 0,30 0,31
1,0 1,1 1,2 1,3 ... 1,29 1,30 1,31 Januar
2,0 2,1 2,2 2,3 ... 2,29 2,30 2,31 Februar
11,0 11,1 11,2 11,3 ... 11,29 11,30 11,31 November
12,0 12,1 12,2 12,3 ... 12,29 12,30 12,31 Dezember
Wir ignorieren diese Reihe
Regenfall am 3. Januar
ist jetzt rainfall[1][3]
rainfall[1][5] = 1.15; // Regen für 5. Januar
rainfall[13][32] = 0.15 ; // Reihe und Spalte gibt es nicht!
rainfall[11][32] = 1.3; // 32. Spalte gibt es nicht!
rainfall[13][30] = 0.74; // 13. Reihe gibt es nicht!
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 27

Initialisierung einer 2-dimensionalen Reihung in
einer Methode
Wir benutzen 2 geschachtelte Schleifen, um die Reihung zu
initialisieren:
/**
* Initialisiert eine 2-D Reihung
* Vorbedingung: rain ist nicht null
* Nachbedingung: rain[x][y] == 0.0 für alle x,y in der Reihung
*/
public void initRain(double[][] rain) {
for (int month = 1; month < rain.length; month++)
for (int day = 1; day < rain[month].length; day++)
rain[month][day] = 0.0;
} // initRain()
Methodenaufruf: Übergibt den Namen der Reihung an die
Methode:
Die 2-D Reihung als
formaler Parameter
Zwei geschachtelte
Zählschleifen, die
12 x 31 iterieren
double[][] rainfall = new double[13][32];
initRain(rainfall); // Beispiel eines Methodenaufrufs
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 28

Berechnung des durchschnittlichen täglichen Regens
public double avgDailyRain(double[][] rain) {
double total = 0.0;
for (int month = 1; month < rain.length; month++)
for (int day = 1; day < rain[month].length; day++)
total += rain[month][day];
return total/365;
}
System.out.println("Täglicher Regen: " + avgDailyRain(rainfall));
Methodenaufruf innerhalb einer
Druckanweisung.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 29

Berechnung des durchschnittlichen monatlichen Regens
public double avgRainForMonth(double[][] rain, int month, int nDays)
{
double total = 0.0;
for (int day = 1; day

Reihungen und Reihungswerte als Parametertypen
Der Typ des aktuellen Parameters bei einem Methodenaufruf muss
denselben Typ wie der formale Parameter in der Methodendefinition haben.
Dies gilt für alle Parameter einschließlich Reihungen:
double
double[]
double[][]
rainfall[1][14]: Regenfall vom 14. Januar
rainfall[3]: 1-D-Reihung mit März-Daten
rainfall: Die gesamte 2-D-Reihung
0
1
2
.
.
.
10
11
12
13
0 1 2 ... 31
…...
1.14
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 31
J
F
M
A
M
J
…...
O
N
D

Multidimensionale Reihungen
Eine 3-dimensionale Reihung kann man für die Messung von
Regenfällen über mehrere Jahre benutzen.
0
1
2
.
.
.
11
12
13
0 1 2 ... year 0
31
0
1
2
.
.
.
11
12
13
0 1 2 ... year 1
J 31
F
0 1 2 ... year 2
J 31
0
M
F
1
A
M
2
M
A
.
J
M
.
J
J
.
A
J
S
A
O
S
N
O
D
N
11
D
12
13
J
F
M
A
M
J
J
A
S
O
N
D
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 32

Eine 3-D-Reihung
v Deklaration der Reihung:
final int NYEARS = 10;
final int NMONTHS = 13;
final int NDAYS = 32;
double[][][] rainfall = new double[NYEARS][NMONTHS][NDAYS];
Initialisierung mit 3 geschachtelten Schleifen:
for (int year = 1; year < rainfall.length; year++) {
for (int month = 1; month < rainfall[year].length; month++) {
for (int day = 1; day < rainfall[year][month].length; day++) {
rainfall[year][month][day] = 0.0;
}
}
}
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 33

Initialisierung von Reihungen
v Bei kleinen Reihungen, kann man einen Initialisierungsausdruck
(initializer expression) für die Zuweisung von Anfangswerten
verwenden:
2 x 3 Reihung
von int-Werten
Initialisierungsausdruck
int[][] a = { {1, 2, 3}, {4, 5, 6} };
2 x 2 Reihung char [][] c = { {'a', 'b'}, {'c', 'd'} };
von char-Werten.
double [][][] d ={ { {1.0, 2.0}, {3.0, 4.0} },
{ {5.0, 6.0}, {7.0, 8.0} },
{ {9.0, 10.0}, {11.0, 12.0}}
};
3 x 2 x 2 Reihung
von double-Werten.
In Java kann jede Teilreihung einer mehr-dimensionalen Reihung
eine unterschiedliche Länge haben (siehe Dreiecksmatrix Beispiel )!
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 34

Dynamische Reihungen: java.util.Vector
v Reguläre Reihungen sind auf die zum Zeitpunkt der Initialisierung
(statisch) vereinbarte Größe beschränkt.
Sie können später nicht mehr wachsen oder kleiner werden.
v Die java.util.Vector Klasse implementiert eine Reihung von Objekten
(keine Grundtypwerte als Elemente!), die auch nach der Initialisierung
(dynamisch) wachsen kann.
public class Vector {
public Vector(int size);
public Vector();
// Konstruktor: Array mit Anfangsgröße
// Konstruktor: Array ohne Anfangsgröße
}
public void addElement(Object obj);
public Object elementAt(int index);
// Füge obj zum Array dazu
// Hole das bei index
// gespeicherte Element
public void insertElementAt(Object obj, int index); // Speicher obj bei
// index
public int indexOf(Object obj); // Ermittle index von obj
public void removeElementAt(int index); // Entferne Element bei index
public int size(); // Länge des dynamischen Arrays
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 35

Sortierte Reihungen
v Reihungen dienen dazu, große Datenmengen zu verwalten.
v Große Datenmengen lassen sich jedoch nicht effizient verwalten,
wenn sie nicht sortiert vorliegen
– Beispiel: Suche nach einem Wort in einem Roman vs. Suche
nach einem Wort in einem Lexikon
v Voraussetzung, dass man Daten sortieren kann, ist, dass auf dem
Datentyp eine Ordnung definiert ist.
v Programm für den Rest dieses Vorlesungsblocks:
– Formale Definition von Relationen und unterschiedlichen
Ordnungen (nach Goos)
– Erste Algorithmen, um Reihungen zu sortieren
– Ein schneller Algorithmus, um in sortierten Reihungen Elemente
zu finden
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 36

Definition Relation
v Gegeben seien zwei Mengen M und N.
– Die Menge aller Paare (a, b) mit a aus M und b aus N heißt
kartesisches Produkt von M und N.
– in Zeichen: M ¥ N = def { (a, b) | a Œ M Ÿ b Œ N }
v Eine (zweistellige) Relation R zwischen den Mengen M und N ist eine
Teilmenge des kartesischen Produkts:
– R Õ M ¥ N
РStatt (a,b) ΠR schreiben wir oft a R b (Infix-Schreibweise) und
sprechen „a steht in Relation R zu b“.
v Falls M und N dieselbe Menge sind, d.h. falls gilt R Õ M ¥ M, dann
nennen wir R auch eine (zweistellige) Relation über M.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 37

Eigenschaften von Relationen über M
Eine zweistellige Relation R über M (d.h. R Õ M ¥ M)
v heißt reflexiv, wenn für alle a Œ M gilt: a R a
– Beispiele: =, £ und Õ sind reflexiv, < und à sind es nicht.
v heißt irreflexiv, wenn für kein a Œ M gilt: a R a
– Beispiele: < und à sind irreflexiv, =, £ und Õ sind es nicht.
v heißt symmetrisch, wenn aus a R b folgt b R a
– Beispiele: = ist symmetrisch,

Äquivalenzrelation und Ordnungen
Eine zweistellige Relation R über M (d.h. R Õ M ¥ M)
v heißt Äquivalenzrelation, wenn sie reflexiv, symmetrisch und transitiv
ist;
– Beispiele: = ist Äquivalenzrelation,

Sortieralgorithmus
Algorithmus:
1. Wandere über alle Elemente der Reihung, und zwar N-1 mal ("Phasen")
2. Vergleiche die Nachbarelemente in der Reihung (Vergleich: N-1 Paare)
3. Falls das kleiner indizierte Element größer ist als das größer indizierte Element
4. Vertausche die beiden Elemente
21 20 27 24 19 // Die unsortierte Reihung
[20 21] 27 24 19 // Anfang Phase 1: Vergleiche Nachbarelemente
20 [21 27] 24 19 // Vertausche,falls notwendig,geh weiter
20 21 [24 27] 19 // Vertausche,falls notwendig,geh weiter
20 21 24 [19 27]
20 21 24 19 |27 // Ende Phase 1: 27 ist jetzt an der Spitze
[20 21] 24 19 27 // Anfang Phase 2
…
20 19 21 |24 27 // Ende Phase 2: 24 hat jetzt seinen Platz
….
|19 20 21 24 27 // End Phase 4: Das ganze Feld ist sortiert
Seifenblasen-Algorithmus (Bubblesort algorithm):
Bei jeder Runde (auch Phase genannt) durch die Reihung lassen wir das
größte noch nicht sortierte Element ans Ende "blubbern".
Für ein Feld mit N Elementen werden N-1 Phasen benötigt.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 40

Die Idee hinter dem Bubblesort
Swap: 0
Comp: 0
Swap: 0
Comp:1
Swap:1
Comp:2
Swaps:25 Swaps:8 Swaps:9
Comp: 45
Comp:10 9
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 42

Wie vertauschen wir 2 Elemente in einer Reihung?
Beispiel: Nehmen wir an, wir haben die Reihung arr mit der
Belegung: 1 4 2 8
Wir wollen jetzt 4 and 2 vertauschen. Sei pair der Index in der
Reihung, wir setzen also pair = 2; Los geht's:
arr[pair-1] = arr[pair];
arr[pair] = arr[pair-1];
Wir bekommen: 1 2 2 8
So einfach geht es also nicht.
Der Trick: Eine temporäre Variable muss deklariert werden, wenn man
die Werte von zwei Variablen vertauschen will:
int temp = arr[pair-1];
Wir erwarten: 1 2 4 8
// Speichere den ersten Wert in temp
arr[pair-1] = arr[pair]; // Überschreibe den ersten Wert mit
// dem zweiten Wert
arr[pair] = temp; // Überschreibe den zweiten Wert mit
// temp (das den ersten Wert
Ergebnis: 1 2 4 8
// zwischengespeichert hat)!
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 43

Java-Implementation von Bubblesort mit Tausch
int[] arr = { 1, 4, 2, 8};
// Eine vorinitialisierte Reihung von Werten
for (int pass = 1; pass < arr.length; pass++) {
// Für jede Runde
for (int pair = 1; pair arr[pair]) { // Vergleiche die Werte
// und vertausche, falls
// notwendig
int temp = arr[pair-1]; // Speichere den ersten Wert in temp
arr[pair-1] = arr[pair]; // Überschreibe den ersten Wert mit
// dem zweiten Wert
arr[pair] = temp; // Überschreibe den zweiten Wert mit
// temp (das den ersten Wert
// zwischengespeichert hat)!
} // Ende if
} // Ende for pair
} // Ende for pass
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 44

Implementation von bubbleSort() als Dienst
Parameter vom Typ Array sind Referenzvariablen, d.h. die
Parameterübergabe erfolgt per Call-by-Reference: Änderungen, die an
Reihungsvariablen in der Methode gemacht werden, sind außerhalb der
Methode sichtbar.
Der formale Parameter ist als Reihung
(int[] arr) spezifiziert
/**
* Ziel: Sortiere die Werte von arr in aufsteigender Reihenfolge
* Vorbedingung: arr ist nicht null.
* Nachbedingung: Die Werte arr[0]...arr[arr.length-1] sind in
* aufsteigender Reihenfolge sortiert.
*/
public void bubbleSort(int[] arr) {
for (int pass = 1; pass < arr.length; pass++)
Beim Methodenaufruf wird nur der Name
des aktuellen Parameters benötikz
// Für jede Runde
for (int pair = 1; pair < arr.length; pair++) // Für jedes Paar
if (arr[pair-1] > arr[pair]) { // Vergleiche die Werte
int temp = arr[pair-1]; // und vertausche, falls
arr[pair-1] = arr[pair]; // notwendig
arr[pair] = temp;
Aufrufendes Programm:
} // if
int[] myArr = {21, 20, 27, 24, 19};
} // bubbleSort()
bubbleSort(myArr);
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 45

Aufruf des "Dienstes" Bubblesort
public class Sort {
public void print(int[] arr) {
for (int k = 0; k < arr.length; k++) // Für jedes Element
System.out.print( arr[k] + " \t "); // Drucke es
System.out.println();
} // print()
public static void main(String[] args) {
int[] myArr = { 21, 20, 27, 24, 19 };
Sort sorter = new Sort();
sorter.print(myArr);
sorter.bubbleSort(myArr);
sorter.print(myArr);
} // main()
} // Sort public void bubbleSort(int[] arr) {
for (int pass = 1; pass < arr.length; pass++)
for (int pair = 1; pair < arr.length;
pair++)
if (arr[pair-1] > arr[pair]) {
int temp = arr[pair-1];
arr[pair-1] = arr[pair];
arr[pair] = temp;
} // if
} // bubbleSort()
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 46

Bubblesort kann in 4 Zeilen geschrieben werden
private void swap(int one, int two, int[] arr) {
int temp = arr[one]; // Zwischenspeicher für arr[one]
arr[one] = arr[two];
arr[two] = temp;
}
// In Swap übergebe ich die Array-Indizes,
// nicht die Array-Elementwerte
public void bubbleSort(int[] arr) {
for (int pass = 1; pass < arr.length; pass++) // Für jede Runde
for (int pair = 1; pair < arr.length; pair++)// Für jedes Paar
if (arr[pair-1] > arr[pair] // Vergleiche die Werte
swap(pair-1, pair, arr); // Swap, falls notwendig
}
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 47

Komplexität von Algorithmen
v Bubblesort lässt sich schnell implementieren, arbeitet aber sehr langsam,
vor allem, wenn die Anzahl der Elemente größer wird.
v Es gibt schnellere Sortieralgorithmen als Bubblesort.
– Selectionsort, Insertionsort, Quicksort, Mergesort
v Wenn wir verschiedene Algorithmen haben, ist es nützlich, diese
Algorithmen bezüglich ihrer Kosten zu vergleichen.
v Arten von Kosten:
– Programmieraufwand (sehr gering bei Bubblesort)
– Ausbildungsaufwand für Programmierer
– Anschaffungskosten für Rechner und Software
– Rechenzeit, Speicherplatzbedarf
v Beim Vergleichen von Algorithmen konzentrieren wir uns auf
Rechenzeit und Speicherplatzbedarf und vernachlässigen Faktoren, die
von der Leistungsfähigkeit des Rechners oder der Programmiersprache
abhängen.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 48

2 Arten von Komplexität, 3 Fallunterscheidungen
v Zeitkomplexität: Wieviele Schritte muss ein Algorithmus durchführen,
um N Eingabedaten zu verarbeiten?
v Platzkomplexität: Wieviel Speicherplatz braucht ein Algorithmus, um
N Eingabedaten zu verarbeiten?
v Im folgenden beschränken wir uns auf die Zeitkomplexität.
v Wir müssen trotzdem folgende Fälle unterscheiden:
– Anzahl der Schritte im schlechtesten Fall (worst case)
– Beispiel: Die Reihung ist völlig unsortiert
– Anzahl der Schritte im besten Fall (best case)
– Beispiel: Die Reihung ist bereits sortiert
– Anzahl der Schritte im durchschnittlichen Fall (average case)
– Beispiel: Die Reihung ist zur Hälfte sortiert.
v Wenn wir von nun an den Begriff Komplexität allein verwenden,
meinen wir gewöhnlich Zeitkomplexität im schlechtesten Fall.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 49

Einflussfaktoren für Zeitkomplexität
v Wir nehmen an, dass nur Zuweisungen, Vergleiche,
Inkrementierungen und Multiplikationen Zeit kosten.
v Wir nehmen an, dass die Deklaration von Variablen und Allokation
von Speicherplatz keine Zeit kostet.
v Wir bestimmen deshalb in Abhängigkeit von der Eingabe n nur
– Z(n): Die Anzahl der Zuweisungen
– V(n): Die Anzahl der Vergleiche
– M(n): Die Anzahl der Multiplikationen
– I(n): Die Anzahl der Inkrementierungen
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 51

Komplexitätsüberlegungen für den Bubblesort:
v Wir haben keine Multiplikationen.
v Die Anzahl der Inkrementierungen der Schleifenvariablen und
Vergleiche zur Schleifenterminierung vernachlässigen wir hier.
v Die Komplexität von Bubblesort wird dann durch 2 Arten von
Operationen bestimmt:
– V(n) = Anzahl der Vergleiche zwischen Elementen
– T(n) = Anzahl der Tauschoperationen (swap) von Elementen
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 52

Komplexitätsüberlegungen für Bubblesort
v Anzahl der Vergleichsoperationen V:
– Bei n =10 sind in der ersten Runde 9 Vergleiche, in der zweiten
Runde 8 Vergleiche, usw., bis zu 1 Vergleich in der letzten Runde:
9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 = 45
– Allgemein V(n) = (n-1) + (n-2) + …. 1 = n*(n-1)/2
– Bei großem n ist n*(n-1)/2 ungefähr n 2 /2, also
u V(n) ~ n 2 /2
v Anzahl der Tauschoperationen:
– Ein Tausch findet nur statt, wenn das erste Element größer als das
zweite Element ist. Ein Tausch T besteht aus 3 Zuweisungen Z
– Wenn die Datenverteilung zufällig ist, dann können wir annehmen,
dass ein Tausch ungefähr in der Hälfte aller Fälle notwendig ist.
u T(n) ~ n 2 /4
u Z(n) ~ 3 * n 2 /4
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 53

Komplexität des Bubblesorts 11/20/03
v Anzahl aller Operationen in Bubblesort ~ n 2 /2 + 3*n 2 /4
– Die Anzahl der Vergleichsoperationen und Zuweisungen ist also
proportional zu n 2.
v Bei asymptotischen Komplexitätsberechnungen können wir die
Konstanten weglassen.
v Bubblesort hat somit die Komplexität O( n 2 ).
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 54

Allgemeine Beobachtungen zur Komplexität
v Geschachtelte Schleifen haben oft Laufzeitkomplexität O( n 2 ):
– Die äußere Schleife exekutiert n mal, die innere für jeden Zyklus
der äußeren Schleife n mal (oder vielleicht n dividiert durch eine
Konstante).
Das ergibt dann ungefähr n*n Operationen, oder O( n 2 ).
v Weitere einfache Sortieralgorithmen mit O( n 2 )-Komplexität:
– Selectionsort
– Insertionsort
v O( n 2 ) ist für das Sortieren eine schlechte Komplexität, wenn die
Anzahl der Elemente sehr groß ist. In diesem Fall brauchen wir
Algorithmen, die eine bessere Laufzeitkomplexität haben.
v Schnellere Sortieralgorithmen mit O(n*log n)
u Mergesort
u Quicksort
Heute
nach Kapitel funktionale Programmierung
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 55

Komplexität: Theorie und Praxis
v Die Ordnung von f, geschrieben O(f(n)) ist eine Abschätzung für
das Wachstum von Funktionen (z.b. für die Laufzeit eines
Algorithmus)
– d.h. die Komplexitätsüberlegungen gelten für den Fall n Æ µ
v Das Laufzeitverhalten von zwei Algorithmen, auch wenn sie die
dieselbe Laufzeitkomplexität haben, kann sehr wohl grosse
Unterschiede bei praktischen Werten für die Anzahl der
Eingabewerte zeigen.
v Beispiel:
– Verschiedene Implementationen für die Matrixmultiplikation
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 56

Beispiel: Matrixmultiplikation
v Grundidee des Algorithmus: Reihen mit Spalten multiplizieren
v allgemein:
/* ijk */
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
sum = 0.0;
for (k = 0; k < n; k++)
sum += a[i][k]*b[k][j];
c[i][j] = sum;
}
}
v Komplexität für Matrizenmultiplikation ist O(n 3 )
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 57

Zwei Algorithmen für die Matrixmultiplikation
/* ijk */
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
sum = 0.0;
for (k = 0; k < n; k++)
sum += A[i][k]*B[k][j];
C[i][j] = sum;
}
}
/* kij */
for (k = 0; k < n; k++)
for (i = 0; i < n; i++) {
sum = 0.0;
for (j = 0; j < n; j++)
sum += A[i][k]*B[k][j];
C[i][j] = sum;
}
}
Ergeben die beiden Algorithmen dasselbe Resultat?
Ja!
Haben beide Algorithmen dieselbe Laufzeitkomplexität?
Ja!
Wie sieht es mit der aktuellen Laufzeit aus?
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 58

Laufzeit der Implementation (Reihenfolge i-j-k)
Zeit
/* ijk */
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
sum = 0.0;
for (k = 0; k < n; k++)
sum += A[i][k]*B[k][j];
C[i][j] = sum;
}
}
Grösse der
Matrix
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 59

Alternative Implementation (Reihenfolge k-i-j)
/* kij */
for (k = 0; k < n; k++)
for (i = 0; i < n; i++) {
sum = 0.0;
for (j = 0; j < n; j++)
sum += A[i][k]*B[k][j];
C[i][j] += sum;
}
}
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 60

Laufzeitverhalten von verschiedenen Implementationen
jki
kji
ijk
jik
Warum sind die
kij und ikj
Implementationen
so schnell?
kij
ikj
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 61

Interpretation der Ergebnisse
v Trotz der gleichen Anzahl von Operationen in jedem Algorithmus
sehen wir sehr unterschiedliche Laufzeiten
– kij ist bis zu 3 mal schneller als kji bei gleicher Matrixgröße
v Für Multiplikationen von kleinen Matrizen ist der Effekt nicht zu
beobachten, sehr wohl aber bei großen Matrizen
– Bei n = 400 braucht kij nur 2.5 sek, kji braucht 8 sek
v Grund für die unterschiedlichen Laufzeiten:
– Größe des Prozessorcaches und des Speicherbedarfs der
inneren Schleife
v Lektion: Auch beim Programmieren mit höherer
Programmiersprachen muss man die Rechnerarchitektur kennen.
=> Technische Informatik, TGI Praktikum
=> Mehr darüber auch im Kapitel über maschinennahe
Programmierung (Info II)
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 64

Ein anderer Sortieralgorithmus:
Sortieren nach Auswahl (Selectionsort)
v Grundprinzip:
– Partitioniere die Reihung in zwei Teilreihungen F und S.
Solange es Elemente in der Reihung F gibt, finde in F das kleinste
Element, und überführe es ans Ende der Reihung S.
v Algorithmus für Selectionsort (in Pseudocode):
1. Initialisierung: Setze S auf null
2. Trivialfall: Wenn F == null, dann ist S das Ergebnis
3. Reduktion:
Finde das Minimum in F:
a = select(F)
Hänge a an das Ende von S: appendElem(S, a)
Entferne a aus F: deleteElem(F, a)
4. Iteration: Gehe nach 2
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 65

Grundidee des Algorithmus
S
F
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 66

Selectionsort
Animation
public void selectionSort() {
int outer, inner, min;
for(outer = 0; outer < nElems-1; outer++){ // Äussere Schleife
min = outer;
// Bestimme Index des Minimums
for(inner = outer+1; inner < nElems; inner++){ // Innnere Schleife
if(a[inner] < a[min]) // Wenn a[min] größer ist,
min = inner;
// dann haben wir ein neues Min
}
swap(outer, min, a); // Vertausche die Elemente
} // end for(outer)
} // end selectionSort()
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 67

Komplexität von Selectionsort
v Selectionsort führt dieselbe Anzahl von Vergleichen aus wie
Bubblesort.
v Für großes n dominieren die Vergleichsoperationen, so dass auch
Selectionsort die Komplexität O(n 2 ) hat.
v Selectionsort führt im allgemeinen wesentlich weniger
Tauschoperationen aus (eine pro Durchlauf der äußeren Schleife).
v Beispiel:
– Für 100 Datenelemente werden 4950 Vergleiche benötigt, aber
nur 100 Tauschoperationen.
v Deshalb ist Selectionsort im allgemeinen schneller als Bubblesort.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 68

Noch ein Sortieralgorithmus: Insertionsort
v Insertionsort beruht auf der Idee, dass ein Teil der Reihung bereits
partiell sortiert ist.
v Wir entnehmen uns ein Element aus der noch nicht sortierten
Reihung und nennen es das „markierte Element“.
v Wir sortieren dann das markierte Element an der Stelle im partiell
sortierten Teil ein, wo es von der Größe her hingehört.
– Um das zu ermöglichen, müssen wir Platz für das markierte
Element machen.
– Wir tun dies, in dem wir einige bereits sortierte Elemente nach
rechts schieben, und zwar die, die größer als das markierte
Element sind.
– Um Platz für diese Verschiebung zu haben, nehmen wir das
markierte Element temporär aus der Reihung (in eine temporäre
Variable).
v Wir terminieren den Sortiervorgang, wenn der nicht sortierte Teil der
Reihung leer ist.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 69

Die Idee hinter
Insertionsort
Animation
Partiell sortiert
M
Partiell sortiert
"leer"
temp
Partiell sortiert
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 70

Implementation von Insertionsort
public void insertionSort(double[] a) {
int in, out;
}
for (out = 1; out < nElems; out++) { // out ist index des
// markierten Elements
double temp = a[out]; // "entferne" markiertes Element
in = out;
// start das Verschieben:
while(in > 0 && a[in-1] > temp) { // Solange Elemente
// größer,
a[in] = a[in-1]; // schiebe Elemente nach rechts
in = in-1; // gehe eine Position nach links
}
a[in] = temp; // Setze das markierte Element ein
}
Durchschnittliche Laufzeitkomplexität
von Insertionsort
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 71

Wiederholung: Einflussfaktoren für
Zeitkomplexität
v Wir bestimmen in Abhängigkeit von der Eingabe n
– Z(n): Die Anzahl der Zuweisungen
– V(n): Die Anzahl der Vergleiche
– M(n): Die Anzahl der Multiplikationen
– I(n): Die Anzahl der Inkrementierungen
v Wir unterscheiden folgende Fälle :
– Anzahl der Schritte im schlechtesten Fall (worst case)
– Beispiel: Die Reihung ist völlig unsortiert
– Anzahl der Schritte im besten Fall (best case)
– Beispiel: Die Reihung ist bereits sortiert
– Anzahl der Schritte im durchschnittlichen Fall (average case)
– Beispiel: Die Reihung ist zur Hälfte sortiert.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 72

Komplexität von Insertionsort (durchschnittlicher Fall)
v In der ersten Runde wird nur ein Element verglichen, in der
zweiten Runde höchstens zwei Elemente.
v In der letzten Runde haben wir maximal n-1 Vergleiche:
– V(n) = 1+2+3….+n-1= n*(n-1)/2
v Im durchschnittlichen Fall werden höchstens die Hälfte der
Elemente in jeder Runde vertauscht, also n*(n-1)/4
v Für jeden Tausch brauchen wir 3 Operationen:
– Z(n) ~ 3 * n 2 /4
v Anzahl der Operationen in Insertionsort also ~ n 2 /4 + 3*n 2 /4
v Insertionsort hat somit auch die Komplexität O( n 2 ).
v Bei kleinem n ist Insertionsort zweimal schneller als Bubblesort
(da weniger Kopien) und leicht schneller als Selectionsort.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 73

Vorteil von Insertionsort bei sortierten Reihungen
v Wenn die Daten sortiert sind, wird die Eintrittsbedingung in die
While-Schleife (while(in > 0 && a[in-1] > temp))
fast nie wahr.
v In diesem Fall wird in der äußeren Schleife nur eine Anweisung
exekutiert.
v Bei sortierten Reihungen ist die Komplexität von Insertionsort
somit nur O(n).
v Falls die Daten sortiert sind, läuft Insertionsort also in O(n).
Merken: Insertionsort ist eine gute Sortiermethode, wenn die zu
sortierende Reihung bereits weitgehend vorsortiert ist.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 74

Sequentieller Suchalgorithmus für Reihungen
Problem: Suche in einer nichtsortierten Reihung a nach einem
bestimmten Wert key.
Idee des Algorithmus: Da die Reihung a nicht sortiert ist, müssen
wir eine sogenannte sequentielle Suche durchführen.
public int sequentialSearch(int[] a, int key) {
for (int k = 0; k < a.length; k++)
if (a[k] == key)
return k;
return -1; // Nicht gefunden
} // sequentialSearch()
Die Suche war nicht
erfolgreich.
Sobald der Wert gefunden ist,
können wir zum Aufrufer
zurückkehren.
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 76

Komplexität von sequentieller Suche
v Die Suche nach einem Element in einer ungeordneten Reihung mit
n Elementen ist
– im schlechtesten Fall: V(n) = n
– im durchschnittlichen Fall: V(n) = n/2
– im besten Fall: V(n) = 1
v Komplexität für sequentielle Suche: O(n)
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 77

Implementation von binärer Suche
Algorithmus: low und high zeigen auf das erste und letzte Element
der Teilreihung (subarray), und mid zeigt immer auf den derzeitigen
Mittelpunkt in der Reihung oder Teilreihung.
/**
* Vorbedingung: a ist aufsteigend sortierte Reihung von int
* Nachbedingung: Ergebnis ist -1 oder k, wobei a[k] == key
*/
Wenn low > high, dann ist
public int binarySearch(int[] a, int key) { der Schlüssel nicht in der
int low = 0; // Initialisierung
Reihung.
int high = a.length - 1;
while (low high: Suche erfolglos
low bzw. high anpassen, um die
Reihung in 2 Hälften zu schneiden
Code
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 79

Noch ein Beispiel
Wir suchen nach Zahl 8
Erste Iteration:
key = 8;
low = 0; high = 9;
mid = 4;
a[4] == 5
Zweite Iteration:
key = 8;
low = 5; high = 9;
mid = 7;
a[7] == 8
1 2 3 4
public int binarySearch(int[] a, int key) {
int low = 0;
int high = a.length - 1;
while (low

Komplexität von binärer Suche
v Lineare Suche läuft auf
beliebigen Reihungen
v Binäre Suche braucht eine
sortierte Reihung
v Bei einer Reihung von bis
zu n Elementen brauchen
wir höchstens log 2 (n)
Vergleiche
v Die Komplexität von
binärer Suche für sortierte
Reihungen ist also
O(log 2 (n)).
max. Anzahl von
Elementen n
in der Reihung
1
2
4
8
16
32
64
128
256
512
513
1024
2
log 2
(n)
max. Anzahl
von Teilungen
log 2
(n)
2 0
0
2 1
1
2 2
2
2 3
3
2 4
4
2 5
5
2 6
6
2 7
7
2 8
8
2 9
9
2 10
10
2 10 10
Copyright 2003 Bernd Brügge, Christian Herzog Einführung in die Informatik I, TUM Wintersemester 2003/04 Kapitel 6, Folie 82