5 Ausgewählte Algorithmen

5
5 Ausgewählte Algorithmen
5.1 Motivation
5.2 Suchen in sortierten Folgen
5.3 Sortieren
79
5 Ausgewählte Algorithmen
Teil V
Ausgewählte Algorithmen
Überblick
Motivation
Suchen in sortierten Folgen
Sortieren
Saake/Schallehn
Algorithmen & Datenstrukturen
5–1
Motivation
◮
◮
◮
Kennenlernen von Beispielalgorithmen, auch als
Grundlage für praktische Übungen
Vorbereitung der theoretischen Betrachtungen, etwa
Komplexität von Algorithmen
informelle Diskussion von Design-Prinzipien
Saake/Schallehn
80
Algorithmen & Datenstrukturen
5–2
Uni Magdeburg, WS 2005/06
5 Ausgewählte Algorithmen
◮
Suchen als eine der häufigsten Aufgaben in der Informatik
◮
Vielzahl von Lösungen für unterschiedlichste Aufgaben
◮
◮
hier: Suchen in sortierten Folgen
Annahmen
◮
◮
◮
◮
5
Suchen in sortierten Folgen
Folge F als Feld von numerischen Werten
Zugriff auf i-tes Element über F [i]
nur Berücksichtigung des Suchschlüssels
Beispiel: Telefonbuch, Suche nach Namen
Saake/Schallehn
Algorithmen & Datenstrukturen
5–3
Sequenzielle Suche: Algorithmus
algorithm SeqSearch (F , k ) → p
Eingabe: Folge F der Länge n, Schlüssel k
for i := 1 to n do
if F [i] = k then
return i
fi
od;
return NO_KEY
Saake/Schallehn
Algorithmen & Datenstrukturen
5–4
Sequenzielle Suche: Aufwand
bester Fall
schlechtester Fall
Durchschnitt (erfolgreiche Suche)
Durchschnitt (erfolglose Suche)
Saake/Schallehn
Anzahl der Vergleiche
1
n
(n + 1)/2
n
Algorithmen & Datenstrukturen
Uni Magdeburg, WS 2005/06
5–5
81
5 Ausgewählte Algorithmen
Binäre Suche
◮
Prinzip:
1. Wähle den mittleren Eintrag und prüfe ob gesuchter Wert in
der ersten oder in der zweiten Hälfte der Liste ist.
2. Fahre rekursiv mit der Hälfte vor, in der sich der Eintrag
befindet.
Saake/Schallehn
Algorithmen & Datenstrukturen
5–6
Binäre Suche: Beispiel
1
2
3
4
0
1
2
4
5
6
7
8
5
8
9
12 13 18
m
u
0
1
2
4
0
1
2
4
5
10
o
8
9
12 13 18
m
u
Saake/Schallehn
9
5
8
9
u
m
o
o
12 13 18
Algorithmen & Datenstrukturen
5–7
Binäre Suche: Algorithmus
algorithm BinarySearch (F , k ) → p
Eingabe: Folge F der Länge n, Schlüssel k
u := 1, o := n;
while u <= o do
m := (u + o)/2;
if F [m] = k then
return m
else if k < F [m] then o := m − 1
else u := m + 1
fi; fi;
od;
return NO_KEY
Saake/Schallehn
82
Algorithmen & Datenstrukturen
5–8
Uni Magdeburg, WS 2005/06
5 Ausgewählte Algorithmen
5
Binäre Suche: rekursiver Algorithmus
algorithm BinarySearch (F , k ) → p
Eingabe: Folge F der Länge n, Schlüssel k
return BinarySearchRec (F , k , 1, n);
algorithm BinarySearchRec (F , k , u, o) → p
Eingabe: Folge F , Schlüssel k ,
unter und obere Schranken u und o
???
Saake/Schallehn
Algorithmen & Datenstrukturen
5–9
Binäre Suche: Aufwandsanalyse
◮
nach dem ersten Teilen der Folge: noch n/2 Elemente
◮
nach dem zweiten Schritt: n/4 Elemente
◮
nach dem dritten Schritt: n/8 Elemente
◮
...
◮
allgemein: im i-ten Schritt max. n/2i Elemente
Saake/Schallehn
log2 n
Algorithmen & Datenstrukturen
5–10
Binäre Suche: Aufwand
bester Fall
schlechtester Fall
Durchschnitt (erfolgreiche Suche)
Durchschnitt (erfolglose Suche)
Saake/Schallehn
Anzahl der Schritte
1
≈ log2 n
≈ log2 n
≈ log2 n
Algorithmen & Datenstrukturen
Uni Magdeburg, WS 2005/06
5–11
83
5 Ausgewählte Algorithmen
Vergleich der Suchverfahren
Verfahren
sequenziell (n/2)
binär (log2 n)
Saake/Schallehn
10
≈5
≈ 3.3
102
≈ 50
≈ 6.6
103
≈ 500
≈ 9.9
104
≈ 5000
≈ 13.3
Algorithmen & Datenstrukturen
5–12
Sortieren
◮
◮
Grundlegendes Problem in der Informatik
Aufgabe:
◮
◮
◮
Ordnen von Dateien mit Datensätzen, die Schlüssel
enthalten
Umordnen der Datensätze, so dass klar definierte Ordnung
der Schlüssel (numerisch/alphabetisch) besteht
Vereinfachung: nur Betrachtung der Schlüssel,
z.B. Feld von int-Werten
Saake/Schallehn
Algorithmen & Datenstrukturen
5–13
Sortieren: Grundbegriffe
◮
Verfahren
◮
◮
intern: in Hauptspeicherstrukturen (Felder, Listen)
extern: Datensätze auf externen Medien (Festplatte,
Magnetband)
Saake/Schallehn
84
Algorithmen & Datenstrukturen
5–14
Uni Magdeburg, WS 2005/06
5 Ausgewählte Algorithmen
5
Stabilität
Ein Sortierverfahren heißt stabil, wenn es die relative
Reihenfolge gleicher Schlüssel in der Datei beibehält.
◮
Beispiel: alphabetisch geordnete Liste von Personen soll
nach Alter sortiert werden → Personen mit gleichem Alter
weiterhin alphabetisch geordnet
Name
Endig, Martin
Geist, Ingolf
Höpfner, Hagen
Schallehn, Eike
Saake/Schallehn
Alter
30
28
24
28
Sortieren
Name
Höpfner, Hagen
Geist, Ingolf
Schallehn, Eike
Endig, Martin
Alter
24
28
28
30
Algorithmen & Datenstrukturen
5–15
Sortieren durch Einfügen: Prinzip
◮
Idee
◮
Umsetzung der typischen menschlichen Vorgehensweise,
etwa beim Sortieren eines Stapels von Karten:
1. Starte mit der ersten Karte einen neuen Stapel
2. Nimm jeweils nächste Karte des Originalstapels:
füge diese an der richtigen Stelle in den neuen Stapel ein
Saake/Schallehn
Algorithmen & Datenstrukturen
5–16
Sortieren durch Einfügen: Algorithmus
algorithm InsertionSort (F )
Eingabe: zu sortierende Folge F der Länge n
for i := 2 to n do
m := F [i]; /* zu merkendes Element */
j := i;
while j > 1 do
if F [j − 1] ≥ m then
/* Verschiebe F [j − 1] nach rechts */
F [j] := F [j − 1]; j := j − 1
else
Verlasse innere Schleife
fi;
F [j] := m /* Einfügeposition */
od
od
Saake/Schallehn
Algorithmen & Datenstrukturen
Uni Magdeburg, WS 2005/06
5–17
85
5 Ausgewählte Algorithmen
Sortieren durch Einfügen: Beispiel
Saake/Schallehn
1.Durchlauf
5
5
1
1
8
8
3
3
9
9
2
2
2.Durchlauf
1
1
1
5
5
5
8
8
8
3
3
3
9
9
9
2
2
2
3.Durchlauf
1
1
1
5
5
5
8
8
8
3
3
3
9
9
9
2
2
2
4.Durchlauf
1
1
1
3
3
3
5
5
8
8
9
9
2
2
2
5.Durchlauf
1
1
3
3
5
5
8
8
9
9
2
2
6.Durchlauf
1
1
1
2
2
2
3
3
3
5
5
5
8
8
8
9
9
9
Algorithmen & Datenstrukturen
5–18
Analyse: InsertionSort
◮
Aufwand:
◮
◮
◮
◮
Anzahl der Vertauschungen
Anzahl der Vergleiche
Vergleiche dominieren Vertauschungen, d.h. es werden
(wesentlich) mehr Vergleiche als Vertauschungen benötigt
Ausserdem Unterscheidung:
◮
◮
◮
Bester Fall: Liste ist schon sortiert
Mittlerer (zu erwartender) Fall: Liste ist unsortiert
Schlechtester Fall: z.B. Liste ist absteigend sortiert
Saake/Schallehn
Algorithmen & Datenstrukturen
5–19
Analyse: InsertionSort /2
◮
◮
◮
wir müssen in jedem Fall alle Elemente i = 2 bis n
durchgehen, d.h. immer Faktor n − 1
dann müssen wir zur korrekten Einfügeposition
zurückgehen
Bester Fall: Liste sortiert
→ Einfügeposition ist gleich nach einem Schritt an Position
i −1
◮
◮
◮
◮
bei jedem Rückweg Faktor 1
Gesamtanzahl der Vergleiche:
(n − 1) ∗ 1 = n − 1
für Große Listen abgeschätzt als n − 1 ≈ n
”linearer Aufwand”
Saake/Schallehn
86
Algorithmen & Datenstrukturen
5–20
Uni Magdeburg, WS 2005/06
5 Ausgewählte Algorithmen
◮
5
Analyse: InsertionSort /3
Mittlerer (zu erwartender) Fall: Liste unsortiert
→ Einfügeposition wahrscheinlich auf der Hälfte des
Rückwegs
◮
◮
bei jedem der n − 1 Rückwege Faktor (i − 1)/2
Gesamtanzahl der Vergleiche:
(n − 1)/2 + (n − 2)/2 + (n − 3)/2 + · · · + 2/2 + 1/2
(n − 1) + (n − 2) + · · · + 2 + 1
2
1 n ∗ (n − 1)
= ∗
2
2
n ∗ (n − 1)
=
4
n2
≈
4
=
Saake/Schallehn
Algorithmen & Datenstrukturen
5–21
Analyse: InsertionSort /4
◮
Schlechtester Fall: z.B. Liste umgekehrt sortiert
→ Einfügeposition am Ende des Rückwegs bei Position 1
◮
◮
◮
◮
bei jedem der n − 1 Rückwege Faktor i − 1
analaog zu vorhergehenden Überlegungen, bloss doppelte
Rückweglänge
Gesamtanzahl der Vergleiche:
2
n∗(n−1)
≈ n2
2
letzten beiden Fälle: ”quadratischer Aufwand”, wenn
konstante Faktoren nicht berücksichtigt werden
Saake/Schallehn
Algorithmen & Datenstrukturen
5–22
Sortieren durch Selektion
◮
Idee: Suche jeweils größten Wert, und tausche diesen an
die letzte Stelle; fahre dann mit der um 1 kleineren Liste
fort.
algorithm SelectionSort (F )
Eingabe: zu sortierende Folge F der Länge n
p := n;
while p > 0 do
g := Index des größten Elementes aus F
im Bereich 1...p;
Vertausche Werte von F [p] und F [g];
p := p − 1
od
Saake/Schallehn
Algorithmen & Datenstrukturen
Uni Magdeburg, WS 2005/06
5–23
87
5 Ausgewählte Algorithmen
Sortieren durch Selektion: Beispiel
Saake/Schallehn
1.Durchlauf
5
1
8
3
9
2
2.Durchlauf
5
1
8
3
2
9
3.Durchlauf
5
1
2
3
8
9
4.Durchlauf
3
1
2
5
8
9
5.Durchlauf
2
1
3
5
8
9
6.Durchlauf
1
2
3
5
8
9
Algorithmen & Datenstrukturen
5–24
Analyse: SelectionSort
◮
◮
◮
in jedem Durchlauf das Element von F [p] mit dem größten
Element tauschen
Variable p läuft von n . . . 1
daher n Vertauschungen
in jedem Durchlauf das größte Element aus 1 . . . p
ermitteln
p − 1 Vergleiche
(n − 1) + (n − 2) + (n − 3) + · · · + 2 + 1 =
◮
n(n − 1)
n2
≈
2
2
Anzahl Vergleiche identisch für besten, mittleren und
schlechtesten Fall!
Saake/Schallehn
Algorithmen & Datenstrukturen
5–25
BubbleSort
◮
Idee: Verschieden große aufsteigende Blasen („Bubbles“)
in einer Flüssigkeit sortieren sich quasi von allein, da
größere Blasen die kleineren „überholen“.
algorithm BubbleSort (F )
Eingabe: zu sortierende Folge F der Länge n
do
for i := 1 to n − 1 do
if F [i] > F [i + 1] then
Vertausche Werte von F [i] und F [i + 1]
fi
od
until keine Vertauschung mehr aufgetreten
Saake/Schallehn
88
Algorithmen & Datenstrukturen
5–26
Uni Magdeburg, WS 2005/06
5 Ausgewählte Algorithmen
5
BubbleSort: Beispiel
5
1
8
3
9
2
1
5
8
3
9
2
1
5
3
8
9
2
1
5
3
8
2
9
1
3
5
8
2
9
3.
3.Durchlauf
Durchlauf
1
3
5
2
8
9
4.Durchlauf
1
3
2
5
8
9
1
2
3
5
8
9
1.Durchlauf
2.Durchlauf
5.Durchlauf
Saake/Schallehn
Algorithmen & Datenstrukturen
5–27
BubbleSort: Optimierung
◮
◮
größte Zahl rutscht in jedem Durchlauf automatisch an das
Ende der Liste
im Durchlauf j reicht die Untersuchtung bis Position n − j
Saake/Schallehn
Algorithmen & Datenstrukturen
5–28
Analyse: BubbleSort
◮
◮
◮
Bester Fall: n
Durchschnittlicher Fall
normal: n2
2
optimiert: n2
Schlechtester Fall
normal: n2
2
optimiert: n2
Saake/Schallehn
Algorithmen & Datenstrukturen
Uni Magdeburg, WS 2005/06
5–29
89
5 Ausgewählte Algorithmen
MergeSort: Prinzip
◮
Idee:
1. Teile die zu sortierende Liste in zwei Teillisten
2. Sortiere diese (rekursives Verfahren!)
3. Mische die Ergebnisse
Saake/Schallehn
Algorithmen & Datenstrukturen
5–30
Mischen von zwei Folgen: Algorithmus
procedure Merge (F1 , F2 ) → F
Eingabe: zwei zu sortierende Folgen F1 , F2
Ausgabe: eine sortierte Folge F
F := leere Folge;
while F1 oder F2 nicht leer do
Entferne das kleinere der Anfangselemente
aus F1 bzw. F2 ;
Füge dieses Element an F an
od;
Füge die verbliebene nichtleere Folge F1
oder F2 an F an;
return F
Saake/Schallehn
Algorithmen & Datenstrukturen
5–31
Sortieren durch Mischen: Algorithmus
algorithm MergeSort (F ) → FS
Eingabe: eine zu sortierende Folge F
Ausgabe: eine sortierte Folge FS
if F einelementig then
return F
else
Teile F in F1 und F2 ;
F1 := MergeSort (F1 );
F2 := MergeSort (F2 );
return Merge (F1 , F2 )
fi
Saake/Schallehn
90
Algorithmen & Datenstrukturen
5–32
Uni Magdeburg, WS 2005/06
5 Ausgewählte Algorithmen
Split
Split
5
5
5
Merge
Saake/Schallehn
1
1
5
8
1
9
3
2
8
3
9
8
3
9
1
9
1
5
3
9
1
5
8
2
3
1
2
3
5
MergeSort: Beispiel
2
2
3
8
5
9
9
Algorithmen & Datenstrukturen
5–33
Analyse: MergeSort
◮
Folge der Länge n: Anzahl der Vergleiche = Vn
Vn = 2Vn/2 + n für n ≥ 2 mit V1 = 0
◮
◮
jede Teilfolge sortieren (n/2 Vergleiche), Mischen (n
Vergleiche)
Annahme: n = 2N (n ist Zweierpotenz)
V2N
V2N
2N
Saake/Schallehn
= 2V2N−1 + 2N
V2N−1
=
+1
2N−1
Algorithmen & Datenstrukturen
5–34
Analyse: MergeSort /2
◮
sukzessive
V2N−i
ersetzen bis i = N
2N−i
V2N
=N
2N
◮
aus 2N folgt N = log n:
Vn = n log n
Saake/Schallehn
Algorithmen & Datenstrukturen
Uni Magdeburg, WS 2005/06
5–35
91
5 Ausgewählte Algorithmen
QuickSort: Prinzip
◮
Idee:
◮
◮
ähnlich wie MergeSort durch rekursive Aufteilung
Vermeidung des Mischvorgangs durch Aufteilung der
Teillisten in zwei Hälften bezüglich eines Pivot-Elementes,
wobei
◮
◮
in einer Liste alle Elemente größer als das Referenzelement
sind
in der anderen Liste alle Elemente kleiner sind
Saake/Schallehn
Algorithmen & Datenstrukturen
5–36
QuickSort: Algorithmus
algorithm QuickSort (F , u, o)
Eingabe: eine zu sortierende Folge F ,
die untere und obere Grenze u, o
if o > u then
Zerlege F [u . . . o] in zwei Partitionen
F [u . . . r ] und F [l . . . o];
QuickSort (F , u, r );
QuickSort (F , l, o)
fi
Saake/Schallehn
Algorithmen & Datenstrukturen
5–37
QuickSort: Vertauschen von Elementen
◮
Pivot-Element p
◮
◮
◮
Folge von links durchsuchen, bis Element gefunden, das
größer oder gleich p ist
Folge von rechts durchsuchen, bis Element gefunden, das
kleiner p ist
Elemente ggf. tauschen
2
Saake/Schallehn
92
7
4
6
3
9
Algorithmen & Datenstrukturen
8
5–38
Uni Magdeburg, WS 2005/06
5 Ausgewählte Algorithmen
5
QuickSort: Zerlegen beim QuickSort
algorithm Zerlege (F , u, o)
Eingabe: Folge F , untere/obere Grenze u, o
Ausgabe: Positionen l und r der Zerlegung
p := F [(u + o)/2];
l := u; r := o;
while l ≤ r do
l := Index des ersten Elementes aus l . . . o
mit F [l] ≥ p;
r := Index des letzten Elementes aus u . . . r
mit F [r ] < p;
if l ≤ r then
Tausche F [l] und F [r ];
l := l + 1; r := r − 1
fi
od
Saake/Schallehn
Algorithmen & Datenstrukturen
5–39
QuickSort: Beispiel
Ebene0
Ebene1
Ebene2
8
2
1
5
9
7
3
3
2
1
5
9
7
8
3
2
1
9
7
8
1
2
3
7
9
8
9
8
8
9
1
3
Ebene3
Saake/Schallehn
8
Algorithmen & Datenstrukturen
5–40
Analyse: QuickSort
◮
Aufwand analog zu MergeSort abschätzbar
◮
◮
◮
◮
Bester Fall: n log n
Durchschnittlicher Fall: n log n
Schlechtester Fall: n log n
aber: im Gegensatz zur MergeSort ist QuickSort durch
Vorgehensweise bei Vertauschungen instabil
Saake/Schallehn
Algorithmen & Datenstrukturen
Uni Magdeburg, WS 2005/06
5–41
93
5 Ausgewählte Algorithmen
Sortierverfahren im Vergleich
Verfahren
SelectionSort
InsertionSort
BubbleSort
MergeSort
QuickSort
Saake/Schallehn
Stabilität
Vergleiche (im Mittel)
instabil
stabil
stabil
stabil
instabil
≈ n2 /2
≈ n2 /4
≈ n2 /2
≈ n log n
≈ n log n
Algorithmen & Datenstrukturen
5–42
Zusammenfassung
◮
Suchen und Sortieren als Grundaufgaben in der Informatik
◮
Grundalgorithmen
◮
Algorithmenmuster „Teile und herrsche“
◮
Abschätzung des Aufwands
◮
Literatur: Saake/Sattler: Algorithmen und Datenstrukturen,
Kapitel 5
Saake/Schallehn
94
Algorithmen & Datenstrukturen
5–43
Uni Magdeburg, WS 2005/06