External Quicksort

Optimierung des Quicksort-Verfahrens für Speicherhierarchien

Martin Gronemann, Bernd Zey

Überblick

1. Quicksort - Erinnerung

2. Intuitive Lösung

3. Distribution-Sort (external Quicksort)

Quicksort - Erinnerung

12

Pivot-Element:

42 23 1 60 17 55 22 5

RL23

12 5

L

421212 5 23 1 60 17 55 22 425 42

RL

12 5 23 1 60 17 55 22 4223 2212 5 23 1 60 17 55 22 4222 23

L

22 1

L

1 6012 5 22 1 60 17 55 22 4223 6023 17

R

60555523 17

R

12 5 22 1 60 23 55 22 4217 60

1 5 17 22 42 6012 23 55

12 5 22 1 17 55 22 426012 5523

1 5 22 17 42 6012 23 55

Intuitive Lösung

1. Lade den Wert des Pivot-Elements und die ersten und letzen B Array-Elemente in den Main Memory

2. Starte normalen Quicksort

3. Laden und Schreiben bei Bedarf

Intuitive Lösung: BeispielEM:

MM:

L R

Pivot

L RL RL RL RL RL RL RL RL R

Analyse: Intuitive Lösung

• Analyse der I/O‘s äquivalent zur Laufzeitanalyse von Quicksort

• Pro Rekursionstiefe: O(N/B) I/O‘s benötigt

• Im average case beträgt die Rekursionstiefe O(log2 N) I/O-Anzahl O(N/B log2

N/B)

interne Laufzeit O(N log2 N)

• Im worst case (N2)

Distribution Sort

• Mit mehreren Pivot-Elementen arbeiten

• Pivot-Elemente definieren „Buckets“• Element muss in „Bucket“ einsortiert

werden• Jeden „Bucket“ rekursiv sortieren bis

Blockgröße B erreicht ist

Berechnung der Pivot-Elemente (1)

1. Unterteile Eingabemenge in N/M Chunks2. Sortiere jeden Chunk3. Nehme jedes a-te Element aus jedem

Chunk in Array U auf (|U| = N/a)4. Sortiere U5. Berechne µ-1 äquidistante Pivot-Elemente

aus dem Array U mit BFPRT (Blum-Floyd-Pratt-Rivest-Tarjan)

Berechnung der Pivot-Elemente (2)

BFPRT

Array U(sortiert)

µ-1 Pivot-Elemente

Chunks(sortiert)

Analyse: Berechnung der Pivot-Elemente

• U kann mit O(N/B) I/O‘s erzeugt werden.• BFPRT benötigt

O((|U|/B) lg µ) =

O((N/aB) lg µ) I/O‘sFür a ≥ lg µ:

O(N/B)

• Insgesamt O(N/B) I/O‘s für die Berechnung der Pivot-Elemente

Rekursion

1. Sortiere jedes Element in den richtigen „Bucket“ (Distribution)

Bi := {x | pi ≤ x < pi+1}

2. Starte Rekursion auf jedem „Bucket“

3. Wenn „Bucket“ Blockgröße erreicht hat dann intern sortieren

Beispiel µ=4 Pivot 1 Pivot 2 Pivot 3-∞ ∞

Blockgröße Rekursionstiefe: O(logµN/B)

Analyse

• Rekursionstiefe bis zur Blockgröße: O(logµ

N/B) I/O‘s

• Einsortieren kostet pro Rekursionstiefe O(N/B) I/O‘s

• Gesamt: O(N/B logµ N/B) I/O‘s

Literatur

• Alok Aggarwal and Jerey Scott Vitter, 1988:

„The Input/Output Complexity of Sorting and Related Problems“

• Jeff Erickson - Prof. an der University of Illinois: „Introduction: the standard external-memory model; upper and lower bounds for scanning (Θ(n)), searching (Θ(logB n) via B-trees), and sorting (Θ(n logm n) via mergesort); external comparison trees“

http://compgeom.cs.uiuc.edu/~jeffe/teaching/473/01-search+sort.pdf