Sortowanie w czasie liniowym

Sortowanie w czasie liniowym
1
Sortowanie - zadanie
Definicja (dla liczb):
wejście: ciąg n liczb A = (a1, a2, …, an)
wyjście: permutacja (a1,…, a’n) taka, że a’1 ≤ … ≤ a’n
Po co sortować?
–  Podstawowy problem dla algorytmiki
–  Wiele algorytmów wykorzystuje sortowanie jako procedurę pomocniczą
–  Pozwala pokazać wiele technik
–  Dobrze zbadane (czas)
2
Zestawienie czasów działania
Ø  Przez wybór: O(N2) zawsze
Ø  Bąbelkowe: O(N2) najgorszy przypadek; O(N) najlepszy przyp.
Ø  Wstawianie: O(N2) średnio; O(N) najlepszy przypadek
Ø  Shellsort:
O(N3/2)
Ø  Heapsort:
O(NlogN) zawsze
Ø  Mergesort:
O(NlogN) zawsze
Ø  Quicksort:
O(NlogN) średnio; O(N2) najgorszy przypadek
Ø  Zliczanie:
O(N) zawsze
Ø  Radix sort:
O(N) zawsze
Ø  zewnętrzne: O(b logb)) dla pliku o b „stronach”.
3
Przegląd
Ø  Czy możliwe jest sortowanie w czasie lepszym niż dla metod
porównujących elementy (poprzednio – najlepsze algorytmy dawały
czas O(NlogN))?
Ø  Algorytmy o liniowym czasie działania:
–  Przez zliczanie (Counting-Sort)
–  Pozycyjne (Radix-Sort)
–  Kubełkowe (Bucket-sort)
Ø  Potrzeba dodatkowych założeń!
4
Sortowanie o czasie liniowym
Ø  Możliwe przy dodatkowych informacjach (założeniach) o danych
wejściowych.
Ø  Przykłady takich założeń:
–  Dane są liczbami całkowitymi z przedziału [0..k] i k = O(n).
–  Dane są liczbami wymiernymi z przedziału [0,1) o rozkładzie
jednostajnym na tym przedziale
Ø  Trzy algorytmy:
–  Counting-Sort
–  Radix-Sort
–  Bucket-Sort
5
Zliczanie (Counting sort)
wejście: n liczb całkowitych z przedziału [0..k], dla k = O(n).
pomysł: dla każdego elementu wejścia x określamy jego pozycje (rank):
ilość elementów mniejszych od x.
jeśli znamy pozycję elementu – umieszczamy go na r+1 miejscu ciągu
przykład: jeśli wiemy, że w ciągu jest 6 elementów mniejszych od 17, to 17
znajdzie się na 7 miejscu w ciągu wynikowym.
powtórzenia: jeśli mamy kilka równych elementów umieszczamy je kolejno
poczynając od indeksu pozycja
6
Zliczanie (Counting sort)
A= 4 2 1 3 5
Dla każdego A[i], liczymy elementy
≤ od niego. Daje to rank (pozycję)
elementu
Rank = 1 2 3 4 5
B=
1 2 3
4 5
Jeśli nie ma powtórzeń i n = k,
Rank[A[i]] = A[i] i B[Rank[A[i]] ß A[i]
7
Zliczanie (Counting sort)
A= 5 2 1 3
Rank = 1 2 3
B=
1 2 3
Jeśli nie ma powtórzeń i n < k,
4
5
Niektóre komórki tablicy rank
pozostają niewykorzystane, ale
algorytm działa.
8
Zliczanie (Counting sort)
A= 4 2 1 2 3
Jeśli n > k i mamy powtórzenia,
Rank = 1 32 4 5
B= 1 2 2
3 4
umieszczamy na wyjściu
powtarzające się elementy w
takiej kolejności, w jakiej
występowały w oryginalnym
ciągu (stabilność)
9
Zliczanie (Counting sort)
A[1..n] – tablica wejściowa
B [1..n] – tablica wyjściowa
C [0..k] – pomocnicza tablica (do zliczania)
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 zawiera ilości elementów równych i
6. 
for i ß 1 to k
7. 
do C[i] ß C[i] + C[i –1]
8. 
/* C zawiera ilości elementów ≤ i
9. 
for j ß length[A] downto 1
10. 
do B[C[A[j]]] ß A[j]
11. 
C[A[j]] ß C[A[j]] – 1
10
Sortowanie przez zliczanie – przykład (1)
1
2
3
4
5
6
7
8
A= 2 5 3 0 2 3 0 3
0
1
2
3
4
5
C[A[j]] ß C[A[j]] +1
po p.4
C= 2 0 2 3 0 1
0
1
2
3
4
5
C[i] ß C[i] + C[i –1]
po p. 7
C= 2 2 4 7 7 8
1
2
3
4
5
n=8
k=6
6
7
8
3
B=
0
1
2
C= 2 2 4
3
4
76 7 8
5
B[C[A[j]]] ß A[j]
C[A[j]] ß C[A[j]] – 1
po p. 11
11
Sortowanie przez zliczanie – przykład (2)
1
2
3
4
5
6
7
8
A= 2 5 3 0 2 3 0 3
0
1
2
3
4
5
C= 2 2 4 6 7 8
1
2
3
4
5
6
7
3
0
B=
0
1
8
2
3
4
5
C = 21 2 4 6 7 8
12
Sortowanie przez zliczanie – przykład (3)
1
2
3
4
5
6
7
8
A= 2 5 3 0 2 3 0 3
0
1
2
3
4
5
C= 2 2 4 6 7 8
1
2
3
4
5
0
1
7
8
3 3
0
B=
6
2
3
4
5
C = 1 2 4 65 7 8
13
Counting sort – czas działania
Ø  Pętla for w p.1-2 zajmuje czas Θ(k)
Ø  Pętla for w p.3-4 zajmuje czas Θ(n)
Ø  Pętla for w p.6-7 zajmuje czas Θ(k)
Ø  Pętla for w p.9-11 zajmuje czas Θ(n)
Ø  Stąd dostajemy łączny czas Θ(n+k)
Ø  Ponieważ k = O(n), T(n) = Θ(n)
à algorytm jest optymalny!!
Ø  Konieczne jest założenie k = O(n). Jeśli k >> n to potrzeba to
potrzeba dużej ilości pamięci.
Ø  Nie jest to sortowanie „w miejscu”.
14
Radix sort – sortowanie pozycyjne
wejście: n liczb całkowitych, d-cyfrowych, łańcuchów o d-pozycjach
pomysł: zajmować się tylko jedną z cyfr (sortować względem kolejnych
pozycji – cyfr/znaków). Zaczynamy od najmniej znaczącej cyfry/
znaku, potem kolejne pozycje (cyfry/znaki), aż do najbardziej
znaczącej. Musimy stosować metodą stabilną. Ponieważ zbiór
możliwych wartości jest mały (cyfry – 0-9, znaki ‘a’-’z’) możemy
zastosować metodę zliczania, o czasie O(n)
Po zakończeniu ciąg będzie posortowany!!
15
Radix sort – przykład
329
720
720
329
457
355
329
355
657
436
436
436
839
457
839
457
436
657
355
657
720
329
457
720
355
839
657
839
16
Radix-Sort – pseudokod
Radix-Sort(A, d)
1. 
2. 
for i ß 1 to d
do zastosuj stabilną metodę sortowania do cyfry d dla tablicy A
uwagi:
• 
złożoność: T(n) = Θ(d(n+k)) à Θ(n) dla stałego d i k = O(1)
• 
wartości cyfr/znaków są z zakresu [0..k –1] dla k = O(1)
• 
Metoda stosowana dla poszczególnych pozycji musi być stabilna!
17
Sortowanie kubełkowe – Bucket sort
wejście: n liczb rzeczywistych z przedziału [0..1) ważne jest, aby były
równomiernie rozłożone (każda wartość równie prawdopodobna)
pomysł: dzielimy przedział [0..1) na n podprzedziałów („kubełków”):0, 1/n,
2/n. … (n–1)/n. Elementy do odpowiednich kubełków, ai: 1/i ≤ ai ≤ 1/(i+1).
Ponieważ rozkład jest równomierny to w żadnym z przedziałów nie
powinno znaleźć się zbyt wiele wartości. Jeśli wkładamy je do kubełków
zachowując porządek (np. przez wstawianie – Insertion-Sort),
dostaniemy posortowany ciąg.
18
Bucket sort – przykład
.78
.17
.39
.26
.72
.94
. 21
0
.12
1
.12
2
.21
3
.39
.23
.26
.21
.23
4
.26
5
.39
6
.68
.23
7
.72
.68
8
.12
.17
.17
9
.68
.78
.72
.78
.94
.94
19
Bucket-Sort
A[i] tablica wejściowa
B[0], B[1], … B[n –1] lista „kubełków”
Bucket-Sort(A)
1. 
n ß length(A)
2. 
for i ß 0 to n
3. 
do wstaw A[i] do listy B[floor(nA[i])]
4. 
for i ß 0 to n –1
5. 
do Insertion-Sort(B[i])
6. 
Połącz listy B[0], B[1], … B[n –1]
20
Bucket-Sort – złożoność czasowa
Ø  Wszystkie instrukcje z wyjątkiem 5 (Insertion-Sort) wymagają czasu O(n),
w przypadku pesymistycznym.
Ø  W przypadku pesymistycznym, O(n) liczb trafi do jednego „kubełka” czyli
ich sortowanie zajmie czas O(n2).
Ø  Jednak w średnim przypadku stała ilość elementów wpada do jednego
przedziału – stąd czas średni wyniesie O(n).
21