Transcript Rzędy wielkości funkcji Notacja  (g(n)) = {f(n): istnieją stałe c1, c2 i n0 takie, że 0  c1g(n)  f(n) 

Rzędy wielkości funkcji
Notacja 
(g(n)) = {f(n): istnieją stałe c1, c2 i n0 takie, że 0  c1g(n)  f(n)  c2g(n) dla
wszystkich n  n0}.
Asymptotyczne ogranicza funkcję od góry oraz od dołu.
Dla wszystkich n  n0 funkcja f(n) jest równa g(n) z dokładnością do stałego
współczynnika; g(n) jest asymptotycznie dokładnym oszacowaniem dla f(n).
Niech f(n) =
1 2
n  3n
2
c1 = 1/14, c2 = 1/2, n0 = 7
1 2 1 2
1
n  n  3n  n 2
14
2
2
f(n) = (n2)
d
Dla każdego wielomianu
p ( n )   ai n i
i 0
mamy
p(n)  (n d )
Rzędy wielkości funkcji
Notacja O
O(g(n)) = {f(n): istnieją stałe c i n0 takie, że 0  f(n)  cg(n) dla wszystkich n 
n0}. Asymptotyczne ogranicza funkcję od góry.
To oszacowanie nie musi być dokładnym; na przykład,
n = O(n2). Ale też n = O(n).
Notacja 
(g(n)) = {f(n): istnieją stałe c i n0 takie, że 0  cg(n)  f(n) dla wszystkich n 
n0}. Asymptotyczne ogranicza funkcję od dołu.
Dla każdych dwóch funkcji f(n) i g(n) zachodzi zależność f(n) = (g(n))
wtedy i tylko wtedy, gdy f(n) = O(g(n)) i f(n) = (g(n)).
Quicksort - sortowanie szybkie
Algorytm sortowania szybkiego jest oparty na technice „dziel
i zwyciężaj”.
Dziel: Tablica A[p…r] jest dzielona na dwie niepuste podtablice A[p…q] i
A[q+1…r] takie, że każdy element A[p…q] jest nie większy niż każdy
element A[q+1…r].
Zwyciężaj: Dwie podtablice A[p…q] i A[q+1…r] są sortowane za
pomocą rekurencyjnych wywołań algorytmu Quicksort.
Quicksort(A, p, r)
1 if p < r
2
then q := Partition(A, p, r)
3
Quicksort(A, p, q)
4
Quicksort(A, q+1, r)
Dzielenie tablicy
Partition(A, p, r)
1 x := A[p]
2 i := p - 1
3 j := r + 1
4 while True
5
do repeat j := j - 1
6
until A[j]  x
7
repeat i := i + 1
8
until A[i]  x
9
if i < j
10
then zamień A[i]A[j]
11
else return j
5
3
2
6
8
4
1
3
7
i
j
5
3
2
6
8
4
1
i
3
3
2
6
8
4
1
5
7
j
3
2
6
8
4
i
3
7
j
i
3
3
3
2
1
1
5
7
5
7
j
4
6
i
j
Czas działania Quicksort
Najgorszy przypadek podziałów: (n2)
Najlepszy przypadek podziałów: (n lg n)
Czas działania w średnim przypadku zbliżony jest do najlepszego: (nlgn)
n
1
n
n-1
1
n
n
n
n-2
n
n/2
n/4
n-1
n/2
n/4
n
n/4
n/4
n
lg n
1
2
1
Najgorszy przypadek
3
1
2
(n2)
1
1
1
1
1
Najlepszy przypadek
1
1
1
n
(n lg n)
Probabilistyczna wersja
Randomized-Partition(A, p, r)
1 i := Random(p, r)
2 zamień A[p]  A[i]
3 return Partition(A, p, r)
Randomized-Quicksort(A, p, r)
1 if p < r
2
then q := Randomized-Partition(A, p, r)
3
Randomized-Quicksort(A, p, q)
3
Randomized-Quicksort(A, q+1, r)