Algorytmy sortowania - Politechnika Poznańska

Poniedziałki 11.45
Grupa I3
Informatyka na wydziale Informatyki
Politechnika Poznańska
Algorytmy I Struktury Danych
Prowadząca: dr Hab. inż. Małgorzata Sterna
Sprawozdanie do
Ćwiczenia 1 – Algorytmy sortowania (27.02.12)
Autorzy:
Oliwer Kostera
nr indeksu 106552
Adam Matuszewski
nr indeksu 106550
1. Implementacja metod sortowania.
Do implementacji metod sortowania posłużyliśmy się językiem C. Każda z
metod została napisana w odrębnej funkcji. Do mierzenia czasu poszczególnych
metod użyliśmy funkcji clock() z bibliotek time.h.
2. Badana zależność czasu obliczeń t[s] od liczby sortowanych
elementów n.
n
Insertion Selestion
Sort
Sort
t[s]
t[s]
Bubble
Sort
t[s]
Heap
Sort
t[s]
Quick
Sort*
t[s]
Merge
Sort
t[s]
Counting
Sort
t[s]
20000
0,46
0,78
2,29
0,01
0,00
0,01
0,00
40000
1,87
3,14
9,13
0,01
0,01
0,01
0,00
60000
4,20
7,04
20,52
0,02
0,02
0,01
0,00
70000
5,73
9,57
27,86
0,02
0,02
0,02
0,00
80000
7,57
12,51
36,46
0,03
0,02
0,02
0,00
90000
9,45
15,83
46,17
0,04
0,02
0,03
0,01
100000
11,69
19,54
56,93
0,04
0,02
0,03
0,01
120000
16,78
28,16
82,01
0,05
0,02
0,04
0,01
150000
26,17
44,15
128,35
0,06
0,03
0,04
0,01
200000
47,03
78,68
226,07
0,07
0,04
0,06
0,01
300000
104,60
179,53
536,91
0,14
0,08
0,09
0,02
400000
195,40
328,67
955,88
0,19
0,10
0,12
0,04
500000
304,88
514,14
1492,83
0,25
0,13
0,16
0,05
750000
691,20
1163,54
3356,55
0,38
0,21
0,26
0,09
1000000
1246,62
2062,72
5829,55
0,53
0,28
0,33
0,09
*- metoda Quick Sort z podziałem wg środkowego elementu
Zakres liczb [1, n].
7000
6000
5000
t[s]
4000
3000
2000
1000
0
40000
20000
70000
60000
80000
90000
120000
200000
400000
750000
100000
150000
300000
500000
1000000
n
Insertion Sort
Selection Sort
Bubble Sort
0.6
0.5
0.4
t[s]
0.3
0.2
0.1
0
40000
20000
70000
60000
80000
90000
120000
200000
400000
750000
100000
150000
300000
500000
1000000
n
Heap Sort
Quick Sort
Merge Sort
Counting Sort
Wnioski:
-metody Heap Sort, Quick Sort, Merge Sort i Counting Sort są algorytmami
szybszymi jak widać na powyższych wykresach co czyni je efektywniejszymi,
-najszybszym algorytmem z metod „szybkich” dla n z zakresu
[20000, 1000000] jest Counting Sort, natomiast najwolniejsza Heap Sort,
-najszybszym algorytmem z metod „wolnych” dla n z zakresu
[20000, 1000000] jest Insertion Sort, natomiast najwolniejsza Bubble Sort,
Na efektywność algorytmów sortowania ma wpływ między innymi liczba
sortowanych elementów, rozkład i zakres elementów czy złożoność obliczeniowa.
Powyższe algorytmy możemy podzielić ze względu na wrażliwość na dane
wejściowe, złożoność obliczeniową, stabilność czy zajmowanie pamięci.
Wszystkie metody „szybkie” maja złożoność O(n*logn), natomiast metody
„wolne” O(n2). Do algorytmów stabilnych możemy zaliczyć MS, CS, IS i BS.
Wrażliwe na dane wejściowe są IS, CS, QS i HS. Metodami działającymi w
miejscu są wszystkie algorytmy „wolne” oraz HS.
3. Metody szybkie QS, a metoda IS dla losowego i rosnącego rozkładu
danych.
n
IS(losowe) QSs*(losowe) QSe*(losowe) IS(rosnące) QSs(rosnące) QSe(rosnące)
t[s]
t[s]
t[s]
t[s]
t[s]
t[s]
40000
1,87
0,01
0,01
0
0,01
1,72
60000
4,2
0,02
0,02
0
0,01
3,86
70000
5,73
0,02
0,02
0
0,01
5,24
80000
7,57
0,02
0,02
0
0,01
6,85
90000
9,45
0,02
0,02
0
0,01
8,66
100000
11,69
0,02
0,03
0
0,01
10,67
120000
16,78
0,02
0,03
0
0,01
15,33
150000
26,17
0,03
0,03
0
0,01
23,04
160000
31,5
0,04
0,04
0
0,02
26,16
170000
34,83
0,05
0,04
QSs- Quick Sort z pivotem na środku
Qse- Quick Sort z pivotem na skraju
0
0,02
29,62
40
35
30
t[s]
25
20
15
10
5
0
40000
60000
70000
80000
90000
100000
120000
150000
160000
170000
n
IS(losowo)
Qss(losowo)
Qse(losowo)
IS(rosnąco)
Qsm(rosnąco)
Qse(rosnąco)
Wnioski dla metody szybkiej QS:
-punkt podziału tablicy znacznie wpływa na efektywność tej metody, w
przypadku rozkładu losowego danych, czasy wykonywania algorytmów były
podobne, natomiast dla rozkładu losowego złożoność obliczeniowa metody z
piwotem w środku tablicy rosła aż do O(n2).
-najgorszym przypadkiem dla metody z podziałem wg skrajnego elementu
jest ciąg posortowany rosnąco lub malejąco, wpływ ma na to ilość wykonywanych
iteracji (mediana ciągu znajduje się w środku),
-najlepszym przypadkiem dla algorytmu z podziałęm wg środkowego
elementu jest najgorszy przypadek dla metody z podziałem wg skrajnego
elementu,
-najgorszym przypadkiem dla metody z piwotem w środku są ciągi A lub Vkształtne,
-najlepsza wersją wyboru punktu podziału jest znalezienie mediany ciągu i
w tym miejscu jego ustawienie, zaletą tego jest utrzymanie złożoności O(n*logn),
natomiast wadą wymagany dodatkowy czas,
-metoda szybka posiada niejawne wymaganie pamięciowe w postaci
odkładania wartości na stos przy rekurencji.
Metoda szybka a metoda IS.
Z wyżej otrzymanych wyników, możemy wnioskować, że efektywniejszym
algorytmem jest QS od IS. Nawet w przypadku gdy złożoność QS rośnie do O(n2)
to nadal jest szybsza metodą jak IS dla losowych elementów. Algorytm IS jest tym
lepszym tylko w przypadku gdy wiemy, że dane są już posortowane (złożoność
O(n)), nie wymaga wtedy żadnej pamięci w przeciwieństwie do QS.
Podstawowe wady i zalety poszczególnych algorytmów.
Insertion Sort:
-zalety: stabilna, działą w miejscu, zachowanie naturalne, najszybsza
z metod „wolnych”,
-wady: jak każda metoda „wolna” złożoność obliczeniowa O(n2)
Selection Sort:
-zalety: działa w miejscu, niewrażliwa na dane wejśćiowe,
-wady: niestabilna, bardzo dużo porównań, bardzo słabe zachowanie
naturalne, złożoność O(n2),
Bubble Sort:
-zalety: działa w miejscu, jest stabilna,
-wady: najwolniejsza z metod „wolnych”, słabe zachowanie naturalne,
złożoność O(n2),
Heap Sort:
-zalety: działa w miejscu, mało wrażliwa na układ danych
wejściowych,
złożoność w przypadku pesymistycznym O(n*logn), a optymistycznym
O(n), stabilna,
-wady: zachowanie nienaturalne, najwolniejsza z metod „szybkich”,
Quick Sort:
-zalety: jedna z najszybszych metod w typowych warunkach,
-wady: niejawne wymagania pamięciowe, wrażliwa na dane
wejściowe,
jedyna z metod „szybkich” dla których złożoność może urosnąć do
O(n2)
Merge Sort:
-zalety: stabilna, mniej porównań od QS,
-wady: nie działa w miejscu,
Counting Sort:
-zalety: niewrażliwa na rozkład danych wejściowych, zlożoność
liniowa,
-wady: działa tylko dla liczb naturalnych, duże zapotrzebowania
pamięciowe, silna zależność od zakresu danych wejściowych
(może
też być zaletą),
4. Metoda CS a QS.
n
QS
CS
QS
CS
(zakres 0,01*n) (zakres 0,01*n) (zakres 100*n) (zakres 100*n)
t[s]
t[s]
t[s]
t[s]
50000
0,02
0
0,01
0,07
100000
0,03
0
0,02
0,11
200000
0,07
0
0,04
0,39
300000
0,11
0,01
0,08
0,37
400000
0,15
0,01
0,10
0,75
500000
0,18
0,01
0,13
0,71
600000
0,22
0,02
0,15
0,91
700000
0,26
0,02
0,15
0,91
900000
0,33
0,01
0,24
1,33
1000000
0,37
0,02
0,27
1,72
Zakres [1, 0,01*n]
0.4
0.35
0.3
t[s]
0.25
0.2
0.15
0.1
0.05
0
50000
100000 200000 300000 400000 500000 600000 700000 900000 1000000
n
QS
CS
Zakres [1, 100*n]
2
1.8
1.6
1.4
t[s]
1.2
1
0.8
0.6
0.4
0.2
0
50000
100000 200000 300000 400000 500000 600000 700000 900000 1000000
n
QS
CS