Überblick 5.1 Sequentielles Suchen

Überblick 

5 Suchen und Sortieren 

5.1 Sequentielles Suchen 

5.2 Binäres Suchen 

5.3 Was ist Sortieren? Wie schwer ist es? 

5.4 Einige Typen von Sortieralgorithmen 

5.5 Einfache Sortieralgorithmen mit Zeitaufwand !(n 2 ) 

5.6 Eine untere Schranke "(n · log n) 

5.7 Quicksort 

5.8 Merge Sort 

5.9 Ist es möglich, in linearer Zeit zu sortieren? 

5.10 Sortiernetzwerke 

© Klaus Hinrichs Informatik II – Suchen und Sortieren 

5.1 Sequentielles Suchen 

• Gegeben: Menge von n Elementen, z.B. ganze Zahlen, 

abgespeichert in einem Array 

int[] a; // a.length = n 

• Problem: Ist ein vorgegebenes Element x im Array a enthalten? 

• Einfachste Lösung: 

Sequentielles (oder lineares) Durchsuchen des Arrays 

• Triviales Beispiel für einen inkrementellen Algorithmus, der jeweils 

ein Datenobjekt nach dem anderen bearbeitet. 

• Bei erfolgreicher Suche wird der Index i, 0 ! i < a.length, 

zurückgegeben, an dessen Position x steht. 

• i = –1 signalisiert erfolglose Suche. 


5-1 

5-2

Algorithmus für sequentielles Suchen 

• int find(int[] a, int x) { 

int i = a.length - 1; 

while ((i >= 0) && (x != a[i])) 

// Position (1) 

i--; 


return i; 

} 

• && (and mit SCE) wertet den booleschen Ausdruck von links nach 

rechts aus und bricht die Auswertung ab, sobald der Wert des 

booleschen Ausdrucks feststeht: 

Auswertung von (i >= 0) zu false verhindert, daß auf ein nicht 

existierendes Arrayelement (z.B. a[–1]) zugegriffen wird. 

• Invarianten bringen das für den Nachweis der formalen Korrektheit des 

Algorithmus Wesentliche zum Ausdruck, nämlich: 

In jeder Iteration der while-Schleife wird das Teilarray, von dem 

bekannt ist, daß es x nicht enthält, um ein Element vergrößert. 


Invarianten und formale Korrektheit 

• Folgende Invariante gilt an Position (1): 

(I) (0 ! i < a.length) ! (" k, i ! k: a[k] " x) 

Invariante (I) gilt trivialerweise beim ersten Durchlauf der while- 

Schleife und bleibt wahr in jedem nachfolgenden Durchlauf. 

• Folgende Bedingung gilt an Position (2): 

(II) (" k, i < k: a[k] " x) ! 

((i = –1) # ((0 ! i < a.length) ! (a[i] = x))) 

Bedingung (II) besagt, daß der Algorithmus auf zwei Arten terminiert: 

– i = –1 signalisiert, daß das ganze Array erfolglos durchsucht wurde. 

– x wurde an der Arrayposition i gefunden. 

• Formaler Korrektheitsbeweis muß zeigen, daß die Schleife wirklich 

terminiert: 

– i wird mit einem ganzzahligen Wert " 0 initialisiert. 

– i wird in jedem Schleifendurchlauf um 1 erniedrigt, muß also nach 

einer endlichen Anzahl von Durchläufen negativ werden. 


5-3 

5-4

Einsatz eines Platzhalters 

• Boolescher Ausdruck zur Kontrolle der while-Schleife enthält zwei 

Bedingungen: (i >= 0) und (x != a[i]) 

• Erster Term ist verzichtbar, falls sichergestellt ist, daß x immer gefunden 

wird, bevor der Suchindex i das Array a verläßt, d.h. i < 0 wird. 

• Idee: Erweitere das Array um eine Zelle und speichere die eigentlichen 

n Elemente an den Positionen 1, 2, …, n. Benutze a[0] beim Suchprozess, 

indem das zu suchende Element x als Platzhalter (sentinel) 

zu Beginn des Suchprozesses in a[0] gespeichert wird $ 

Suchprozess stoppt spätestens bei a[0] $ 

i > 0 % erfolgreiche Suche i = 0 % erfolglose Suche 

• int find(int[] a, int x) { 


a[0] = x; 

while (x != a[i]) 

i--; 

return i; 

} 


Aufwand für sequentielles Suchen 

• Annahme: n Elemente im Array gespeichert 

• Schlimmster Fall tritt ein bei erfolgloser Suche: 

Gesamtes Array wird durchlaufen $ Zeitaufwand T(n) # !(n) 

• Erfolgreiche Suche: 

Annahme: Alle im Array enthaltenen Elemente besitzen gleiche 

Wahrscheinlichkeit, daß nach ihnen gesucht wird $ 

durchschnittliche Anzahl Iterationen der while-Schleife bei 

erfolgreicher Suche = 

1 !(1 + 2 +…+ n) = n +1 

n 2 

• Sequentielles Suchen benötigt !(n) Zeit sowohl im schlimmsten als 

auch im durchschnittlichen Fall. 


5-5 

5-6

Suchen für beliebige Objekttypen 

• Falls Datenobjekte vom Typ Element sind, so sollte die Klasse 

Element die Methode public boolean equals(Object obj) 

bereitstellen, die true zurückgibt, falls das aufrufende Objekt und 

das übergebene Objekt gleich sind im Sinne der Anwendung: 

class Element { 

... 

public boolean equals(Object obj) { ... } 

... 

} 

• Stellt die Klasse Element die Methode equals nicht bereit, so wird 

die entsprechende Methode der Klasse Object verwendet, die 

true zurückgibt, falls beide Objektreferenzen gleich sind! 

• Sequentieller Suchalgorithmus: 

int find(Object[] a, Object x) { 


while ((i >= 0) && (! x.equals(a[i]))) 

i--; 

return i; 

} 


5.2 Binäres Suchen 

• Im Array a abgespeicherte Datenelemente seien geordnet bezüglich 

einer dem Wertebereich der Datenelemente zugrunde liegenden 

Ordnungsrelation !: 

" k, 0 ! k < n–1: a[k] ! a[k + 1] 

• Suche kann beschleunigt werden, da ein Vergleich des Suchelementes 

x mit einem Arrayelement mehr Information gibt als im 

ungeordneten Fall: 

x " a[m] schließt nicht nur a[m], sondern auch alle Elemente zur 

einen oder anderen Seite von m aus: 

– x < a[m] $ " i # m: a[i] " x 

– x > a[m] $ " i ! m: a[i] " x 

a[m] < x 

m 

Falls 

kann x nicht enthalten sein in 


a[m] > x 

m 

5-7 

5-8

Algorithmus für binäres Suchen 

int find(int[] a, int x) { 

int i = 0; 

int j = a.length - 1; 

while (i a[m]) 

i = m + 1 

else // x = a[m] 


return m; 

} 


return -1; 

} 


Invarianten, formale Korrektheit 

• Folgende Invariante gilt an Position (1): 

(I) (i ! j) ! (" k, 0 ! k < i: a[k] < x) 

! (" k, j < k < a.length: a[k] > x) 

• Invariante (I) gilt trivialerweise beim ersten Durchlauf der while-Schleife 

und bleibt wahr in jedem nachfolgenden Durchlauf. 


(II) a[m] = x 


(III) (i = j + 1) ! (" k, 0 ! k < i: a[k] < x) 

! (" k, j < k < a.length: a[k] > x) 

• i = j + 1 $ Unsicherheitsintervall ist leer! 

• In jedem Schleifendurchlauf wird i erhöht oder j erniedrigt $ nach 

endlich vielen Schleifendurchläufen wird i > j $ Algorithmus terminiert. 


5-9 

5-10

Zeitaufwand 

• Algorithmus funktioniert für jede Wahl von m mit i ! m ! j, ist aber am 

effizientesten für m = (i + j) / 2. 

• Zeitaufwand im schlimmsten Fall: 

&log 2 n' Schleifendurchläufe, d.h. T(n) # !(log n). 


Beispiel Interface für Comparable 

Binäres Suchen 

• Falls Datenobjekte vom Typ Element int sind, find(int[] so sollte die a, Klasse int x) { 

int i = 0; 

Element das 

int j = a.length - 1; 

interface Comparable while (i a[m]) 

x.compareTo(o) 

i = m + 1 

3 gibt 4 für 6x < 7o eine 16 negative 23 25 int, 29 für x = o den Wert else 0 und // x = a[m] 

für x > o eine positive int zurück. 

return m; 

} 

class Element implements Comparable{ 

return -1; 

i ... m i m ixi iim m j 

j } 

public int compareTo(Element o) { ... } 

int[] a = {3,4,6,7,16,23,25,29}; 

... 

int xi = find(a, 25); 

} 


5-11 

5-12

Binäres Suchen für beliebige Objekttypen 

int find(Comparable[] a, Comparable x) { 

int i = 0; 

int j = a.length – 1; 

while (i 0) 

i = m + 1 

else // comp = 0 

return m; 

} 

return –1; 

} 


5.3 Was ist Sortieren? Wie schwer ist es? 

• Motivation: Binäres Suchen in geordneten Mengen ist sehr viel schneller 

als sequentielles Suchen in ungeordneten Mengen. Sortieren ist neben 

Suchen eine der am häufigsten ausgeführten Operationen. 

• Gegeben sei eine Folge S von n Elementen x 1 , x 2 , … , x n , die einem 

Wertebereich X entstammen, auf dem eine totale Ordnung ! definiert ist, 

d.h. eine Relation, die die folgenden Axiome erfüllt: 

! ist reflexiv: " x ( X: x ! x 

! ist antisymmetrisch: " x, y ( X: x ! y ! y ! x $ x = y 

! ist transitiv: " x, y, z ( X: x ! y ! y ! z $ x ! z 

! ist total: " x, y ( X $ x ! y # y ! x 

• Sortieren ist ein Prozess, durch den eine Folge x i1 , x i2 , … , x in erzeugt 

wird, so daß (i 1 , i 2 , … , i n ) eine Permutation der ganzen Zahlen von 1 bis 

n ist und folgende Eigenschaft gilt: 

" k, 1 ! k ! n–1: x ik ! x ik+1 


5-13 

5-14

Sortieren = Finden einer Permutation 

• Beispiel: 

Sortierung der Folge 

x 1 = 9, x 2 = 4, x 3 = 13, x 4 = 2, x 5 = 21, x 6 = 15, x 7 = 2, x 8 = 5, x 9 = 11 

erzeugt die Folge 

x 4 = 2, x 7 = 2, x 2 = 4, x 8 = 5, x 1 = 9, x 9 = 11, x 3 = 13, x 6 = 15, x 5 = 21 

die durch die Permutation 

(4, 7, 2, 8, 1, 9, 3, 6, 5) 

der Ausgangsfolge festgelegt wird. 

• Abstrakte Formulierung: 

Sortieren besteht im Auffinden einer spezifischen Permutation (oder 

einer unter einigen wenigen Permutationen, wenn Elemente gleiche 

Werte haben dürfen) aus n! möglichen Permutationen der n gegebenen 

Elemente. 


Randbedingungen 

• Menge S der zu sortierenden Elemente gegeben in einer Datenstruktur, 

die S implizit ordnet, aber nicht notwendigerweise bzgl. der gewünschten 

Ordnung !. 

• Typische Sortierprobleme: 

S gegeben in 

– Array mit direktem Zugriff auf jedes Element 

(z.B. a[i] im Array a) oder 

– sequentieller Datei (z.B. Magnetband) mit sequentiellem Zugriff (z.B. 

durch Zeiger auf gegenwärtige Position). 

Generierung des Resultats in der gleichen Datenstruktur. 

Zugriffsoperationen der zugrunde liegenden Datenstruktur bestimmen, 

welche Sortieralgorithmen möglich sind. 


5-15 

5-16

Eigenschaften von Sortieralgorithmen 

• Ein Sortieralgorithmus sortiert in place, falls während seines Ablaufs 

zu jedem Zeitpunkt höchstens eine konstante Anzahl zu sortierender 

Elemente außerhalb der Datenstruktur gespeichert wird. 

• Ein Sortieralgorithmus heißt stabil, falls nach der Sortierung die 

ursprüngliche Anordnung gleicher Elemente erhalten bleibt: 

8, 6', 2', 1, 6", 2", 9 % 1, 2', 2", 6', 6", 8, 9 ist stabil 

8, 6', 2', 1, 6", 2", 9 % 1, 2", 2', 6', 6", 8, 9 ist nicht stabil 


Sortieralgorithmen 

• Die meisten Sortieralgorithmen sind Verfeinerungen der folgenden Idee: 

) while (* (i, j): i < j ! a[i] > a[j]) a[i] :=: a[j]; 

:=: bezeichnet den Austauschoperator! 

• Zwei Typen von Operationen sind zum Sortieren notwendig: 

– Sammeln von Information über die Ordnung der gegebenen Elemente 

– Ordnen der Elemente, z.B. durch Vertauschen zweier Elemente 

• Ziel bei der Entwicklung eines effizienten Sortieralgorithmus: 

Minimierung der Anzahl Operationen beider Typen $ 

– Vermeide, redundante Informationen zu sammeln! 

– Versuche, Elemente so selten wie möglich zu bewegen! 


5-17 

5-18

Nicht-deterministische Algorithmen 

• Beispiel: 

Nicht-deterministischer Algorithmus ) erlaubt beim Sortieren von 

x 1 = 5, x 2 = 2, x 3 = 3, x 4 = 4, x 5 = 1 (+) 

eine der folgenden 7 Austauschoperationen: 

x 1 :=: x i für 2 ! i ! 5 und x j :=: x 5 für 2 ! j ! 4 

Zustand (+) könnte entstanden sein durch exotische Strategie, die von 

der Mitte zu den beiden Enden sortiert, und es könnte bekannt sein, 

daß eine einzige Austauschoperation x 1 :=: x 5 den Sortierprozeß 

abschließen würde. Der nicht-deterministische Algorithmus ) bietet 

jedoch keine Möglichkeit, dieses Wissen auszudrücken und zu nutzen. 

$ Kein Nicht-Determinismus! 

Zu entwickelnde Kontrollstruktur muß sorgfältig die Reihenfolge der 

auszuführenden Operationen festlegen, um die bereits gesammelten 

Informationen möglichst optimal zu nutzen! 


Intrinsische Komplexität 

• Grenzen der Optimierung: 

Ohne irgendwelche bereits vorhandene Informationen muß jedes Element 

mindestens einmal inspiziert und i. a. mindestens einmal bewegt 

werden $ mindestens "(n) primitive Operationen sind notwendig. 

• Sammeln von Informationen nur durch Beantworten binärer Fragen 

(z.B. ja/nein Fragen, Vergleich zweier Elemente mit Antwort ! oder >) $ 

mindestens n · log 2 n Fragen sind notwendig (siehe Abschnitt 5.6) $ 

"(n · log n) ist untere Schranke in diesem Berechenbarkeitsmodell. 

• Umordnen von Elementen: durchschnittlicher Abstand eines Elementes 

von seiner korrekten Position $ n / 3 (siehe Abschnitt 4.7). 

Transfer eines Elementes kann z.B. durch 1 Schritt der Länge n / 3 

oder n / 3 Schritte der Länge 1 erfolgen. 

Umordnung nur durch Austausch benachbarter Elemente $ 

durchschnittlich !(n 2 ) Austauschoperationen sind nötig $ 

Kurze Schritte nicht ausreichend für effizienten O(n · log n) Algorithmus! 


5-19 

5-20

Praktische Aspekte 

• Objekte statt Elemente 

Unsere Annahme: Zu sortierende Elemente entstammen einem total 

geordneten Wertebereich. 

In der Praxis wird die Ordnung der Elemente häufig 

– direkt durch Schlüssel bestimmt, die Bestandteil der zu sortierenden 

komplexen Datenobjekte sind, die neben dem Schlüssel noch 

weitere Daten umfassen, z.B. Konten mit Schlüssel Kontonummer. 

– indirekt aus den Eigenschaften der Objekte abgeleitet, z.B. 

Rechtecke, die durch ihre Seitenlängen gegeben sind und nach 

ihrem Flächeninhalt geordnet werden. 

• Vergleichsoperatoren =,

Insertion Sort und Selection Sort 

• Hauptunterschied zwischen Insertion Sort und Selection Sort: In 

welcher der beiden Mengen wird die meiste Arbeit während des 

Sortierens verrichtet? 

• Insertion Sort: 

Entferne das erste (oder am leichtesten zugreifbare) Element aus 

UNSORTED und durchsuche SORTED, um seine korrekte Position zu 

finden. 

• Selection Sort: 

Durchsuche UNSORTED, um das nächste an SORTED anzuhängende 

Element zu finden. 


Beispiel für Insertion Sort 

Initialisierung: SORTED = (); 

UNSORTED = (25, 23, 3, 16, 4, 7, 29, 6); 

i 

1 

2 

i = 12 

34 

56 

78 

3 

4 

5 

6 

7 

8 

SORTED 

(25) 

(23, 25) 

(3, 16, 4, 7, 29, 6) 

23 25 3 23 25 16 23 4 23 25 16 37 6 25 16 23 16 7 23 16 25 4 25 23 7 29 25 29 6 

(3, 23, 25) 

(16, 4, 7, 29, 6) 

(3, 16, 23, 25) 

sortiert sortiert sortiert sortiert sortiert sortiert sortiert unsortiert unsortiert 

(3, 4, 16, 23, 25) 

(3, 4, 7, 16, 23, 25) 

(3, 4, 7, 16, 23, 25, 29) 

(3, 4, 6, 7, 16, 23, 25, 29) 


UNSORTED 

(23, 3, 16, 4, 7, 29, 6) 

(4, 7, 29, 6) 

(7, 29, 6) 

(29, 6) 

(6) 

() 

5-23 

5-24

Beispiel für Selection Sort 

Initialisierung: SORTED = (); 

UNSORTED = (25, 23, 3, 16, 4, 7, 29, 6); 

i 

1 

2 

(3, 4) 

(25, 23, 16, 7, 29, 6) 

i i i = = = 23 

74 51 6 

3 

25 3 23 4 25 36 (3, 4, 6) 

16 7 23 16 4 16 23 7 29 25 29 25 6 

(25, 23, 16, 7, 29) 

4 

5 

6 

7 

8 

SORTED 

(3) 

(3, 4, 6, 7) 

sortiert sortiert sortiert sortiert sortiert sortiert sortiert unsortiert 

(3, 4, 6, 7, 16) 

(3, 4, 6, 7, 16, 23) 

(3, 4, 6, 7, 16, 23, 25) 

(3, 4, 6, 7, 16, 23, 25, 29) 


Insertion Sort und Selection Sort 


UNSORTED 

(25, 23, 16, 4, 7, 29, 6) 

(25, 23, 16, 29) 

(25, 23, 29) 

(25, 29) 

(29) 

• SORTED und UNSORTED teilen sich ein Array, die Grenze zwischen 

beiden wird durch einen Index i festgelegt, der mit steigender Anzahl 

sortierter Elemente zunimmt. 

• Insertion Sort: Füge im i-ten Schritt das i-te Element in die Folge der 

ersten (i–1) Elemente ein. 

1 2 ? i–1 i n 

… ! x ! … x … 

sortiert unsortiert 

• Selection Sort: Selektiere im i-ten Schritt das kleinste unter den n – i + 1 

noch nicht sortierten Elementen und bewege es an die i-te Position. 

1 2 i n 

… ! x 

x = minimum(a[i], …, a[n]) 


• Insertion Sort und Selection Sort erfordern wahlfreien Zugriff auf die 

Elemente, daher werden beide Verfahren für das interne Sortieren 

im Hauptspeicher verwendet. 

() 

5-25 

5-26

Merge Sort 

• Merge Sort (Sortieren durch Mischen) verarbeitet (Teil-) Folgen von 

Elementen sequentiell $ 

Merge Sort ist sehr gut geeignet für externes Sortieren auf 

Sekundärspeichermedien, die nur sequentiellen Zugriff effizient 

unterstützen (z.B. Festplatten) oder erlauben (z.B. Magnetbänder). 

• Merge Sort ist auch gut geeignet für internes Sortieren. 

• Idee: Verschmelze zwei sortierte Folgen von Elementen, genannt 

Läufe (runs), in eine längere sortierte Folge: Lese von jedem der 

beiden Läufe das jeweils nächste Element, vergleiche die beiden 

Elemente miteinander und hänge das kleinere der beiden Elemente 

an die Ausgabefolge. 

… 

… 

9 7 4 

6 3 2 


Externer Merge Sort 

A 2 1 

B 4 3 Prozessor 

8 

7 

1&3 

2&4 Prozessor 

6 4 

• Prozessor liest zwei Magnetbänder (oder sequentielle Dateien) A und B. 

– A enthält Läufe 1 und 2, B Läufe 3 und 4. 

– Prozessor verschmilzt Läufe 1 und 3 in einen einzigen Lauf 1&3 auf 

Band C und Läufe 2 und 4 in einen einzigen Lauf 2&4 auf Band D. 

– In einem zweiten Merge-Schritt werden Läufe 1&3 und 2&4 in einen 

einzigen Lauf 1&3&2&4, d.h. in eine sortierte Folge, verschmolzen. 


3 

2 

1&3&2&4 

5-27 

5-28

Radix Sort … 

• Radix Sort 

(Sortieren durch Verteilen, Distribution Sort) 

– beruht nicht auf Vergleich und Vertauschung von Elementen, 

sondern auf deren Darstellung in einem Stellenwertsystem 

(z.B. Dezimalsystem). 

– benutzt primitive arithmetische Operationen wie 

"extrahiere die k-te Ziffer". 

• Beispiel: 

3-ziffrige Zahlen im Zahlensystem zur Basis 4 

301 023 230 322 100 321 213 

– Verteile zu sortierende Zahlen auf 4 Folgen gemäß ihrer rechten 

Ziffer und hänge die so entstehenden Folgen aneinander. 

– Wiederhole diesen Prozess für die mittlere und dann für die linke 

Ziffer. 


… Radix Sort 

zu sortierende Folge: 301 023 230 322 100 321 213 

301 023 230 322 100 321 213 

verteile 

verteile bezüglich 

bezüglich der rechten 100 321 

213 

der rechten Ziffer 100 230 321 301 322 213 023 

Ziffer 0 

230 

301 1 2 3 

322 023 

0 1 2 3 


230 100 301 321 322 023 213 

verteile 

bezüglich 

verteile der mittleren 

bezüglich Ziffer 

301 

100 213 023 

023 

322 

321 230 

der 

0 1 2 

301 

322 

mittleren 

100 

213 

321 230 

Ziffer 


0 100 301 1 213 321 322 2 023 230 3 

3 

verteile verteile 

bezüglich 

bezüglich 

der linken 

der linkenZiffer 

Ziffer 023 

023 

0 100 

100 

1 

230 

213 

230 

213 

2 

322 

321 

301 

322 

321 

301 

3 

sortierte Folge: 

023 100 213 230 301 321 322 

0 1 2 3 


5-29 

5-30

5.5 Einfache Sortieralgorithmen mit Zeitaufwand !(n 2 ) 

• Array von n Elementen, z.B. ganze Zahlen: 

int[] a; // a.length = n 

Sortiere die Elemente von a in aufsteigender Reihenfolge. 

In place Algorithmen benutzen bei der Sortierung neben dem Array a 

höchstens O(1) weiteren Speicherplatz. 


void insertionSort(int[] a) { 

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

int tmp = a[i]; 

int j = i - 1; 

while ((j >= 0) && (tmp < a[j])) { 

} 

} 

a[j + 1] = a[j]; 

j = j - 1; 

} 

a[j + 1] = tmp; 

• Insertion Sort ist stabil! 

Austausch 


Insertion Sort 


0 1 j i n–1 

… … 


• v best , v average , v worst bezeichne die Anzahl Vergleichsoperationen in der 

Bedingung der while-Schleife, a best , a average , a worst die Anzahl Durchläufe 

des Rumpfes der while-Schleife, d.h. die Anzahl Austauschoperationen, 

im besten, durchschnittlichen und schlimmsten Fall. 

v best = n !1 

v = inv + (n !1) = average average n2 + 3 "n ! 4 

4 

v worst = i 

n!1 

# = 

i=1 

n2 ! n 

2 

a best = 0 

5-31 

a = inv = average average n2 ! n 

4 

a worst = i 

n!1 

" = 

i=1 

n2 ! n 

2 

• inv average bezeichnet die durchschnittliche Anzahl Inversionen in einer 

Permutation (siehe Abschnitt 4.7) 

• Insertion Sort ist im besten Fall ein !(n) Algorithmus, im 

durchschnittlichen und schlimmsten Fall ein !(n 2 ) Algorithmus. 

• Binäres Suchen der korrekten Einfügeposition von a[i] im bereits 

sortierten Teil würde die Zeitkomplexität nicht verbessern! 

5-32

Interface Comparable 

• Falls Datenobjekte vom Typ Element sind, so sollte die Klasse 

Element das 

interface Comparable 

aus java.lang implementieren, das die Methode 

public int compareTo(T o); 

enthält. Der Aufruf 

x.compareTo(o) 

gibt für x < o eine negative int, x = o den Wert 0 und für x > o eine 

positive int zurück. 

class Element implements Comparable{ 

... 

public int compareTo(Element o) { 

... 

} 

... 

} 


Insertion Sort für beliebige Objekttypen 

public static 

void insertionSort(T[] a) { 

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

T tmp = a[i]; 

int j = i – 1; 

while ((j >= 0) && 

(tmp.compareTo(a[j]) < 0)) { 

a[j + 1] = a[j]; 

j = j – 1; 

} 

a[j + 1] = tmp; 

} 

} 


5-33 

5-34

Selection Sort … 

void selectionSort(int[] a) { 

for (int i = 0; i < a.length - 1; i++) { 

int minindex = i; 

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

if (a[j] < a[minindex]) 

minindex = j; 

swap(a, i, minindex); 

} 

} 

void swap(int[] a, int i, int j) { 

int tmp = a[i]; 

minindex 

a[i] = a[j]; 

0 i j 

n–1 

a[j] = tmp; 

} 

… 

sortiert 

… … 

unsortiert 

• Obige in place Implementierung von Selection Sort ist nicht stabil! 


… Selection Sort 

• Die von Selection Sort zu verrichtende Arbeit ist immer gleich, es gibt 

keinen besten, durchschnittlichen oder schlimmsten Fall. 

Sei v die Anzahl Vergleiche von Elementen, a die Anzahl 

Austauschoperationen. 

n!2 

" 

v = (n !1 

i=0 

a = n !1 

! i) = n2 ! n 

2 

• Selection Sort benötigt immer einen Zeitaufwand von !(n 2 ). 


5-35 

5-36

5.6 Eine untere Schranke "(n · log n) 

• Zweiwertige binäre Fragen: Antwort ja / nein, true / false 

• Häufige Art einer zweiwertigen Frage: x ! y ? 

• Satz: 

Jeder Sortieralgorithmus, der die Information über die Anordnung der 

Elemente nur über zweiwertige Fragen und nichts anderem bezieht, 

benötigt im Durchschnitt (d.h. im Mittel über alle n! Permutationen) und 

somit auch im schlimmsten Fall mindestens n · log 2 (n + 1) – n / ln 2 

Vergleiche. Somit ist die Zeitkomplexität eines solchen Algorithmus im 

durchschnittlichen und im schlimmsten Fall "(n · log n). 

Beweis: 

Darstellung eines solchen Sortieralgorithmus durch einen binären 

Entscheidungsbaum: 

– Interner Knoten repräsentiert binäre Frage. 

– Blatt entspricht einem möglichen Resultat des 

Entscheidungsprozesses. 


… Eine untere Schranke "(n · log n) … 

• Fortsetzung Beweis: 

Entscheidungsbaum muß jede der möglichen n! Permutationen der 

Eingabedaten von jeder anderen unterscheiden $ 

Entscheidungsbaum hat mindestens n! Blätter, mindestens eines für 

jede Permutation! 

Beispiel: 

Sortierung von drei Elementen x, y und z durch Vergleiche zwischen 

jeweils zwei Elementen 

x ! y ? 

yes no 

y ! z ? y ! z ? 

yes no 

yes no 

x ! y ! z 

x ! z ? x ! z ? 

yes no yes no 

x ! z < y z < x ! y y < x ! z y ! z < x 


z < y < x 

5-37 

5-38



Durchschnittliche Anzahl binärer Fragen, 

die ein gegebener Sortieralgorithmus benötigt 

= durchschnittliche Tiefe der Blätter des Entscheidungsbaums 

n " % 

log n! = log i 

2 2 ! 

# 

$ 

& 

' = log2 i 

Lemma (siehe nächste Folie) $ durchschnittliche Tiefe # log2 n! 

n 

( 

i=1 


i=1 

) (n +1)* log (n +1) + 2 n 

ln 2 + log (n +1) 

2 

= n * log 2 (n +1) + n 

ln 2 

Im Durchschnitt werden also mindestens n · log 2 (n + 1) – n / ln 2 

binäre Fragen benötigt, d.h. die Zeitkomplexität eines solchen 

Sortieralgorithmus beträgt "(n · log n) im durchschnittlichen und 

daher auch im schlimmsten Fall. 


• Lemma: 

In einem binären Baum mit k Blättern beträgt die durchschnittliche 

Tiefe der Blätter mindestens log 2 k. 

Beweis: 

durch Widerspruch! 

Annahme: Die Behauptung trifft nicht zu! 

Der binäre Baum T sei das Gegenbeispiel mit der kleinsten Anzahl 

Knoten. 

Fall I: 

T = 


w 

T besteht aus einem einzigen Knoten $ 

die Tiefe dieses einzigen Blattes ist 0, die durchschnittliche Tiefe ist 

also mindestens log 2 1 = 0 $ 

Behauptung trifft auf T zu $ 

T kann nicht nur aus einem einzigen Knoten bestehen. 

5-39 

5-40


• Fortsetzung Beweis: w 

Fall II: 

Fall III: 

T = 

T = 


T' 

Wurzel w von T hat nur ein Kind $ 

T' enthält weniger Knoten, aber alle k Blätter von T, die in T' eine 

geringere durchschnittliche Tiefe haben als in T $ 

T' ist Gegenbeispiel mit geringerer Anzahl Knoten als T $ 

Widerspruch zur Wahl von T $ 

Wurzel w von T kann nicht nur ein Kind haben. 

T L 

w 

Wurzel w von T hat zwei Kinder: k L > 0 Blätter im linken Teilbaum T L , 

k R > 0 Blätter im rechten Teilbaum T R mit k = k L + k R 

… Eine untere Schranke "(n · log n) 


T Gegenbeispiel mit kleinster Anzahl Knoten $ 

k L Blätter von T L 

k L 

log 2 k L 

T R 

haben durchschnittliche Tiefe 

von mindestens 

! log k + ! log k +1 (") 

2 L 2 R k + k k + k L R 

L R 


k R 

k R Blätter von T R 

log 2 k R 

$ die durchschnittliche Tiefe der k Blätter von T beträgt mindestens 

(+) nimmt minimalen Wert log 2 k für k L = k R = k / 2 an 

$ durchschnittliche Tiefe der k Blätter von T beträgt mindestens log 2 k 

$ Widerspruch zur Wahl von T als Gegenbeispiel! 

Fall I, II, III $ Behauptung des Lemmas! 

5-41 

5-42

5.7 Quicksort 

• C. A. R. Hoare: Quicksort, Computer Journal 5(1), 10 – 15 (1962). 

• Quicksort kombiniert divide & conquer mit einer effizienten Strategie, 

die Elemente mit nur wenigen Austauschoperationen zu bewegen. 

• divide: 

– Partitioniere das Array in zwei disjunkte Teile, die "kleinen" Elemente 

auf der linken Seite und die "großen" Elemente auf der rechten Seite. 

conquer: 

– Sortiere jedes der zwei Teilarrays rekursiv. 

combine: 

– Keine Arbeit notwendig, um die beiden Teillösungen zu einer Lösung 

des Gesamtproblems zu kombinieren. 

kleine Elemente große Elemente 


… Quicksort … 

… … 

• Effizienz von Quicksort hängt entscheidend davon ab, daß die in 

der divide-Phase entstehenden Teilarrays sich in der Größe nicht 

allzu stark unterscheiden! 

• Wähle einen Schwellenwert m $ 

Definiere klein als ! m, groß als # m 

kleine Elemente 

! m 

… … 

große Elemente 

# m 


5-43 

5-44


• Partitioniere ein zu sortierendes Teilarray a[L .. R] durch einen 

links-nach-rechts Durchlauf L-R (durch Inkrementierung eines Index i ) 

und einen gleichzeitigen rechts-nach-links Durchlauf R-L (durch 

Dekrementierung eines Index j ). 

L i j 

R 

… … 

… 

! m # m 

• L-R stoppt, sobald das erste Element mit a[ i ] " m angetroffen wird. 

• R-L stoppt, sobald das erste Element mit a[ j ] ! m angetroffen wird. 

• Nach Stop beider Durchläufe $ 

a[ i ] :=: a[ j ] (Austausch) und setze die Durchläufe fort. 

• j 

• Rufe Quicksort rekursiv auf für 

! a[L .. j ] falls j > L 

" 

# a[ i .. R] falls i < R 



• •zu Beispiel: sortierende Folge: (25, 23, 3, 16, 4, 7, 29, 6) 

Partitionierung Partitionierung mit mit m m = = 16 16 

25 23 3 16 4 7 29 6 

i j 

6 23 25 36 23 716 

34 16 4 7 16 4 29 23 7 25 29 25 6 

i j 

6 7 3 

i 

16 

i i 

4 

ij 

23 

ij 

29 

j 

25 

j 

i j 

6 7 3 4 16 23 29 25 

j i 


j 

5-45 

5-46


• Wahl des Schwellenwertes muß die Korrektheit und die Effizienz von 

Quicksort sicherstellen! 

• Korrektheit: 

{x i : x i ! m} = $ oder {x j : x j " m} = $ $ Quicksort terminiert nicht! $ 

Forderung: min(x i ) ! m ! max(x i ) 

• Effizienz: m sollte nahe am Median liegen! 

• Der Median einer Menge von n Elementen ist das Element m, so daß 

gleich viele (bis auf eins) Elemente links und rechts von m liegen. 

• Wie findet man den Median von n Elementen? 

• Der exakte Median kann im schlimmsten Fall in O(n) Zeit bestimmt 

werden: 

M. Blum, R. W. Floyd, V. R. Pratt, R. L. Rivest, R. E. Tarjan: 

Time bounds for selection, 

Journal of Computer and System Sciences 7(4), 448 – 461 (1972). 



• Bei Verwendung des exakten Medians werden die zu sortierenden 

Elemente in zwei gleich große Teilmengen aufgeteilt $ 

Zeitaufwand T(n) von Quicksort beträgt 

( ) 

T(n) = 2 !T 

und man erhält 

T(n) = a · n · log2 n + (T(1) + b) · n – b 

n + a !n + b 

2 

d.h. vom theoretischen Standpunkt aus betrachtet benötigt Quicksort 

selbst im schlimmsten Fall nur !(n·log n) Zeit. 

• Aber: Die multiplikative Konstante des Algorithmus zum Auffinden 

des Medians ist sehr groß $ a ist sehr groß $ Quicksort ist in der 

Praxis nicht sehr effizient, falls der exakte Median benutzt wird! 

Es lohnt sich nicht, den hohen Aufwand zum Auffinden des exakten 

Medians zu treiben! 


5-47 

5-48

… Quicksort 

• Techniken zur Bestimmung eines vermuteten Medians, der eine 

akzeptable Approximation liefert: 

– Ein Arrayelement in fixer Position, z.B. a[(L + R) / 2]. 

Vorsicht: Benutze kein Element nahe a[L] oder a[R], da dies zu 

Ineffizienz im Falle von partiell sortierten Elementen führt. 

– Ein Arrayelement in zufällig gewählter Position $ gibt gute 

Resultate! 

– Den Median von drei oder fünf Elementen an fixen oder zufällig 

gewählten Positionen. 

– Den Mittelwert des kleinsten und größten Elementes $ erfordert 

zusätzlichen Durchlauf zu Beginn, danach kann der Mittelwert für 

jedes Teilarray während des vorherigen Aufteilungsprozesses 

bestimmt werden. 


Quicksort: Rekursive Implementierung 

void quicksort(int[] a, int L, int R) { 

int m = a[(L + R) / 2]; 

// min(a[L], … , a[R]) ! m ! max(a[L], … , a[R]) 

int i = L; 

int j = R; 

while (i

Implementierung von Quicksort 

• Initialer Aufruf: 

quicksort(a, 0, a.length - 1); 

mit a.length > 1 garantiert, daß L < R in jedem rekursiven Aufruf 

von quicksort gilt! 

• Quicksort ist ein in place Algorithmus! 

• Quicksort ist nicht stabil! 

• Für sehr kleine Arrays (n ! 20) ist Quicksort nicht so effizient wie 

Insertion Sort. 

Quicksort rekursiv $ 

Quicksort wird sehr häufig für kleine Arrays aufgerufen! 

In der Praxis: Modifikation von Quicksort, so daß für kleine Teilarrays 

Insertion Sort aufgerufen wird! 


Analyse von Quicksort … 

• T(n) sei der von Quicksort benötigte Zeitaufwand $ 

T(n) = T(k) + T(n – k) + a · n + b (+) 

wenn das Array aufgeteilt wird in ein Teilarray mit k Elementen und 

ein Teilarray mit n – k Elementen. 

– Konstante b: Kosten für den Aufruf von Quicksort für das zu 

sortierende Array. 

– a · n: Kosten für die Partitionierung. 

– T(k) und T(n – k): Kosten der rekursiven Aufrufe für die beiden 

Teilarrays. 


5-51 

5-52

… Analyse von Quicksort … 

• Beispiel: Aufteilung mit m = 16 

25 13 3 16 22 18 29 6 

i j 

6 13 3 16 22 18 29 25 

i j 

6 13 3 16 22 18 29 25 

j i 

$ von Quicksort benötigter Zeitaufwand 

T(n) = T(k) + T(n – k – 1) + a · n + b 

Diese Rekurrenz hat gleiche asymptotische Lösung wie (+), daher 

Beschränkung auf (+). 

T(n) = T(k) + T(n – k) + a · n + b (+) 



• Verhalten im besten Fall: 

Partitionierung des Arrays in zwei gleich große Teilarrays $ 

Abschnitt 4.6 $ 

( ) 

T(n) = 2 !T n 

2 

+ a !n + b 

T(n) = a · n · log 2 n + (T(1) + b) · n – b 

= a · n · log 2 n + g(n) mit g(n) # O(n) 

$ Quicksort's Zeitkomplexität im besten Fall ist !(n · log n). 


5-53 

5-54


• Verhalten im schlimmsten Fall: 

Partitionierung des Arrays in ein Teilarray mit n – 1 Elementen und 

ein Teilarray mit einem Element $ 

T(n) = T(1) + T(n – 1) + a · n + b 

Substitution: 

T(n – 1) = T(1) + T(n – 2) + a · (n – 1) + b 

$ T(n) = 2 · T(1) + T(n – 2) + a · n + a · (n – 1) + 2 · b 

Wiederholte Substitution ergibt 

$ Quicksort's Zeitkomplexität im schlimmsten Fall ist !(n 2 T(n) = n !T(1) + a ! 

). 

n2 + n " 2 + b !(n "1) 

2 


… Analyse von Quicksort 

• Durchschnitt über alle n! Permutationen ist schwer zu ermitteln, 

daher Analyse des Verhaltens im typischen Fall, d.h. unter der 

Annahme: Für alle k, 1 ! k < n, ist die Wahrscheinlichkeit 1 / (n – 1), 

daß das Array aufgeteilt wird in Teilarrays der Größen k und n – k. 

• Verhalten im typischen Fall: 

Der im Durchschnitt von Quicksort benötigte Zeitaufwand wird 

beschrieben durch 

T(n) = 1 

n !1 

n!1 

" (T(k ) +T(n ! k )) + a # n + b = 2 

n !1 

k=1 

Lösung durch trial-and-error (Abschnitt 4.5): 

T(n) = (ln 4) · a · n · log 2 n + g(n) mit ln 4 # 1.386 und g(n) # O(n) 

$ Quicksort's asymptotisches Verhalten ist im typischen Fall nur etwa 

40% schlechter als im besten Fall 

$ Quicksort's Zeitkomplexität im typischen Fall ist !(n·log n). 


n!1 

" 

k=1 

T(k ) + a # n + b 

5-55 

5-56

5.8 Merge Sort 

• Bisher: 

Interne Sortieralgorithmen mit direktem Zugriff auf jedes Element! 

• Annahme bei der Algorithmenanalyse: Zugriff auf a[i] ist primitive 

Operation mit konstanten Kosten, d.h. unabhängig von i und n. 

• Annahme gilt nicht für Sekundärspeichermedien wie Festplatten oder 

Magnetbänder! 

• Externes Sortieren: 

Zu sortierende Elemente sind in einer sequentiellen Datei (File) 

gespeichert. 

– Zu jedem Zeitpunkt kann man über einen Zeiger nur auf genau ein 

Element zugreifen. 

– Zugriff auf andere Elemente erfordert Neupositionierung des 

Zeigers in der Datei. Zeiger kann nur in einer Richtung (vorwärts) 

oder in beide Richtungen (vorwärts und rückwärts) wandern. 


Externer Merge Sort … 

• Annahme: Zeit zur Repositionierung des Zeigers ist proportional zur 

zurückgelegten Distanz. 

• Annahme 

– begünstigt Algorithmen, die nur benachbarte Elemente verarbeiten 

(vergleichen, austauschen). 

– benachteiligt Algorithmen, die wahlfreien Zugriff auf die Elemente 

benötigen (z.B. Quicksort). 

• f k bezeichne das k-te Element, das in Datei f gespeichert ist. 

• Ein Lauf (Run) ist eine sortierte Teilfolge von Elementen f i , f i+1 , …, f j , 

die aufeinanderfolgend in Datei f gespeichert sind und für die 

f k ! f k+1 für alle k mit i ! k ! j – 1 gilt. 

• Verfügbarer Puffer im Hauptspeicher mit Kapazität m Elemente 


5-57 

5-58

… Externer Merge Sort … 

• Externer Sortieralgorithmus, basierend auf dem Prinzip des Merge Sort: 

– Initiale Phase: 

Erzeuge im Hauptspeicher initiale Läufe der Länge m (evtl. weniger 

Elemente im letzten Lauf) und speichere die Läufe in Datei f. 

– Kopierphase (Copy): 

Kopiere die Hälfte der Läufe von f in Datei g, die andere Hälfte in 

Datei h. 

– Verschmelzungsphase (Merge): 

Verschmelze jeden Lauf von g mit genau einem Lauf von h und 

schreibe den resultierenden Lauf nach f. 

– Wiederhole Kopier- und Verschmelzungsphase, bis f nur noch einen 

einzigen Lauf enthält. 


… Externer Merge Sort 

• Realisierung der initialen Phase: 

– Lese aus Eingabedatei e die m Elemente e r·m+1 , e r·m+2 , …, e r·m+m in 

den Puffer (r = 0, 1, …). 

– Sortiere die Elemente im Puffer mit einem internen Sortierverfahren 

(z.B. Quicksort). 

– Schreibe den so erzeugten r-ten Lauf in die Datei f, die den gleichen 

physischen Speicherbereich belegen kann wie die ursprüngliche 

Datei e. 

$ f ist partiell sortiert: " k, r · m + 1 ! k < r · m + m: f k ! f k+1 

• Jeder Copy-Merge-Zyklus halbiert die Anzahl Läufe: 

copy 

g: s/2 Läufe 

f: s Läufe f: s/2 Läufe 

h: s/2 Läufe 


merge 

Nach &log 2 (n/m)' Copy-Merge-Zyklen besteht f aus einem einzigen 

Lauf, der die sortierte Folge aller Elemente darstellt. 

5-59 

5-60

Interner Merge Sort … 

void mergeSort(int[] a, int L, int R) { 

int M = (L + R) / 2; 

if (L < M) 

mergeSort(a, L, M); 

if (M + 1 < R) 

mergeSort(a, M + 1, R); 

merge(a, L, M, R); 

} 


… Interner Merge Sort … 

void merge(int[] a, int L, int M, int R) { 

int[] b = new int[R–L+1]; 

int i = L; 

int j = M + 1; 

int k; 

for (k = L; k M) || ((j

… Interner Merge Sort … 

• Interner Merge Sort ist kein in place Algorithmus, da er ein 

zusätzliches Array benötigt. 

• Interner Merge Sort ist stabil! 

• Interner Merge Sort ist ein divide & conquer Algorithmus: 

7 

7 5 

5 7 

7 5 3 2 

5 

2 3 5 7 

7 5 3 2 1 8 6 4 

divide 

3 2 

divide 

divide 

1 2 3 4 5 6 7 8 

1 8 

1 8 6 4 


… Interner Merge Sort 

• Zeitaufwand 

( ) 

T(n) = 2 !T n 

2 

6 4 

3 2 1 8 6 4 

merge 

2 3 

1 8 4 6 

merge 

merge 

1 4 6 8 

+ a !n + b 

Abschnitt 4.6 $ 

T(n) = a · n · log 2 n + (T(1) + b) · n – b 

= a · n · log 2 n + g(n) mit g(n) # O(n) 

$ Zeitkomplexität von Merge Sort ist in jedem Fall !(n · log n). 


5-63 

5-64

5.9 Ist es möglich, in linearer Zeit zu sortieren? 

• Untere Schranke "(n · log n) gilt für Sortieralgorithmen, die Information 

über die Anordnung der Elemente nur über zweiwertige Fragen und 

nichts anderem beziehen! 

• Diese untere Schranke gilt nicht unbedingt für andere Situationen! 

• Beispiel 1: Sortieren einer Permutation 

Sortieren einer Permutation der ganzen Zahlen von 1 bis n in !(n) Zeit 

durch Speichern des Elementes i im Arrayelement mit Index i – 1. 

• Beispiel 2: Counting Sort 

Annahme: Jedes der n zu sortierenden Elemente ist eine ganze Zahl 

zwischen 0 und k – 1. 

Idee: Bestimme für jedes Element x die Anzahl der Elemente ! x $ 

Jedes Element kann direkt an seine korrekte Position im Ausgabearray 

gebracht werden. 


Counting Sort … 

void countingSort(int[] a, int k) { 

int[] b = new int[a.length]; 

int[] c = new int[k]; 

int i; 

for (i = 0; i < k; i++) 

c[i] = 0; 

for (i = 0; i < a.length; i++) 

c[a[i]] = c[a[i]] + 1; 

// c[i] enthält jetzt die Anzahl Elemente = i 

for (i = 1; i < k; i++) 

c[i] = c[i] + c[i - 1]; 

// c[i] enthält jetzt die Anzahl Elemente ! i 

for (i = a.length - 1; i >= 0; i--) { 

b[c[a[i]] - 1] = a[i]; 

c[a[i]] = c[a[i]] - 1; 

} 

for (i = 0; i < a.length; i++) 

a[i] = b[i]; 

} 


5-65 

5-66

… Counting Sort 

• Counting Sort ist kein in place Algorithmus. 

• Counting Sort ist stabil! 

• Zeitkomplexität von Counting Sort ist !(n + k). 

• Counting Sort wird in der Praxis eingesetzt, wenn k # O(n) $ 

Zeitkomplexität !(n). 


Sortieren in linearer Zeit? 

• Widersprechen Beispiele 1 & 2 der unteren Schranke "(n · log n)? 

• Nein, da das Sammeln von Informationen durch das Stellen von (in 

den Zugriffen auf die einzelnen Arrayelemente versteckten) Fragen 

erfolgt, die mächtiger sind als binäre Fragen: 

– n-wertige Fragen im Beispiel 1, 

– k-wertige Fragen im Beispiel 2. 

• Jede k-wertige Frage entspricht log 2 k binären Fragen. Wird dieser 

Umtauschfaktor berücksichtigt, so sind die Zeitkomplexitäten der 

obigen Algorithmen 

– !(n · log n) im Beispiel 1 und 

– !(n · log k + k) im Beispiel 2. 


5-67 

5-68

Radix Sort 

• Beispiel 3: Radix Sort 

Annahme: Die zu sortierenden Elemente sind ganze Zahlen bestehend 

aus höchstens d Ziffern, wobei die Ziffernpositionen von 1 bis d durchnumeriert 

sind. Die am weitesten rechts stehende Ziffer hat Position 1, 

die am weitesten links stehende Ziffer Position d. Die Basis des 

Zahlensystems sei b, d.h. 0 ! z 

Implementierung: 

void radixSort(int[] a, int d) { 

for (int i = 1; i

… Sortiernetzwerke … 

• Komparatoren sind Prozessoren, die Werte auf zwei Eingabekanälen 

vergleichen und sie an zwei Ausgabekanäle weitergeben, so daß der 

kleinere Wert auf dem oberen Ausgabekanal, der größere Wert auf 

dem unteren Ausgabekanal erscheint. 

x 

y 

Komparator 


min(x, y) 

max(x, y) 

• Anordnung von Komparatoren innerhalb eines Netzwerks, daß aus n 

waagerecht verlaufenden Kanälen besteht. Vertikale Verbindungen 

zwischen den Kanälen repräsentieren Komparatoren. Zahlen 

repräsentieren Eingabewerte, die durch das Netzwerk wandern und 

miteinander verglichen werden: 

4 

1 

3 

2 


1 

4 

3 

4 2 

1 

3 

2 

4 4 

• Ein Netzwerk von Komparatoren ist ein Sortiernetzwerk, wenn es jede 

Eingabekonfiguration sortiert. 

• Eingabekonfiguration besteht aus verschiedenen Elementen $ 

oBdA: Eingabekonfigurationen sind Permutationen der Zahlen 

1, 2, … , n 

• Netzwerk, daß duplikatfreie Eingabekonfigurationen sortiert, sortiert 

auch Konfigurationen mit Duplikaten. 

• (4, 1, 3, 2) wird nicht korrekt sortiert: 

$ kein Sortiernetzwerk! 

4 

1 

3 

2 


1 

4 

3 

4 2 

1 

3 

2 

4 4 

5-71 

5-72


• Wieviele Komparatoren werden benötigt, wie sollten sie plaziert werden? 

• Sortiernetzwerk für 4 Elemente: 

k 1 k 2 k 3 k 4 k 5 

• Wie kann man feststellen, ob ein gegebenes Netzwerk korrekt sortiert? 

– Ausschöpfendes Testen ist allenfalls für kleine Netzwerke möglich. 

– Netzwerke mit regelmäßiger Struktur erlauben gewöhnlich einen 

einfacheren Korrektheitsbeweis. 

• Beispiel: 

k 1 , k 2 und k 3 plazieren das kleinste Element auf dem obersten Kanal. 

k 1 , k 2 und k 4 plazieren das größte Element auf dem untersten Kanal. 

Die mittleren beiden Elemente verbleiben auf den beiden mittleren 

Kanälen und werden durch k 5 in die richtige Reihenfolge gebracht. 



• Entwurfsprinzipien für die Entwicklung großer Sortiernetzwerke? 

• Abbildung eines Sortieralgorithmus, der für sequentielle Maschine 

entwickelt wurde, in ein Sortiernetzwerk im allgemeinen nicht direkt 

möglich, da Netzwerke ein eingeschränkteres Berechnungsmodell 

darstellen: 

Sequentieller Sortieralgorithmus führt Vergleiche in Abhängigkeit 

vom Ausgang vorheriger Vergleiche durch , 

Sortiernetzwerk macht immer die gleichen Vergleiche für alle 

Eingabekonfigurationen. 

• Aber: gleiche grundlegende Designprinzipien, die beim Entwurf 

sequentieller Algorithmen eingesetzt werden, treffen auch auf 

parallele Algorithmen zu. 


5-73 

5-74


• Divide & Conquer: 

Plaziere zwei Sortiernetzwerke für jeweils n Kanäle übereinander und 

kombiniere sie in ein Sortiernetzwerk mit 2·n Kanälen durch 

Hinzufügen eines Merge-Netzwerks, daß ihre Ausgaben verschmilzt. 

Die rigide Struktur von Komparatornetzwerken kompliziert die 

Kombination von Netzwerken! 

• Inkrementeller Algorithmus: 

Plaziere einen n-ten Kanal unter ein Sortiernetzwerk mit n – 1 Kanälen 

und schalte diesem Netzwerk eine Kaskade von Komparatoren vor 

oder nach, die diesen Kanal in das existierende Netzwerk einbinden. 




Elemente auf den oberen n – 1 Kanälen bereits sortiert $ Element 

auf dem untersten Kanal wandert nach oben in die richtige Position: 

Sortiernetzwerk 

für 

n–1 Elemente 

• Selection Sort: 

Das größte Element wandert zuerst nach unten, dann werden die 

restlichen Elemente sortiert: 

Sortiernetzwerk 

für 

n–1 Elemente 

Induktion 

Induktion 


5-75 

5-76

… Sortiernetzwerke 

• Komparatoren können zur Minimierung der Anzahl Berechnungsstufen 

an ihren Kanälen entlang verschoben werden unter der Voraussetzung, 

daß die Topologie des Netzwerkes sich nicht ändert. 

Diese Kompression reduziert sowohl Insertion Sort als auch Selection 

Sort auf das folgende Netzwerk: 

!(n 2 ) Komparatoren, Zeitkomplexität 2 · n – 3 # !(n) 


Zusammenfassung 

• Sequentielles Suchen in Array in !(n) Zeit 

• Binäres Suchen in geordnetem Array in !(log n) Zeit 

• Sortierproblem 

• Verschiedene Typen von Sortieralgorithmen 

• Einfache Algorithmen mit Zeitaufwand !(n 2 ): 

Insertion Sort, Selection Sort 

• Untere Schranke "(n · log n) 

• Quicksort mit durchschnittlichem Zeitaufwand !(n · log n), 

im schlimmsten Fall !(n 2 ) 

• Interner Merge Sort mit Zeitaufwand !(n · log n) im schlimmsten Fall 

• Sortieren in linearer Zeit? Counting Sort, Radix Sort 

• Ausblick: 

Heapsort ist ein nicht stabiler, in place Sortieralgorithmus mit 

Zeitaufwand !(n · log n) im schlimmsten Fall. 


5-77 

5-78

Überblick 5.1 Sequentielles Suchen

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?