FH-Hof

Sortierverfahren

Richard Göbel

FH-Hof

Sortierverfahren - Anwendungen

Sortierte Ausgabe von Daten

Effiziente Algorithmen

Suchen in sortierten Listen

Vergleich von Elementen verschiedener Listen

. . . und andere . . .

FH-Hof

Sortierverfahren - Voraussetzung

Elemente müssen vergleichbar sein

Zahlen

Zeichenketten

Allgemein: Totale Ordnung

Eine Liste [x1, x2, . . . , xn] ist sortiert g.d.w.:

:x x x , , :x y z x y y z x z

, :x y x y y x x y

1[1, 1] : i ii n x x

FH-Hof

Sortierverfahren - Comparator in Java

public MyComparator implements Comparator

{

public int compare(Object o1, Object o2)

{

. . .

}

public boolean equals(Object obj)

{

. . .

}

}

FH-Hof

Einfaches Sortierverfahren (Bubble Sort)

Überprüfe ob die Liste sortiert ist

Falls die Sortierbedingung an einer Stelle

verletzt ist, dann tausche die entsprechenden

Elemente

Wiederhole dieses Verfahren, bis die Liste

sortiert ist

Dieses Verfahren ist nicht effizient!

FH-Hof

Effizientes Sortieren

Aufwand für Sortierverfahren:

Vergleich von Elementen

Einfügen von Elementen in eine sortierte Liste

Ansatz:

Verringere die Anzahl der Vergleichsoperationen

Vermeide Verschieben einer Teilliste beim

Einfügen

FH-Hof

Sortieren - Ideen für ein Verfahren

Identifiziere schrittweise alle größten

(kleinsten) Elemente einer Liste und speichere

diese in ihrer Reihenfolge

Teile und Beherrsche: Aufteilung der großen

Liste in kleinere Listen

Sortieren durch Fachverteilung

FH-Hof

Sortieren - Größtes Element

Finde das größte Element der Liste

Vertausche das größte Element mit dem letzten

Element der Liste

Setze das Verfahren mit der Liste ohne das

letzte Element fort

Endbedingung: Die Liste enthält nur noch ein

Element

FH-Hof

Sortieren - Finde Größtes Element, Insertion Sort

. . .

max = list[0];

pos = 0;

for (int i = 1; i < list.length; i++)

{

if (max < list[i])

{

max = list[i]

pos = i;

}

}

. . .

FH-Hof

Sortieren - Diskussion Insertion Sort

Anzahl Vergleiche:

n + (n -1) + . . . + 1 = (n2+n)/2

Es werden eine Vielzahl von

Vergleichsoperationen bei jedem Durchgang

wiederholt!

Ein verbesserter Ansatz sollte Ergebnisse

mindestens einiger Vergleiche speichern

Ansatz hier: Aufbau einer entsprechenden

Datenstruktur auf der Basis eines binären

Baums

FH-Hof

Binärer Baum als so genannter „Heap“

x1

x2 x3

x4 x5 x6 x7

1 2 3 4 5 6 7, , , , , ,x x x x x x x

2 4 5, ,x x x

3 6 7, ,x x x

FH-Hof

Aufbau des Heap

Bottom-Up: Tausche Element mit dem größten

Nachfolger falls nötig

Top-Down: Vertausche das eingefügte kleinere

Element mit dem größten Nachfolger falls nötig

(soweit wie nötig)

Setze dieses Verfahren schrittweise bis zur Wurzel

des Baumes fort

FH-Hof

Aufbau des Heap - Bottom Up

1

2

4 3

5 8

Bis hier bereits fertig!

Vertauschen!

FH-Hof

Aufbau des Heap - Top Down

1

8

5

4 3

24

2

Evtl. weiter nach unten

FH-Hof

Darstellung des Heap - Idee

Für den Heap soll keine komplexe Darstellung

aufgebaut werden

Idee: Darstellung des Heap direkt auf dem

Array

Position i hat die Nachfolger:

2 * i

2 * i + 1

FH-Hof

Darstellung des Heap - Beispiel

1213

624

3841

715

31

2642

1617

49

1213 6243841715312642161749

FH-Hof

Heap Sort - Ansatz

1: Baue den Heap auf einem Array der Länge n auf:

Bearbeite schrittweise die Positionen n/2 bis 1

Überprüfe die Nachfolger und vertausche ggf.

Elemente (Bottom-Up, Top-Down)

2: Vertausche das erste Element (größtes Element)

mit dem letzten Element des Arrays

3: „Blockiere“ das letzte Element (Array wird

„virtuell“ um eine Position kleiner)

4: Wende den „Top-Down“-Ansatz auf das erste

Element an

5: Wiederhole die Schritte 2 - 4 bis das Array sortiert

ist

FH-Hof

Heap Sort - Diskussion

Aufwand im schlechtesten Fall: O(log(n)*n))

Kein zusätzlicher Speicherplatz nötig

FH-Hof

Teile und Beherrsche - Beliebige Aufteilung

Teile die Liste in zwei (fast) gleich große

Teillisten

Sortiere die Teilliste

Erzeuge die Gesamtliste aus den sortierten

Teillisten

Vergleiche die beiden kleinsten Elemente der

sortierten Teillisten

Füge das kleinere Element in die Ergebnisliste

Wiederhole diese Schritte, bis die beiden

Teillisten leer sind

Bezeichnung: Merge Sort

FH-Hof

Diskussion Merge Sort

Aufwand im schlechtesten Fall: O(log(n)*n))

Vergleich mit Heap Sort:

Zusätzlicher Speicher wird benötigt (mindestens in

der Größe der zu sortierenden Liste)

insgesamt etwas schneller als der Heap Sort

FH-Hof

Teile und Beherrsche - Aufteilung mit Element

Wähle ein Element p für die Aufteilung aus

(Pivot-Element)

Erzeuge zwei Teillisten mit Hilfe von p:

Die erste Teilliste enthält alle Elemente kleiner

oder gleich p

Die zweite Teilliste enthält alle Elemente größer

als p

Sortiere danach die Teilliste und hänge das

Ergebnis zusammen

Bezeichnung: Quick Sort

FH-Hof

Quicksort - Sortieren innerhalb des Array

Parameter

Startpunkt: links

Endpunkt: rechts

1425 1627 4112. . . . . .

25Pivotelement:

12 2716 25

FH-Hof

Diskussion Quick Sort

Aufwand im durchschnittlichen Fall:

O(log(n)*n))

Aufwand im schlechtesten Fall: O(n2)

Vergleich mit Heap Sort und Merge Sort:

Kein zusätzlicher Speicher wird benötigt

Im durchschnittlichen Fall deutlich schneller als

die beiden anderen Verfahren

FH-Hof

Sortierung durch Fachverteilung

Sortiere die Elemente direkt in die Felder eines

Arrays ein (Für jeden Wert oder Wertbereich ein

Feld)

Aufwand ist linear!

Probleme:

Größe des Arrays?

Mehrere Werte in einem Feld?

Auslesen des Arrays?