Aufgabe 4, aktueller Übungszettel: BubbleSort(A) Falsch (bis

Aufgabe 4, aktueller Übungszettel: BubbleSort(A)
Falsch (bis gestern)
SS 2008
Richtig (ab heute)
Datenstrukturen und Algorithmen
1
9. Untere Schranken für Sortieren
Alle
bislang betrachteten Sortieralgorithmen hatten
(worst-case) Laufzeit Ω(nlog(n)).
Werden nun gemeinsame Eigenschaften dieser
Algorithmen untersuchen.
Fassen gemeinsame Eigenschaften in Modell des
Vergleichssortierers zusammen.
Zeigen dann, dass jeder Vergleichssortierer Laufzeit
Ω(nlog(n)) besitzt.
SS 2008
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
2
Laufzeit von Sortieralgorithmen
Algorithmus
Laufzeit
SS 2008
InsertionSort
MergeSort
Quicksort
Heapsort
worst-case
average-case
Θ(n 2 )
Θ(n 2 )
Θ(n log (n ))
Θ(n log (n ))
Θ(n 2 )
Θ(n log (n ))
Θ(n log (n ))
-
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
3
Vergleichssortierer
Definition 9.1: Ein Vergleichssortierer ist ein Algorithmus,
der zu jeder beliebigen Eingabefolge (a1 ,a2 ,K ,an ) von
Zahlen eine Permutation π berechnet, so dass
aπ (1) ≤ aπ (2 ) ≤ L ≤ aπ (n ) . Dabei benutzt ein
Vergleichssortierer außer den durch den Pseudocode
definierten Kontrolloperationen nur die
Vergleichsoperationen =, ≠ , ≤, ≥, <, > .
Bemerkungen:
1. Nehmen an, dass Eingabezahlen immer
paarweise verschieden sind. Benötigen daher
= nicht.
2. Können uns auf den Vergleich ≤ einschränken.
Andere Vergleichen sind hierzu äquivalent.
SS 2008
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
4
Entscheidungsbäume
Definition 9.2: Ein Entscheidungsbaum über n Zahlen ist
ein binärer Baum bei dem
1. Jeder innere Knoten mit i : j , 1 ≤ i , j ≤ n gelabelt
ist.
2. Jedes Blatt mit einer Permutation π auf {1,K, n}
gelabelt ist.
SS 2008
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
5
Entscheidungsbäume und Sortieren
Mit Entscheidungsbäumen können Vergleichssortierer
modelliert werden. Hierzu
1.
Wird bei Eingabe (a1 ,K ,an ) ein Pfad von der
Wurzel des Baums zu einem Blatt des Baums
durchlaufen.
2.
Wird an einem inneren Knoten gelabelt mit i : j
die Kante zum linken Kind genommen, falls
ai ≤ a j , sonst wird die Kante zum rechten Kind
genommen.
3.
Wird die Permutation π des Blatts am Ende des
Pfades ausgegeben.
Zu einem Vergleichssortierer gibt für jede Eingabegröße n einen Entscheidungsbaum.
SS 2008
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
6
Entscheidungsbaum für Insertion-Sort
InsertionSort(Array A)
1. for j ← 2 to length(A) do
2.
key ← A[j]
3.
i ← j-1
4.
while i>0 and A[i]>key do
5.
A[i+1] ← A[i]
6.
i ← i-1
7.
A[i+1] ← key
SS 2008
Datenstrukturen und Algorithmen–
9. Sortieren – Untere Schranke
7
Entscheidungsbaum für Insertion-Sort
1:2
>
≤
2:3
1:3
>
≤
(1,2,3)
(2,1,3)
1:3
≤
(1,3,2)
>
≤
2:3
>
(3,1,2)
≤
(2,3,1)
>
(3,2,1)
Eingabe : a1 = 6, a2 = 8,a 3 = 5
SS 2008
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
8
Untere Schranke für Vergleichssortierer
Lemma 9.3: Für Eingaben der Größe n hat ein
Entscheidungsbaum für einen Vergleichssortierer
mindestens n! Blätter.
Beweis: Wir zeigen, jede Permutation muss in einem der
Blätter vorkommen.
• Annahme: eine bestimmte Permutation (π(1), …, π(n))
kommt nicht vor.
• Wir betrachten die Eingabe (a1, …,an) mit aπ(1) < … < aπ(n).
• Sei π‘ ≠ π eine beliebige Permutation. Dann gibt es ein j, so
dass π‘(j) ≠ π(j) (sei o.B.d.A. aπ‘(j) > aπ(j)).
• In der Ausgabe (nach π‘) wäre aπ‘(j) nicht an der richtigen
Position; somit wäre die Folge nicht sortiert.
SS 2008
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
9
Untere Schranke für Vergleichssortierer
Lemma 9.4: log(n! ) = Θ(nlog(n )).
Beweis:
• n! = 1·2·…·n > ( n/2+1) ·…· n > (n/2)n/2
• n! = 1·2·…·n < nn
• (n/2) ·log(n/2) = log((n/2)n/2) < log(n!) < log(nn) = n·log(n)
• (n/2) ·log(n/2) > (n/2) ·(log(n)-1) > (n/4) ·log(n) für alle n>4
SS 2008
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
10
Untere Schranke für Vergleichssortierer
Satz 9.5: Die von einem Vergleichssortierer bei Eingabegröße n benötigte Anzahl von Vergleichen ist
Ω(nlog(n )).
Beweis: Ein binärer Baum mit N Elementen hat Höhe
mindestens log(N).
• Annahme: Es gibt einen Baum der Höhe log(N)-1
(Anzahl der Ebenen ist log(N)).
• Ebene i hat höchstens 2i-1 Elemente
• Der Baum hat höchstens 2log(N)-1= N-1 Knoten.
Korollar 9.6: Die von Merge-Sort und Heapsort benötigte
Laufzeit von Θ(nlog(n )) ist asymptotisch optimal.
SS 2008
Datenstrukturen und Algorithmen 9. Sortieren - Untere Schranke
11
10. Sortieren in linarer Zeit
Es gibt Algorithmen, die die Ω(nlog(n)) untere Schranke
für Vergleichssortierer schlagen. Diese Algorithmen
haben Laufzeit O(n).
Diese Algorithmen benutzen neben Vergleichen und
Kontrolloperationen noch andere Operationen, z.B.
arithmetische Operationen auf den zu sortierenden Zahlen.
Außerdem werden noch Annahmen über die zu
sortierenden Zahlen getroffen, um die Laufzeit von O(n)
zu zeigen und die Korrektheit der Algorithmen zu
beweisen.
Zu diesen Algorithmen gehören Counting-Sort,
Bucket-Sort und Radix-Sort.
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
12
Sortieren durch Abzählen (1)
Annahme: Es gibt ein dem Algorithmus Counting-Sort
bekannter Parameter k, so dass für die Eingabefolge
(a1,K,an ) gilt:
0 ≤ ai ≤ k für alle 1 ≤ i ≤ n .
Algorithmusidee:
1. Für alle i , 0 ≤ i ≤ k bestimme Anzahl Ci der
a j mit a j ≤ i .
2. Kopiere a j mit a j = i in Felder B[Ci −1 + 1],K ,B[Ci ]
eines Arrays B mit length[B]=n. Dabei gilt
C−1 = 0 .
Es gilt: Ci − Ci −1 ist die Anzahl der a j mit a j = i .
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
13
Sortieren durch Abzählen (2)
A
a1
a2
a3
1
B
…
…
Ci −1 + 1
C0
a j mit a j = 0
SS 2008
…
a4
…
an −1 an
Ci
….
Ck
…
a j mit a j = i
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
14
Counting-Sort
Counting - Sort ( A,B,k )
1. for i ← 0 to k
2. do C [i ] ← 0
3. for j ← 1 to length[A]
4. do C [A[ j ]] ← C [A[ j ]] + 1
5. > C [i ] enthält Anzahl der Elemente in A mit Wert i.
6. for i ← 1 to k
7. do C [i ] ← C [i ] + C [i − 1]
8. > C [i ] enthält Anzahl der Elemente in A mit Wert ≤ i.
9. for j ← length[A] downto 1
10.
do B[C [A[ j ]]] ← A[ j ]
11.
C [A[ j ]] ← C [A[ j ]] − 1
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
15
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
0
0
0
0
0
0
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
16
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
0
0
0
0
0
0
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
17
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
0
0
1
0
0
0
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
18
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
0
0
1
0
0
0
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
19
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
0
0
1
0
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
20
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
0
0
1
0
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
21
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
0
0
1
1
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
22
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
0
0
1
1
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
23
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
1
0
1
1
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
24
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
1
0
1
1
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
25
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
1
0
2
1
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
26
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
1
0
2
1
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
27
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
1
0
2
2
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
28
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
1
0
2
2
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
29
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
2
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
30
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
2
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
31
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
3
0
1
C
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
32
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
C
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
3
0
1
0
1
2
3
4
5
2
0
2
3
0
1
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
33
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
C
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
3
0
1
0
1
2
3
4
5
2
2
2
3
0
1
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
34
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
C
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
3
0
1
0
1
2
3
4
5
2
2
4
3
0
1
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
35
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
C
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
3
0
1
0
1
2
3
4
5
2
2
4
7
0
1
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
36
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
C
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
3
0
1
0
1
2
3
4
5
2
2
4
7
7
1
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
37
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
C
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
3
0
1
0
1
2
3
4
5
2
2
4
7
7
8
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
38
Illustration für Counting-Sort (1)
A
C
(nach Zeilen 3-4)
C
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
0
1
2
3
4
5
2
0
2
3
0
1
0
1
2
3
4
5
2
2
4
7
7
8
(nach Zeilen 6-7)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
39
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
7
0
8
3
0
2
C
1
2
3
4
5
6
0
2
1
2
2
4
3
7
4
7
5
8
1
2
7
2
4
3
7
4
7
5
8
8
B
C
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
40
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
7
0
8
3
0
2
C
1
2
3
4
5
6
0
2
1
2
2
4
3
7
4
7
5
8
1
2
7
2
4
3
7
4
7
5
8
8
B
C
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
41
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
7
0
8
3
0
2
C
1
2
3
4
5
6
0
2
1
2
2
4
3
6
4
7
5
8
B
C
SS 2008
1
2
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
2
4
3
7
4
7
5
8
8
42
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
7
0
8
3
0
2
C
1
2
3
4
5
6
0
2
1
2
2
4
3
6
4
7
5
8
B
C
SS 2008
1
2
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
2
4
3
6
4
7
5
8
8
43
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
SS 2008
8
3
0
2
C
1
2
0
3
4
5
6
0
1
1
2
2
4
3
6
4
7
5
8
B
C
7
0
1
2
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
2
4
3
6
4
7
5
8
8
44
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
SS 2008
8
3
1
2
0
3
4
5
6
0
1
1
2
2
4
3
6
4
7
5
8
B
C
7
0
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
45
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
SS 2008
8
3
1
2
0
3
4
5
6
3
0
1
1
2
2
4
3
5
4
7
5
8
B
C
7
0
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
46
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
SS 2008
8
3
1
2
0
3
4
5
6
3
0
1
1
2
2
4
3
5
4
7
5
8
B
C
7
0
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
47
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
SS 2008
8
3
1
2
0
3
4
2
5
6
3
0
1
1
2
2
3
3
5
4
7
5
8
B
C
7
0
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
48
Illustration für Counting-Sort (2)
A
1
2
2
5
3
3
4
0
5
2
6
3
SS 2008
8
3
1
2
0
3
4
2
5
6
3
0
1
1
2
2
3
3
5
4
7
5
8
B
C
7
0
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
49
Illustration für Counting-Sort (2)
A
1
2
SS 2008
2
5
3
3
4
0
5
2
6
3
7
0
8
3
2
0
3
4
2
5
B
1
0
6
3
C
0
0
1
2
2
3
3
5
4
7
5
8
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
50
Illustration für Counting-Sort (2)
A
1
2
SS 2008
2
5
3
3
4
0
5
2
6
3
7
0
8
3
2
0
3
4
2
5
B
1
0
6
3
C
0
0
1
2
2
3
3
5
4
7
5
8
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
51
Illustration für Counting-Sort (2)
A
1
2
SS 2008
2
5
3
3
4
0
5
2
6
3
7
0
8
3
2
0
3
B
1
0
4
2
5
3
6
3
C
0
0
1
2
2
3
3
4
4
7
5
8
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
52
Illustration für Counting-Sort (2)
A
1
2
SS 2008
2
5
3
3
4
0
5
2
6
3
7
0
8
3
2
0
3
B
1
0
4
2
5
3
6
3
C
0
0
1
2
2
3
3
4
4
7
5
8
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
53
Illustration für Counting-Sort (2)
A
1
2
SS 2008
2
5
3
3
4
0
5
2
6
3
7
0
8
3
2
0
3
B
1
0
4
2
5
3
6
3
C
0
0
1
2
2
3
3
4
4
7
5
7
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
5
54
Illustration für Counting-Sort (2)
A
1
2
SS 2008
2
5
3
3
4
0
5
2
6
3
7
0
8
3
2
0
3
B
1
0
4
2
5
3
6
3
C
0
0
1
2
2
3
3
4
4
7
5
7
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
5
55
Illustration für Counting-Sort (2)
A
1
2
SS 2008
2
5
3
3
4
0
5
2
6
3
7
0
8
3
B
1
0
2
0
3
2
4
2
5
3
6
3
C
0
0
1
2
2
2
3
4
4
7
5
7
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
5
56
Illustration für Counting-Sort (2)
A
1
2
SS 2008
2
5
3
3
4
0
5
2
6
3
7
0
8
3
B
1
0
2
0
3
2
4
2
5
3
6
3
C
0
0
1
2
2
2
3
4
4
7
5
7
7
3
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
5
57
Analyse von Counting-Sort (1)
Counting - Sort ( A,B,k )
1. for i ← 0 to k
2. do C [i ] ← 0
3. for j ← 1 to length[A]
4. do C [A[ j ]] ← C [A[ j ]] + 1
5. > C [i ] enthält Anzahl der Elemente in A mit Wert i.
6. for i ← 1 to k
7. do C [i ] ← C [i ] + C [i − 1]
8. > C [i ] enthält Anzahl der Elemen te in A mit Wert ≤ i.
9. for j ← length[A] downto 1
do B[C [A[ j ]]] ← A[ j ]
10.
11.
C [A[ j ]] ← C [A[ j ]] − 1
Zeilen 1-2, 6-7: jeweils O(k)
Zeilen 3-4, 9-11: jeweils O(n)
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
58
Analyse von Counting-Sort (2)
Satz 10.1: Counting-Sort besitzt Laufzeit O(n+k).
Korollar 10.2: Gilt k= O(n), so besitzt Counting-Sort
Laufzeit O(n).
SS 2008
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
59