Sortieren

Sortieren
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
1
Sortiermethoden (Auswahl)
• Allgemeine Methoden: Sortieren in Arrays
• Spezielle Methoden: Sortieren von Dateien
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
2
Sortieren in Arrays
• Direkte Methoden (langsam, immer 2 verschachtelte Schleifen)
– Bubble-Sort (Exchange-Sort, Sortieren durch Austauschen)
– Selection-Sort (Sortieren durch Auswählen)
– Insertion-Sort (Sortieren durch Einfügen)
• Schnelle Methoden
–
–
–
–
Heap-Sort
Quick-Sort
Merge-Sort
ShellSort
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
3
Sortieren in Arrays
• Direkte Methoden (langsam, immer 2 verschachtelte Schleifen)
– Bubble-Sort (Exchange-Sort, Sortieren durch Austauschen)
– Selection-Sort (Sortieren durch Auswählen)
– Insertion-Sort (Sortieren durch Einfügen)
• Schnelle Methoden
–
–
–
–
Heap-Sort
Quick-Sort
Merge-Sort
ShellSort
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
4
Sortieren von Dateien
–
–
–
–
3-Band-Mischen
Einphasen-Mischen (ausgeglichenes Mischen)
Natürliches Mischen
Mehrphasen-Mischen
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
5
Bubble Sort
Innere Schleife:
• Die benachbarten Zahlen werden in ein „bubble“ eingeschlossen
und wenn nötig ausgetauscht
• Die „Blase“ verschiebt sich bis zum Array-Ende
• Nach 1 Durchlauf durch die äußere Schleife ist die größte (oder
kleinste) Zahl ermittelt
Äußere Schleife:
• Falls die größte (kleinste) Zahl bekannt, wird im „Rest-Array“ nach
weiterem Maximum (Minimum) gesucht
• In der äußeren Schleife werden die Margins für den aktuellen
Array-Teil festgelegt
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
6
Bubble Sort - Beispiel
0
1
2
3
4
18 02 37 17 15
02 17 15 18 37
02 18
02 17
15 17
18 37
17 37
15 37
02 15 17 18 37
02 15
02 18 17 15 37
02 18
17 18
02 15 17 18 37
15 18
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
7
Bubble Sort mit Merker - Beispiel
0
1
2
3
4
70 10 20 30 40
… Merker ausgetauscht löschen
10 70
… Tauschen war notwendig, Merker gesetzt
20 70
30 70
40 70
… weiter machen, nur wenn Merker gesetzt
10 20 30 40 70
… Merker ausgetauscht löschen
10 20
… kein Tauschen notwendig, Merker bleibt gelöscht
20 30
30 40
02 15 17 18 37
… kein Tauschen notwendig, Merker bleibt gelöscht
… kein Tauschen notwendig, Merker bleibt gelöscht
… Schluss machen!
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
8
Selection Sort
Wie „intuitives“ Sortieren von wenigen Zahlen:
Minimum finden, dann unter den restlichen Zahlen Minimum finden, usw.
Innere Schleife:
• Die 1. Zahl wird als Minimum bezeichnet
• Sollte die nächste Zahl noch kleiner sein, so wird der MimimumEintrag (Variable min) korrigiert
• min wird mit der linken Randzahl des aktuellen Array-Abschnitts
ausgetauscht
Äußere Schleife:
• Margins für den aktuellen Array-Abschnitt werden festgelegt
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
9
Selection Sort - Beispiel
0
1
2
3
4
min
imin
18 02 37 05 15 18 0
1
1
2
3
4
min
imin
02 05 37 18 15 37 2
2
1
18 3
2
1
15 4
2
1
2
1
tauschen
0
1
2
3
4
min
imin
02 05 15 18 37 18 3
tauschen
0
0
2
3
4
min
imin
18 3
02 18 37 05 15 18 1
kein Tauschen nötig
18 1
0
5
3
5
3
1
2
3
4
02 05 15 18 37
tauschen
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
10
Insertion Sort
Sortieren durch Einfügen - Konzept:
2 Zahlen werden sortiert, jede weitere Zahl wird zwischen die bereits
sortierten Zahlen „eingefügt“, bzw. am Anfang oder am Ende „einsortiert“
Algorithmische Umsetzung – Grundidee:
Äußere Schleife:
Von links werden jeweils 2 benachbarte Zahlen in eine „Blase“ eingeschlossen,
betrachtet und ggf. ausgetauscht
Innere Schleife:
• nach jedem in der äußeren Schleife erfolgten Tauschvorgang wird
die „Blase“ zurück nach links verschoben und es wird geprüft, ob die
Ordnung immer noch stimmt; anderseits werden auch diese Zahlen getauscht
• die Rückwärtsprüfung wird abgebrochen, sobald 1x nicht getauscht werden muss
• die innere Schleife kommt eventuell nicht einmal zur Ausführung
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
11
Insertion Sort (Grundidee) - Beispiel
0
1
2
3
4
18 02 37 05 15
02 05 18 37 15
15 37
tauschen
0
1
2
3
4
tauschen
tauschen
15 18
02 18 37 05 15
kein Tauschen notwendig,
aufhörten, weiter nach
links nicht mehr prüfen
kein Tauschen notwendig,
innere Schleife wird gar nicht ausgeführt
0
1
2
3
4
02 18 37 05 15
0
05 37
05 18
tauschen
1
2
3
02 05 15 18 37
tauschen
kein Tauschen notwendig
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
4
12
Insertion Sort - Verbesserung
Verbesserung der algorithmischen Umsetzung:
• es werden nicht die ganzen Tauschvorgänge gemacht,
Sondern nur die „halben“ – d.h. zunächst überschreibt der linke
Nachbar den rechten
• wenn keine Tauschvorgänge mehr nötig sind, erst dann nehmen
wir die Zahl die ursprünglich ganz rechts war (diese müssen wir und
natürlich vorher merken) und veranlassen, dass diese Zahl die Zahl
ganz links überschreibt.
• Eigentlich lassen wir dadurch alle am Tauschen beteiligte Zahlen
nach rechts rotieren.
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
13
0
1
2
3
4
nächster
0
kopieren
18 18 37 05 15
02
1
2
3
4
37
kein Tauschen notwendig,
innere Schleife wird gar nicht ausgeführt
1
2
3
4
3
4
nächster
02 18 37 05 15
nächster
15
02 05 18 37 15
kopieren
05
15
kopieren
nächster
02 18 37 05 15
0
2
02 05 18 37 37
Hilfsvariable zurück kopieren
0
1
02 05 18 18 15
15
Hilfsvariable
zurück kopieren
prüfen, kein
Tauschen notwendig,
weiter nach links nicht mehr prüfen
kopieren
02 18 37 37 15
05
kopieren
02 18 18 37 15
0
1
2
3
4
02 05 15 18 37
05
Hilfsvariable
zurück kopieren
prüfen, kein
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
Tauschen notw.
14
Insertion Sort
(verbessert) - Beispiel
02
18 02 37 05 15
Merge Sort - Vorstudie
2 vorsortierte Arrays in ein 3. Array mischen (mergen)
0
1
2
3
4
Array1 02 05 37 45 57
(Quelle1)
0
1
2
Array2 03 04 41
(Quelle2)
0
1
2
3
4
5
6
7
Array3
(Ziel)
• Die kleinere der beiden Zahlen, auf die die Zeiger zeigen, wird in das Zielfeld kopiert
• Dort, von wo die Zahl kopiert wurde, verschiebt sich der Zeiger nach rechts
0
1
2
3
4
Array1
02 05 37 45 57
(Quelle1)
0
1
2
0
Array3
(Ziel)
Array2
03 04 41
(Quelle2)
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
1
2
3
4
5
6
7
2
• Falls ein Array am Ende, Rest des
15
anderen Array kopieren
Merge Sort
Idee:
• Prinzip: Divide et impera
• Array mit unsortierten Zahlen solange teilen,
bis 1-Element-Arrays entstehen
• In den 1-Element-Arrays sind
die Zahlen bereits sortiert!!!
• Die Arrays werden in umgekehrter
Reihenfolge des Teilens wieder gemischt
Programmtechnische Umsetzung:
• Rekursiv!
• Teil-array teilen und sofort mischen
• Rekursiver Abschluß: 1-Element-Arrays
Beispiel:
0
1
2
3
4
03 96 71 40 25
03 96 71
03 96
03
71
40 25
40
96
03 96
03 71 96
25 40
03 25 40 71 96
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
16
25
Quick Sort #1
Die Idee:
• Prinzip: Divide et impera
• Im Array von unsortierten Zahlen wird ein sog. Pivot-Element bestimmt
(i.d.R. i.d. Mitte)
0
1
2
3
4
5
6
25 01 20 18 08 31 16
18 = Pivot
• Jetzt möchten wir den Zustand erzielen, dass alle Zahlen links vom Pivot kleiner
als Pivot sind und umgekehrt; die Zahlen untereinander werden noch nicht sortiert
• Dazu suchen wir von links die erste Zahl, die größer ist als Pivot
• und gleichzeitig von rechts die erste Zahl, die kleiner ist als Pivot
0
1
2
3
4
5
6
25 01 20 18 08 31 16
L
R
• Wir tauschen die 2 Zahlen L und R
• Nach jedem Tauschen wird L inkrementiert und L dekrementiert
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
17
Quick Sort #2
0
1
2
3
4
5
6
16 01 20 18 08 31 25
L
R
• Mit der Suche setzen wir fort, anfangend mit dem rechten Nachbar der links
gefundenen Zahl und mit dem linken Nachbar der rechts gefunden Zahl
• wir gehen aber nie weiter als bis zum Pivot
• sollte das Pivot-Element betroffen werden, dann wandert er mit
• Dies machen wir, solange sich die zu prüfenden Zahlen nicht begegnen
0
1
2
3
4
5
6
16 01 20 18 08 31 25
L
R
16 01 08 18 20 31 25
R
L
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
18 wird mit sich selbst
getauscht, danach R<L =>
keine weitere Suche
nach18Tauschkandidaten
Quick Sort #3
0
1
2
3
4
5
6
16 01 08 18 20 31 25
• Wenn alle Zahlen links vom Pivot kleiner als Pivot und
alle Zahlen rechts vom Pivot größer als Pivot sind, wird in entsprechenden Teilen
des Arrays Quick-Sort rekursiv ausgeführt:
0
1
2
16 01 08
4
5
6
14 25 16
Quick sort
erneut rekursiv
Quick sort
erneut rekursiv
Folgendes muss noch genau überlegt werden:
• Kondition für Ende des Suchens/Tauschens
• Abschlussbedingungen für die rekursiven Aufrufe
Analysieren Sie die Beispielprogramme dazu!
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
19
Die Details:
Quick Sort #4
• Abschlussbedingung bei der Suche nach Tauschkandidaten: L>R
• Bei der Grobsortierung des Arrays muss nicht unbedingt gelten, dass
- die Elemente links vom Pivot < als Pivot und
- die Elemente rechts vom Pivot > als Pivot sein müssen
• Günstiger: Wir teilen das Array in 2 Teile, wobei
alle Elemente im linken Teil < alle Elemente in rechten Teil
wobei es auf die Lage des Pivot-Elementes nicht ankommt.
Das Pivot-Element kann
- am Rande der neuen Aufteilung sein
- in der neuen Aufteilung enthalten sein, aber nicht am Rande
- gar nicht in der neuen Aufteilung enthalten sein
• Die Grenzwerte von rekursiven Aufruf linker Array-Teil:
linker Rand bis letzte Position der rechten Zeigers R
Die Grenzwerte von rekursiven Aufruf rechter Array-Teil:
letzte Position der linken Zeigers R bis rechter Rand
• Folglich: Abschlussbedingungen für die rekursiven Aufrufe
Rekursion linker Teil: nur wenn linker Rand < letzte Position der rechten Zeigers R
Rekursion
rechter
Teil: nur
wenn letzte- Sortieren
Position der linken Zeigers
R < rechter Rand
20
2009 Jiri Spale,
Algorithmen
und Datenstrukturen
Quick Sort #5
Fortsetzung unseres Beispiels:
2. Instanz – linker Teil
0
1
3. Instanz – rechter Teil des
in der 2. Instanz bearbeiteteten linker Teils
2
1
16 01 08
L
16 08
R
R
L
0
1
2
01 16 08
R
2
L
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
R
1
2
08 16
R
L
21
Quick Sort #6
Fortsetzung unseres Beispiels:
2. Instanz – rechter Teil
4
5
3. Instanz – linker Teil des
in der 2. Instanz bearbeiteteten rechten Teils
6
4
20 31 25
L
5
20 25
R
20 mit sich selbst tauschen
L
4
5
R
L
6
4
20 25 31
R
5
20 25
L
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
R
R
22
L
Quick Sort #7
Fortsetzung unseres Beispiels:
Ablaufdiagramm
main()
quick(0,6)
quick(0,2)
L
L
R
L
R
quick(1,2)
L
R
quick(4,5)
quick(4,6)
L
R
R
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
… rekursiver Abschluss
23
Quick Sort #8
Eigenschaften:
• i.d.R. sehr schnell (sehr kurze innere Schleifen)
• kann leider instabil sein
• verbraucht wenig Speicherplatz
• es gibt mehrere Varianten des Algorithmusses
Aufwand:
• average case:
O(N log N)
wenn ca. gleich viele Zahlen kleiner und größer
als das Pivot sind
• worst case:
O(N2)
wenn das Pivot das größte (kleinste) Element ist,
und das noch bei ca. allen Rekursionen
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
24
Shellsort
Sortieren durch Einfügen mit abnehmender Schrittweite:
Shell = Hülle, Oberfläche
• Shell sortiert Elemente, die in ausgewählter Entfernung auseinander liegen
• die Entfernungen (Abstände, Schrittweite) verringern sich mit dem Fortschritt des
Verfahrens
• gern genommene Abstandsfolgen:
{2 }
i ∞
i =0
= {1,2,4,8,...}
an +1 = 3an + 1; n > 0, a0 = 1....{1,4,13,40,121,...}
D.L.Shell (1959)
Knuth
• es wird mit dem größten Abstand begonnen, der in unseren Datenbestand noch hereinpaßt
• zum eigentlichen Sortieren der ausgewählten Elemente wird ein herkömmliches
Sortierverfahren eingesetzt
• gern genommenen Sortierverfahren: Insertion-Sort (sehr schnell bei vorsortierten Zahlen) ,
Bubble-Sort mit Merkern, schnelle Verfahren
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
25
Shellsort - Beispiel
1. alle Elemente, die 4 Positionen auseinander liegen, werden zusammengefasst und sortiert
2. alle Elemente, die 2 Positionen auseinander liegen, werden zusammengefasst und sortiert
3. alle Elemente werden zusammengefasst und sortiert
Ausgangsfolge:
44 55 12 42 94 18 06 67
4 sortiert
44 18 06 42 94 55 12 67
2 sortiert:
06 18 12 42 44 55 94 67
1 sortiert:
06 12 18 42 44 55 67 94
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
26
Shellsort:grafische Darstellung mit Spalten
1 Sortierung
Ausgangsfolge:
fertig
44 55 12 42 94 18 06 67
06
06
4 Sortierung
18
12
44 55 12 42
44 18 06 42
12
18
94 18 06 67
94 55 12 67
42
42
44
44
55
55
94
67
67
94
2 Sortierung
44 18
06 42
06 18
12 42
94 55
44 55
12 67
94 67
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
27
Dreiband-Mischen
Band 0
44 55 12 42
94 18 6 67
Zerlegen = Phase 1
Band 1
44 55 12 42
Band 2
94 18 6 67
Band 0
44 94 18 55
}
Mischen = Phase 2
}
ein Durchlauf
6 12 42 67
Zerlegen
Band 1
Band 2
Band 0
44 94 18 55
6 12 42 67
6 12 44 94
}
Mischen
18 42 55 67
usw
Band 0
6 12 18 42 44 55 67 94
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
Abb. 41 c
28
Einphasen-Mischen
(ausgeglichenes Mischen)
Band 1
44 55 12 42
Band 2
94 18 6 67
Band 3
44 94
Band 4
18 55 42 67
6 12
Band 1
18 44 55 94
Band 2
6 12 42 67
Band 3
6 12 18 42 44 55 67 94
Band 4
leer
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
Abb. 41 d
29
Natürliches Mischen#1
Definition: Lauf:
• innerhalb des Laufes gilt:
a k <= a k+1
• am linken Ende eines Laufes gilt: a i-1 > a i
• am rechten Ende eines Laufes gilt: a j > a j+1
a
j
a
i-1
a
k+1
a
k
a
i
a
j+1
Lauf
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
Abb. 41 e
30
Natürliches Mischen#2
Vorgehensweise:
1. Teilfolgen von Band 0 auf Band 1 und 2 verteilen
2. entsprechende Teilfolgen von Band 1 und Band 2 mischen und
auf Band 0 schreiben
3. dann mit 1 weiter, solange, bis auf Band 0 die sortierte Folge steht.
a
c
a
c
Lauf 1
c
c
Lauf 2
b
Verteilphase
a
Lauf n
b
b
Mischphase
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
Abb. 41f
c
31
Natürliches Mischen#3
Band0
17 31
5 59
13 41 43 67
11 23 29 47
3 7 71
verteilen
Band1
17 31
13 41 43 67
Band2
5 59
11 23 29 47
3 7 71
mischen
Band0
5 17 31 59
11 13 23 29 41 43 47 67
verteilen
Band1
5 17 31 59
Band2
11 13 23 29 41 43 47 67
3 7 71
3 7 71
mischen
Band0
5 11 13 17 23 29 31 41 43 47 59 67
3 7 71
verteilen / mischen …
Band0
3 5 7 11 13 17 23 29 31 41 43 47 59 67 71
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
32
Mehrphasen-Mischen (Sortieren)
Regeln:
• ist die Anzahl der benötigten Bänder gleich n
• es werden Laufe gemischt
• ist ein Band erschöpft, so wird es zum neuen Zielband
2
3
...
n
11
10
4
...
0
=Anzahl vorhandener Läufe je Band
7
6
0
...
4
=Anzahl vorhandener Läufe je Band
3
2
4
...
0
=Anzahl vorhandener Läufe je Band
1
0
2
...
2
=Anzahl vorhandener Läufe je Band
0
1
1
...
Band 1
1
=Anzahl vorhandener Läufe je Band
1
0
0
0 =Anzahl vorhandener Läufe je Band
33
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
Abb. 41h
Band
1
Anzahl Läufe
5
56
147
2
2
2
10 11
3
0
1
3
2
0
3
3 13
9
8 14
Leer (Zielband)
3 13
9
8 14
2
256
1 4 7 10 11
1
1
8 14
2
2
2 3 5 6 13
3
0
Leer (Zielband)
1
0
Leer (Zielband)
2
1
1 4 7 9 10 11
3
1
2 3 5 6 8 13 14
1
1
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Leer (Zielband)
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
1 4 7 9 10 11
34
Programm-Lauftzeit-Abschätzungen
Problem:
Mehrere Algorithmen zur Lösung einer Aufgabe verfügbar: was nehmen?
Unser Programm: wozu?
• Einmalig, Schnellschuß → einfachster Algorithmus
• Einsatz in der Produktion, jahrelang, mit vielen Daten
→ Untersuchung der Alternativen
Kriterien:
• Einfachheit, Verständlichkeit, gute Dokumentation
• benötigte Rechenzeit
• benötigter Hauptspeicherplatz
• benötigte Plattenzugriffe
• benötigte Datentransfer im Netzwerk
Möglichkeiten zur Bestimmung der Rechenzeit:
1.
2.
Benchmarks
Analyse
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
35
Benchmarks
Idee: Zeitkritische Programmteile isolieren
90-10-Regel:
90% Laufzeit werden in 10% Programmcodes verbraucht
Für die zeitkritischen Teile:
• besonders schnelle Sprachen oder Techniken einsetzen
• Laufzeitprofile ermitteln
Extremfall:
• Laufzeit des nicht-zeitkritischen Programmteils wird auf 0 gesetzt:
vorher: 100% Zeit, nachher 100 – 10 = 90%
• Laufzeit des zeitkritischen Programmteils wird halbiert:
vorher: 100% Zeit, nachher 100- 90/2 = 55%
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
36
Analyse
2 Schritte:
• Wahl einer Maßzahl. Bsp: n…Anzahl der zu sortierenden Zahlen
• Bestimmung der Zeitfunktion T = T(n,t)
Unterschiedliche Funktionen für unterschiedliche n: T(10,t) ≠ T(100,t) ≠ T(109,t)
Interessant asymptotisches Verhalten (worst case): lim T (n, t )
n →∞
O-Funktionen
= obere Schranke für Programm-Laufzeit
Ziel: kleineste obere Schranke finden
Aus der Mathe:
• konstante multiplikative Faktoren sind unwichtig
(dort stecken die Maschinen und Compilerdetails)
• Terme niedriger Ordnung sind unwichtig. Bsp:
• Transitivität
Bsp:
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
O(2n + n3) = O(2n)
f(n) = O(g(n)) ⇒ f(n) = O(h(n))
g(n) = O(h(n))
37
Übliche Schranken
• Konstante
• logarithmisch
• linear
• n log n
• quadratisch
• kubisch
• exponentiell
O(1)
O(log n)
O(n)
O(n log n)
O(n2)
O(n3)
O(2n)
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
38
Anwendung auf Programmanweisungen #1
• for-Schleife
for (i=0; i<n; i++) {
//
//n mal
O(1)
// Schleifenkörper: Inhalt unbekannt ⇒ O(f(n))
}
3 * O(1) + n*O(f(n))
= O(n*f(n))
• Verzweigung
if (Boolscher Ausdruck) {
//
O(1)
// if-Zweig:
O(f(n))
}
else {
// else-Zweig:
O(g(n))
}
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
O(max(f(n), g(n))
39
Anwendung auf Programmanweisungen #2
• Block
m
{
// Statements
O(Block ) = ∑ O(Statementi )
i =1
}
• while- und do-while-Schleife
while(Bedindung) {
//
O(1)
// Schleifenkörper: O(f(n))
}
Worst case O(g(n));
O(g(n))*O(f(n)) = O (g(n)*f(n))
• Schleifenkörper f(n): wir wissen nicht, was im Körper steht
• Worst case g(n): wir wissen nicht, wieviel mal die Schleife läuft
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
40
Beispiel 1
//Einheitsmatrix aufbauen
for (i=0; i<n; i++)
//
for (j=0; j<n; j++) //
a[i][j]=0;
//
for (i=0; i<n; i++)
//
a[i][i]=1;
//
n-mal
n-mal
O(1) O(n)
n-mal
O(1) O(n)
T(n) = O(n2) + O(n) = O(n2)
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
41
O(n2)
Beispiel 2
for (i=0; i<n-2; i++) {
n-2 - mal
small = i;
//
for (j=i+1;j<=n-1;j++)// n-i-1 - mal
if (a[j]<a[small])//
small = j;
//O(1) max(O(1),0)
temp = a[small];
//
a[small] = a[i];
//
a[i] = temp;
//
}
O(1)
O(n-i-1)
=O(n) O(n)
O(1)
O(1)
O(1)
T(n) = (n-2)*O(n) = O(n2) - O(n) = O(n2)
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
42
Sortieraufwand#1
Voraussetzungen:
1. Wirtschaftlicher Einsatz des Speicherraumes
2. Zeitaufwand
Zeitaufwand: Effizienz gegeben durch:
C ... Anzahl der Schlüsselvergleiche (compare); C=f(n)
M ... Anzahl der Elementumstellungen (move); M=g(n)
(n...Anzahl der zu sortierenden Elemente)
gute Methoden:
schlechtere Methoden
C = O(n log2(n))
C = O(n2)
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
43
Sortieraufwand#2
Cmin
Insertionsort
n-1
Cavrg
(n2+n-2)/4
Selectionsort
(n2+n)/2
Bubblesort
(n2+n)/2
Cmax
Mmin
Mavrg
(n2+n)/2-1
2(n-1)
n2+9n-10
0
3(n2-n)/4
Heapsort
Cmax + Mmax ~ n log2(n)
Mergesort
Cmax + Mmax ~ n log2(n)
Quicksort
Einphasen-Mischen
(n2+3n-4)/4
3(n-1) n(ln(n)+0.57..) n2/4+3(n-1)
C + M ~ n1.2)
Shellsort
Mmax
n log2(n)
C<<M
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
(log2(n))/6
n log2(n)
44
(n2-n)/2
Suchen
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
45
Sequentielle Suche
0
03 enthalten?
1
2
3
4
5
6
25 01 08 18 14 03 16
• z.B. von links suchen, solange
- gefunden oder
- Array-Ende erreicht (das gesuchte Element nicht enthalten)
• die Elemente müssen nicht vorher sortiert werde
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
46
Binäre Suche
0
03 enthalten?
1
2
3
4
5
6
01 03 08 14 16 18 25
mitte
= (elm[linkerRand}+elm[rechterRand])/2
• Prinzip: divide et impera
• Die Zahlen müssen vorher sortiert werden
Funktionsweise:
- Die gesuchte Zahl < Mitte? => dann links von der Mitte suchen
- Die gesuchte Zahl > Mitte? => dann rechts von der Mitte suchen
- Die gesuchte Zahl = Mitte? => gefunden!!!
Iterativ oder rekursiv weiter machen, bis 1-Element-Feld
1-Element-Feld geprüft und immer noch nicht gefunden? =>
=> dann ist die Zahl nicht enthalten
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
47
0
Suche nach:
Suche in Strings
1
2
3
4
str
h u h u l
j
0
im string:
1
2
3
4
5
6
7
a h u h u h u l
muster
i
Funktionsweise:
• i erhöht sich, sobald muster[i] = str[j]
• dann werden beiden Zeiger i und j inkrementiert und die Übereinstimmung
entsprechender Zeichen geprüft
• Bei der ersten Ungleichheit: j=0, i geht zurück und zeigt auf den rechten Nachbar
vom Zeichen, bei dem die Übereinstimmung began
• Varianten: nach dem 1. Auftreten, nach allen Sunstrings suchen, etc.
2009 Jiri Spale, Algorithmen und Datenstrukturen - Sortieren
48