Sortieren und Suchen IFB 2002 Daniel Jonietz.

Präsentation zum Thema: "Sortieren und Suchen IFB 2002 Daniel Jonietz."—  Präsentation transkript:

1 Sortieren und Suchen IFB 2002 Daniel Jonietz

2 Überblick Teil 1: Elementare Sortieralgorithmen Teil 2: Quicksort
Teil 2: Effizienz von Sortierverfahren Teil 3: Suchalgorithmen

3 Teil 1 Elementare Sortieralgorithmen

4 Motivation Eine Reihe von Werten liegt unsortiert vor. Ziel: Die Werte sollen (aufsteigend) sortiert werden.

5 Datenmodell Die Werte liegen in einer Reihung vor: ... ... tIndex 1 2
1 2 user_max prog_max ... ... tWert tZahlen

6 Insgesamt höchstens 1000 Werte
Daten und Typen const prog_max = 1000; type tWert = integer; tIndex = integer; tZahlen = array [0..prog_max] of tWert; var zahlen: tZahlen; user_max: tWert = 14; Insgesamt höchstens 1000 Werte Verwenden davon nur 15

7 Sortieren durch Auswahl
Idee: Suche das kleinste Element und lege es beiseite. Dann wähle aus den übrigen wiederum das kleinste Element und lege es daneben. Sortieren von Münzen

8 Auswahl-Sortieren V1 5 7 2 8 3 1 4 1 5 7 2 8 3 4 1 2 5 7 8 3 4 1 2 3 5 7 8 4 1 2 3 4 5 7 8 1 2 3 4 5 7 8 1 2 3 4 5 7 8 1 2 3 4 5 7 8

9 Auswahl-Sortieren V2 5 7 2 8 3 1 4 1 7 2 8 3 5 4 1 2 7 8 3 5 4 1 2 3 8 7 5 4 1 2 3 4 7 5 8 1 2 3 4 5 7 8 1 2 3 4 5 7 8 1 2 3 4 5 7 8 „in situ“

10 Algorithmus Brauchen Möglichkeit zur Bestimmung des Minimums aus einem Bereich der Zahlen

11 Minimum und Maximum Aufruf findet statt in procedure TForm1.suche_minimum(Sender: TObject); procedure TForm1.suche_maximum(Sender: TObject);

12 Aufgabe Implementieren Sie die Funktionen function min(anfang, ende: tIndex): tIndex; function max(anfang, ende: tIndex): tIndex; die den Index eines minimalen bzw. maximalen Elementes aus dem Bereich anfang ... ende liefert. Implementieren Sie damit die Prozedur procedure minsort; Wer möchte, auch procedure maxsort; Idee?

13 Lösungsvorschlag function min(anfang, ende: tIndex): tIndex;
var i, min_pos: tIndex; min_wert: tWert; begin min_pos:= anfang; min_wert:= zahlen[min_pos]; for i:= anfang+1 to ende do if (zahlen[i] < min_wert) then min_pos:= i; end; min:= min_pos; Kandidat besserer Kandidat

14 Lösungsvorschlag function max(anfang, ende: tIndex): tIndex;
var i, max_pos: tIndex; max_wert: tWert; begin max_pos:= anfang; max_wert:= zahlen[max_pos]; for i:= anfang+1 to ende do if (zahlen[i] > max_wert) then max_pos:= i; end; max:= max_pos; Kandidat besserer Kandidat

15 Lösungsvorschlag procedure minsort; var i, merke: tIndex; begin
for i:= 0 to user_max-1 do merke:= min(i, user_max); tausche(zahlen[merke], zahlen[i]); end;

16 Lösungsvorschlag Idee: Suche immer das Maximum und sammle von rechts
procedure maxsort; var i, merke: tIndex; begin for i:= user_max downto 1 do merke:= max(0, i); tausche(zahlen[merke], zahlen[i]); end; Idee: Suche immer das Maximum und sammle von rechts

17 Sortieren durch Einfügen
Idee: Nimm das nächste Element und füge es sortiert ein. Sortieren eines Kartenspiels

18 Sortieren durch Einfügen
5 7 2 8 3 1 4 5 7 2 8 3 1 4 5 7 2 8 3 1 4 2 5 7 8 3 1 4 2 5 7 8 3 1 4 2 3 5 7 8 1 4 1 2 3 5 7 8 4 1 2 3 4 5 7 8

19 Sortieren durch Einfügen
5 7 2 8 3 1 4 5 7 2 8 3 1 4 5 7 2 8 3 1 4 2 5 7 8 3 1 4 2 5 7 8 3 1 4 2 3 5 7 8 1 4 1 2 3 5 7 8 4 1 2 3 4 5 7 8 „in situ“

20 Sortieren durch Einfügen
Verschiebeoperationen sind auf Reihungen schwierig zu realisieren Günstig auf anderen Datenstrukturen ( Listen)

21 Bubblesort Idee: Vergleiche paarweise und schiebe große Elemente nach hinten Sortieren wie Blasen in einem Wasserglas aufsteigen: Große Blasen steigen schnell auf

22 Bubblesort - Beispiel 5 7 2 8 3 1 4 5 2 7 3 1 4 8 2 5 3 1 4 7 8 2 3 1 4 5 7 8 2 1 3 4 5 7 8 1 2 3 4 5 7 8 1 2 3 4 5 7 8

23 Algorithmus Ende des Sortiervorgangs:
Wenn keine Vertauschung mehr stattfand spätestens nach „Anzahl“ Schleifendurchläufen

24 Aufgaben Implementieren Sie die procedure bubblesort;
Der vorgestellte Bubblesort-Algorithmus kann noch verbessert werden: Die innere Schleife muss nicht immer bis zum Ende durchlaufen werden. Durchdenken Sie dies und verbessern Sie Ihre Implementierung.

25 Lösungsvorschlag procedure bubblesort; var i: tIndex;
getauscht: boolean; begin repeat getauscht:= FALSE; for i:= 0 to user_max-1 do if (zahlen[i] > zahlen[i+1]) then tausche(zahlen[i], zahlen[i+1]); getauscht:= TRUE; end; until not getauscht;

26 Teil 2 Quicksort

27 Quicksort Prinzip: Teile und Herrsche
Wähle ein Pivot-Element, das das Problem in zwei Teilprobleme zerlegt. Ein Bereich enthält dann alle Elemente, die kleiner sind als das Pivot-Element, der andere Bereich alle Elemente, die größer sind. Löse die Teilprobleme auf die gleiche Art und Weise.

28 Quicksort - Beispiel 5 1 8 4 3 7 2 2 1 3 4 8 7 5 1 2 3 4 5 7 8 1 2 3 4 5 7 8 1 2 3 4 5 7 8

29 Quicksort - Pivot-Element
Die Wahl des Pivot-Elementes beeinflusst wesentlich die Anzahl benötigter Durchgänge schlecht: p=min() und p=max() gut: p=Zahlen[(links + rechts) div 2] Feld mittleren Wertes optimal: ein Element das den zu sortierenden Bereich in zwei gleich große Teile partitioniert

30 Quicksort - Zerlegen 5 2 7 4 8 1 3 3 5

31 Quicksort - Zerlegen 5 2 7 4 8 1 3 3 2 1 7 5

32 Quicksort - Zerlegen 5 2 7 4 8 1 3 3 2 1 4 8 7 5

33 Zerlege - Algorithmus

34 Quicksort - Algorithmus

35 Aufgaben Schreiben Sie die Funktion function pivot (links, rechts: tIndex): tIndex; Implementieren Sie procedure zerlege (var links, rechts: tIndex); und damit dann insgesamt Quicksort procedure quicksort(anfang, ende: tIndex);

36 Lösungsvorschlag function pivot (links, rechts: tIndex): tIndex; begin
pivot:= zahlen[(links + rechts) DIV 2] end;

37 Lösungsvorschlag procedure zerlege (var links, rechts: tIndex); var
p : tWert; begin p := pivot(links, rechts); repeat while zahlen[links] < p do links:= links +1; while zahlen[rechts] > p do rechts:= rechts -1; ...

38 Lösungsvorschlag ... if (links <= rechts) then begin
tausche (zahlen[links], zahlen[rechts]); links := links +1; rechts := rechts -1; end; until (links > rechts);

39 Lösungsvorschlag procedure quicksort(anfang, ende: tIndex); var
links, rechts: tIndex; begin links:= anfang; rechts:= ende; zerlege (links, rechts); if (anfang < rechts) then quicksort(anfang, rechts); if (links < ende) then quicksort(links, ende); end;

40 Weitere Sortierverfahren
Heapsort Shellsort Bucketsort Platzziffersortieren Mergesort

41 Teil 3 Effizienz von Sortierverfahren

42 Kriterien Stabilität Geschwindigkeit
Bleiben evtl. vorhandene Vorsortierungen erhalten? Geschwindigkeit Anzahl Vergleiche Anzahl Tauschoperationen Einfluss von Parametern auf den Sortiervorgang Quicksort: Bestimmung des Pivot-Elementes

43 Stabilität Was passiert mit nach anderen Kriterien bereits sortierten Daten? Angenommen, Blau < Rot 1 4 3 4 1 4 2 1 1 2 3 4 4 4 Auswahl (von links) 1 1 2 3 4 4 4 Auswahl (von rechts)

44 Stabilität Beispiel: Adressdaten (Telefonbuch o.ä.) Daten:
Name Ort ... Sind bereits sortiert nach Ort, sollen jetzt nach Name sortiert werden Die Vorsortierung soll erhalten bleiben!

45 Komplexität Unterscheiden 3 Fälle: Aufwandsbestimmung Best Case
(Average Case) Worst Case Aufwandsbestimmung Messung Zählung und arithmetische Rechnung asymptotische Abschätzung

46 Experimente Verwenden Zähler zur Abschätzung des Aufwandes

47 Experimente - Daten 2 neue Zähler: var tausch_z: integer = 0;
// Anzahl Tauschoperationen vergleich_z: integer = 0; // Anzahl Vergleichsoperationen

48 Exkurs - Ereignissteuerung
Die Initialisierung der Zähler geschieht beim Aufruf der Sortierprozedur aus der Ereignissteuerung heraus: procedure TForm1.austausch_sortieren(Sender: TObject); begin tausch_z:= 0; vergleich_z:= 0; minsort; zeige_zaehler; zeige_zahlen; end; Zähler initialisieren Verfahren starten Aktuelle Werte anzeigen

49 Aufgaben Erweitern Sie die Algorithmen so, dass die entsprechenden Zähler erhöht werden. tausche min bzw. max minsort bzw. maxsort bubblesort zerlege quicksort Untersuchen Sie experimentell den Aufwand bei der Sortierung einiger Zahlenreihen. Wie verhalten sich die verschiedenen Verfahren bei bereits sortierten und umgekehrt sortierten Daten?

50 Lösung (exemplarisch)
procedure tausche(var x, y: tWert); var hilf: tWert; begin hilf:= x; x:= y; y:= hilf; tausch_z:= tausch_z +1; end;

51 Groß-O-Notation Wenn für die Laufzeit T(n) eines Algorithmus gilt: T(n)  c*n für eine Konstante c>0 und alle Werte n>n0, so sagt man „T(n) ist in O(n)“ (IdR reicht es den „stärksten“ Ausdruck zu wählen.)

52 Aufwand minsort Aufwand für die Suche des Minimums: (n Elemente)
beim 1. Durchlauf: n-1 Vergleiche beim 2. Durchlauf: n-2 Vergleiche beim n. Duchlauf: n-n Vergleiche Gesamt: Tauschoperationen: in jedem Durchlauf genau eine, also gesamt n-1 Stück in O(n) n  (n - i) = .5n²-.5n ~ n² in O(n²) i=1

53 Die ursprüngliche Fassung
Aufwand bubblesort Vergleichsoperationen (best case) beim 1. Durchlauf: n-1 Vergleiche Fertig! Tauschoperationen (best case) keine Die ursprüngliche Fassung

54 Aufwand bubblesort Vergleichsoperationen (worst case)
beim 1. Durchlauf: n-1 Vergleiche beim 2. Durchlauf: n-1 Vergleiche ... beim n. Duchlauf: n-1 Vergleiche Gesamt: n*(n-1) = n²-n in O(n²) Tauschoperationen (worst case) beim 1. Durchlauf: n-1 Austausche beim 2. Durchlauf: n-2 Austausche beim n. Durchlauf: n-n Austausche Gesamt: n  (n - i) = .5n²-.5n in O(n²) i=1

55 Aufwand Quicksort Bestimmung des Pivot-Elementes
hier so gestaltet, dass Aufwand zur Bestimmung vernachlässigbar aber: Wahl des Elementes hat großen Einfluß auf den weiteren Aufwand! Ungünstigste Wahl führt zu O(n²)! Vereinfachte Analyse unter folgenden Bedingungen: Anzahl Elemente 2er-Potenz: n=2k Zerlegung halbiert immer Zerlegung: fortwährende Halbierung führt zu Zerlegungstiefe log2 (n) führt insgesamt auf: O(n*log2(n))

56 Messergebnisse Überblick und Ergebnisse der Zählungen
Min/Maxsort: O(n²) Bubblesort: O(n²) Quicksort: O(n*log2(n))

57 Teil 4 Suchalgorithmen

58 Suchalgorithmen Zwei grundlegende Strategien: Beispiel Telefonbuch
lineares (sequenzielles) Suchen binäres Suchen Beispiel Telefonbuch Suche nach Namen: binär (naja, in etwa) Suche nach Nummer: linear Beispiel Reihe von Zahlen Suche nach Minimum und Maximum: linear

59 Lineares Suchen - Bsp Suche nach Element 11 1 3 5 7 11 13 17 1 3 5 7
möglich 1 3 5 7 11 13 17 unmöglich 1 3 5 7 11 13 17 Testelement Treffer

60 Lineares Suchen Prüfe der Reihe nach alle Elemente ab, bis das gesuchte Element gefunden ist oder keine Elemente mehr da sind. keine Voraussetzungen an die Daten, dürfen auch unsortiert sein.

61 Lineares Suchen - Alg.

62 Binäres Suchen Voraussetzung: sortierte Daten Idee:
Beginne mit der Suche in der Mitte der Daten; wenn der Suchschlüssel kleiner ist suche in der Mitte des rechten Bereiches weiter, wenn der Suchschlüssel größer ist in der Mitte des linken Bereiches.

63 Binäres Suchen - Beispiel
Suche nach Element 11 1 3 5 7 11 13 17 1 3 5 7 11 13 17 1 3 5 7 11 13 17 1 3 5 7 11 13 17 möglich unmöglich Testelement Treffer

64 Binäres Suchen - Alg.

65 Aufgabe Vereinbarung: Wenn das Gesuchte nicht in den Daten enthalten ist soll -1 zurückgegeben werden! Erweiterung der Datenstruktur: type tIndexFehler = integer; Implementieren Sie function lineare_suche(wonach: tWert): tIndexFehler; function binaere_suche(wonach: tWert): tIndexFehler;

66 Lösung function lineare_suche(wonach: tWert): tIndexFehler; var
i: tIndex; position: tIndexFehler; begin position:= -1; i:= 0; repeat if zahlen[i] = wonach then position:= i; i:= i+1; until (position <> -1) OR (i-1 = user_max); lineare_suche:= position; end;

67 Lösung function binaere_suche(wonach: tWert): tIndexFehler; var
links, rechts, position : tIndex; begin links:= 0; rechts:= user_max; // hier eigentliche Suche ... if (wonach = zahlen[position]) then binaere_suche:= position else binaere_suche:= -1; end;

68 Lösung // das hier ist die eigentliche Suche: repeat
position:= (links + rechts) div 2; if (wonach < zahlen[position]) then rechts:= position -1; else if (wonach > zahlen[position]) then links:= position +1; until (wonach = zahlen[position]) //Treffer! OR (links > rechts); //nicht gefunden

69 Lineare vs. Binäre Suche
Verdoppelt sich die Anzahl Elemente, so führt dies schlimmstenfalls zu einer Verdopplung des Aufwandes bei linearer Suche einem zusätzlichen Vergleich bei binärer Suche Einbau von Zählern verdeutlicht dies: var linear_z: integer = 0; binaer_z: integer = 0;

70 Übung Erweitern Sie die Suchfunktionen, indem Sie die Zähler für jeden benötigten Suchschritt (jeden benötigten Vergleich) erhöhen function binaere_suche(wonach: tWert): tIndexFehler; function lineare_suche(wonach: tWert): tIndexFehler;

71 Such-Experimente

72 Weitere Suchverfahren
Fibonacci-Suche Sprungsuche