Counting-Sort

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 2006
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
1
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 2006
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
2
Sortieren durch Abzählen (2)
A
a1
a2
a3
…
a j mit a j = 0
SS 2006
…
…
an −1 an
…
Ci −1 + 1
C0
1
B
a4
Ci
….
Ck
…
a j mit a j = i
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
3
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]
do C [A[ j ]] ← C[A[ j ]] + 1
4.
5. > C[i ] enthält Anzahl der Elemente in A mit Wert i .
6. for i ← 0 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 ]
C[A[ j ]] ← C [A[ j ]] − 1
11.
SS 2006
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
4
Illustration für Counting-Sort (1)
A
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 3-4)
C
(nach Zeilen 6-7)
SS 2006
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
5
Illustration für Counting-Sort (2)
A
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
1
2
3
C
4
5
0
1
2
3
4
5
2
2
4
7
7
8
6
0
1
2
3
4
5
2
2
4
6
7
8
1
2
3
4
5
6
0
B
C
SS 2006
8
3
B
C
7
7
8
3
0
1
2
3
4
5
1
2
4
6
7
8
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
6
Illustration für Counting-Sort (3)
A
1
2
3
4
5
6
7
8
2
5
3
0
2
3
0
3
1
2
SS 2006
5
6
7
3
3
0
1
2
3
4
5
1
2
4
5
7
8
1
2
3
4
5
6
7
3
3
0
B
C
4
0
B
C
3
2
0
1
2
3
4
5
1
2
3
5
7
8
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
8
7
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 ← 0 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
Zeilen 1-2, 6-7: jeweils O(k)
Zeilen 3-4, 9-11: jeweils O(n)
SS 2006
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
8
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 2006
Datenstrukturen und Algorithmen 10. Sortieren in linearer Zeit
9