Denicje

Zªo»ono±¢ algorytmu
▶ czasowa,
▶ pami¦ciowa,
▶ przepustowo±¢ ª¡cza,
▶ ilo±¢ procesorów.
Rozmiar danych,
Maszyna RAM (Random Access Machine),
Operacja dominuj¡ca,

1 / 78
Denicje
Oznaczenia:
▶ D
n  zbiór danych rozmiaru n,
▶ t(d)  liczba operacji dominuj¡cych,

▶ X
n  Zmienna losowa dla t(d), gdzie d ∈ Dn ,
kn  rozkªad prawdopodobie«stwa zmiennej Xn .
Optymistyczna zªo»ono±¢ czasowa
▶ p

Opt(n) = inf{t(d) : d ∈ Dn }
‘rednia zªo»ono±¢ czasowa X
A(n) = ave(Xn ) = kpk,n

Pesymistyczna zªo»ono±¢ czasowa

k­0

W (n) = sup{t(d) : d ∈ Dn }
Miara wra»liwo±ci pesymistycznej
∆(n) = sup{t(d1 ) − t(d2 ) : d1 , d2 ∈ Dn }
Miara wra»liwo±ci oczekiwanej sX
p
δ(n) = dev(Xn ) = var(Xn ) = (k − ave(Xn ))2 pk,n
k­0
2 / 78
Przykªad
Rozpatrujemy sortowanie dla trzech elementów {1, 2, 3} dla n = 3, wtedy:
Dn  zbiór danych rozmiaru n
Dn = {(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)}
Przykªad algorytmu sortowania trzech elementów {x, y, z} w postaci drzewka

x<y ilo±¢ operacji dominuj¡cych (porównania),

T N
y<z x<z t ((1, 2, 3)) = 2,
T N T N t ((2, 1, 3)) = 3,
x<y<z x<z y<x<z y<z
T N T N
x<z<y z<x<y y<z<x z<y<x

3 / 78
Przykªad
Rozpatrujemy sortowanie dla trzech elementów {1, 2, 3} dla n = 3, wtedy:
Dn  zbiór danych rozmiaru n
Dn = {(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)}
Przykªad algorytmu sortowania trzech elementów {x, y, z} w postaci drzewka

x<y Optymistyczna zªo»ono±¢

T N Opt(3) = inf{t(d) : d ∈ D3 } = 2

y<z x<z
T T N Pesymistyczna zªo»ono±¢
N
x<y<z x<z y<x<z y<z W (3) = sup{t(d) : d ∈ D3 } = 3

T N T N Wra»liwo±¢ pesymistyczna
x<z<y z<x<y y<z<x z<y<x
∆(3) = sup{t(d1 ) − t(d2 ) : d1 , d2 ∈ D3 }
= 1

4 / 78
Przykªad
Rozpatrujemy sortowanie dla trzech elementów {1, 2, 3} dla n = 3, wtedy:
Dn  zbiór danych rozmiaru n
Dn = {(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)}
Przykªad algorytmu sortowania trzech elementów {x, y, z} w postaci drzewka

Zªo»ono±¢ ±rednia
x<y X
T N A(n) = ave(Xn ) = kpk,n

k­0
y<z x<z
2+2+3+3+3+3 2∗2+4∗3
T N T N =
6
=
6
x<y<z y<x<z y<z 2 4 8
x<z = 2 +3 = 2p2,3 + 3p3,3 =

T N T N 6 1 6 3
, dla i = 2,
3
x<z<y z<x<y y<z<x z<y<x pi,n = 2, dla i = 3,
3
0, dla i ̸= 2, 3

5 / 78
Przykªad
Rozpatrujemy sortowanie dla trzech elementów {1, 2, 3} dla n = 3, wtedy:
Dn  zbiór danych rozmiaru n
Dn = {(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)}
Przykªad algorytmu sortowania trzech elementów {x, y, z} w postaci drzewka

Wra»liow±¢ oczekiwana
x<y sX
T N δ(n) = (k − ave(Xn ))2 pk,n

y<z x<z k­0

T N T N q
8
2 1 8
2 2
= 2− ∗ + 3− ∗
x<y<z x<z y<x<z y<z 3 3 3 3
√
T N T N =
2
3
x<z<y z<x<y y<z<x z<y<x

6 / 78
Denicje
Niech f, g, h : N → R+ ∪ {0}, wtedy:
▶ f jest co najwy»ej rz¦du g , co zapisujemy f (n) = O(g(n)), gdy istnieje c > 0 i k ∈ N, takie »e
f (n) ¬ cg(n) dla ka»dego n ­ k.

▶ f jest co najmniej rz¦du g , co zapisujemy f (n) = Ω(g(n)), gdy g(n) = O(f (n)) lub inaczej, gdy
istnieje c > 0 i k ∈ N, takie »e f (n) ­ cg(n) dla ka»dego n ­ k.

▶ f jest dokªadnie rz¦du g , co zapisujemy f (n) = Θ(g(n)), gdy f (n) = O(g(n)) i f (n) = Ω(g(n)).

7 / 78
Klasy zªo»ono±ci
Podstawowe zªo»ono±ci w sensie O - du»e, Θ:
▶ log n,
▶ n,
▶ n log n,
▶ n2 , n3 , . . .,
2
▶ nlog n = 2log n ,
▶ 2 ,
n

▶ n!.
Najcz¦±ciej w analiza algorytmu skupiamy si¦ na badaniu zªo»ono±ci
pesymistycznej, najprostsze, ale maªo u»yteczne.
▶ Mo»e za wyj¡tkiem systemów czasu rzeczywistego.
Najwi¦cej o typowym zachowaniu algorytmu mówi jego zªo»ono±¢ ±rednia
i wra»liwo±¢ oczekiwana.

8 / 78
Porównanie algorytmów
Operacja dominuj¡ca - porównanie
Algorytm Opt(n) A(n) W (n) ∆(n) δ(n)
Quick Sort Θ(n log n) Θ(n log n) Θ(n2 ) Θ(n2 ) Θ(log n)
Bubble Sort Θ(n2 ) Θ(n2 ) Θ(n2 ) Θ(1) Θ(1)
Heap Sort Θ(n) Θ(n log n) Θ(n log n) Θ(n log n) Θ(n)

Opt(n) - Optymistyczna zªo»ono±¢ czasowa

A(n) - ‘rednia zªo»ono±¢ czasowa
W (n) - Pesymistyczna zªo»ono±¢ czasowa
∆(n) - Miara wra»liwo±ci pesymistycznej
δ(n) - Miara wra»liwo±ci oczekiwanej

9 / 78
Równania Rekurencyjne

T (1) = a,
T (n) = bT (n/c) + D(n) + M (n).
gdzie:
D(n) - koszt podziaªu na podzadania,
M (n) - koszt scalenia wyników.
Przykªad 1: Binary Serach,
Przykªad 2: QuickSort
▶ Zªo»ono±¢ pesymistyczna

W (0) = W (1) = 0;
W (n) = max1¬j¬n (W (j − 1) + W (n − j)) + (n + 1)
1 2 3
W (n) = n + n − 2 = θ(n2 )
2 2
▶ Zªo»ono±¢ optymistyczna

Opt(0) = Opt(1) = 0;
Opt(n) = Opt(⌈n − 1⌉/2) + Opt(⌊n − 1⌋/2) + (n + 1)
Opt(n) = θ(n log n)
10 / 78
Przykªad 2: QuickSort
▶ Pesymistyczna wra»liwo±¢:

∆p (n) = O(n2 − n log n) = O(n2 )

▶ Zªo»ono±¢ ±rednia:
(
A(0) = A(1) = 0;
1
Pn
A(n) = (n + 1) + n j=1
(A(j − 1) + A(n − j))
A(n) = O(n log n)

▶ Oczekiwana wra»liwo±¢:
r
2 2
δ(n) = 7− π n + O(log n)
3

11 / 78
Przykªad - szacowanie zlo»ono±ci sredniej Quicksort
A(0) + A(N − 1) A(1) + A(N − 1) A(N − 1) + A(0)
A(N ) = (N + 1) + + + ... +
N N N
N A(N ) = N (N + 1) + 2 (A(0) + A(1) + . . . + A(N − 1))
(N + 1)A(N + 1) = (N + 1)(N + 2) + 2 (A(0) + A(1) + . . . + A(N − 1) + A(N ))

Odejmuj¡c drugie równanie od trzeciego dostaniemy

(N + 1)A(N + 1) − N A(N ) = 2(N + 1) + 2A(N )

Po pogrupowaniu oraz podzieleniu przez (N + 1)(N + 2) mamy

A(N + 1) A(N ) 2
= +
N +2 N +1 N +2

teraz kolejno rozpisuj¡c

A(N ) A(N − 1) 2
= +
N +1 N N +1
A(N − 2) 2 2
= + +
N −1 N N +1
A(N − 3) 2 2 2
= + + +
N −2 N −1 N N +1
............
A(2) 2 2 2
= + + ... + +
1 2 N N +1
2 2 2 2
= + + ... + +
1 2 N N +1

12 / 78
Przykªad - szacowanie zlo»ono±ci sredniej Quicksort
a to daje
 
1 1 1 1
A(N ) = 2(N + 1) + + ... + +
1 2 N N +1

oszacowanie z góry
Z N +2
dx
A(N ) ¬ 2(N + 1)
x
2
≈ 2N ln N
log2 N
= 2N ≈ 1.39N log2 N
log2 e

i oszacowanie z doªu
Z N +1
dx
A(N ) ­ 2(N + 1)
x
1
≈ 2N ln N
log2 N
= 2N ≈ 1.39N log2 N
log2 e

zatem
A(N ) ≈ 1.39N log2 N

13 / 78
Zmienna Losowa
Intuicyjnie - zmienna losowa reprezentuje wynik do±wiadczenia wktórym otrzymujemy warto±¢
liczbow¡ zale»n¡ od przypadku (której nie da si¦ ustali¢ przed do±wiadczeniem).

Przykªad: Zmienna losowa reprezentuj¡ca do±wiadczenie rzucania kostk¡ do gry.

Z prawdopodobie«stwem 1/6 w ka»dym rzucie mo»emy przyj¡¢ jedn¡ z warto±ci 1, 2, . . . , 6.

14 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Warto±¢ ±rednia (przeci¦tna, oczekiwana):
X
A(n) = ave(Xn ) = E(Xn ) = ipi,n
i­0

wariancj¦ wyliczymy jako:

2 2 X 2
δ (n) = var[Xn ] = E[(Xn − E(Xn )) ] = (i − ave(Xn )) pi,n
i­0

gdzie pi,n oznacza prawdopodobie«stwo, »e nasz algorytm przy n danych

wykona i kroków.

Na przykªad przy wyszukiwaniu sekwencyjnym po±ród n elementów je±li

element istnieje w tym zbiorze mamy:
(
1
n dla i = 1, . . . , n
pi,n =
0 w przeciwnym przypadku

15 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Je±li zdeniujemy funkcj¦:
X i
Pn (x) = pi,n x
i­0

gdzie pi,n oznacza prawdopodobie«stwo, »e nasz algorytm przy n danych

wykona i kroków, wtedy:
Pn (1) = 1,
′
ave(Xn ) = Pn (1),
′′ ′ ′ 2
var(Xn ) = Pn (1) + Pn (1) − Pn (1) .

dowód na nast¦pnym slajdzie.

16 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Poniewa»
i
X
Pn (x) = pi,n x
i­0
′ i−1
X
Pn (x) = ipi,n x
i­1
′′ i−2
X
Pn (x) = i(i − 1)pi,n x
i­2

to:
X
1 = pi,n = Pn (1)
i­0
i−1 ′
X X X
ave(Xn ) = ipi,n = ipi,n 1 = ipi,n = Pn (1)
i­0 i­1 i­1
2 ′ 2
X X
var(Xn ) = (i − ave(Xn )) pi,n = (i − Pn (1)) pi,n
i­0 i­0
X
2 ′ ′ 2


= i − 2Pn (1) + Pn (1) pi,n
i­0
′ ′ 2
X X X X
= i(i − 1)pi,n + ipi,n − 2Pn (1) ipi,n + Pn (1) pi,n
i­2 i­1 i­0 i­0

′′ ′ ′ 2
′ 2 ′′ ′ ′ 2
= Pn (1) + Pn (1) − 2Pn (1) + Pn (1) = Pn (1) + Pn (1) − Pn (1) .

17 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Przykªad 1: Wyszukiwanie sekwencyjne w tablicy nieuporz¡dkowanej:
Zakªadamy, »e szukany element x znajduje si¦ w tablicy rozmiaru n.
Je±li element x mo»e znajdowa¢ si¦ na ka»dej pozycji z równym
prawdopodobie«stwem, to:
(
1
n, dla 1 ¬ i ¬ n
pi,n =
0, w przeciwnym przypadku
Deniujemy:
1 Xn
P (x) = pi,n xi = xi
X

i­0 n i=1

wtedy:
1 Xn
P ′ (x) = ixi−1
n i=1
1 Xn
P ′′ (x) = i(i − 1)xi−2
n i=2
18 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Wykorzystuj¡c wªasno±ci wielomianów policzymy P (1), P ′ (1), P ′′ (1)
mamy
n n n n
′′ ′′ 1 X i−2 1 X i−2 1 X i−2 1 X i−1
P (x) − xP (x) = i(i − 1)x −x i(i − 1)x = i(i − 1)x − i(i − 1)x
n n n n
i=2 i=2 i=2 i=2
n n+1
1 X i−2 1 X
i−2
= i(i − 1)x − (i − 1)(i − 2)x
n n
i=2 i=3
n n
1 X i−2 1 X i−2 n(n − 1)xn+1
= i(i − 1)x − (i − 1)(i − 2)x −
n n n
i=2 i=2
n
1 X i−2 n(n − 1)xn+1
= (i(i − 1) − (i − 1)(i − 2)) x −
n n
i=2
n n−1
1 X i−2 n(n − 1)xn+1 2 X i−1 n(n − 1)xn+1
= 2(i − 1)x − = ix −
n n n n
i=2 i=1
n
2 X i−1 2 n−1 n(n − 1)xn+1
= ix − nx −
n n n
i=1

′ 2nxn−1 n(n − 1)xn+1

= 2P (x) − −
n n

19 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Otrzymali±my wzór:
′′ ′′ ′ 2nxn−1 n(n − 1)xn+1
P (x) − xP (x) = 2P (x) − −
n n

podstawiaj¡c x = 1 mamy:
′′ ′′ ′ 2n n(n − 1)
0 = P (1) − 1 ∗ P (1) = 2P (1) − −
n n

czyli
′ n(n + 1) n+1
P (1) = =
2n 2

Podobnie przy pomocy równania 0 = P ′′′ (1) − 1 ∗ P ′′′ (1) mo»na wyliczy¢
warto±¢ P ′′ (1), a tym samym obliczy¢ warto±¢ ave(Xn ) i var(Xn )

20 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Przykªad 2: Wyszukiwanie istniej¡cego elementu x z tablicy
uporz¡dkowanej za pomoc¡ wyszukiwania binarnego.
Mo»na policzy¢ ave(Xn ) i var(Xn ) w sposób podobny jak poprzednio a
nawet pro±ciej.
Je±li przyjmiemy zaªo»enie n = 2h − 1, co generalnie nie wpªywa na klas¦
funkcji w rozwi¡zaniach dla innych n (sprawd¹ zadanie h - z pierwszego
zestawu rozgrzewkowego), to
(
2i−1
n dla 1 ¬ i ¬ h,
pi,n =
0 w przeciwnym wypadku.

Odpowiedni wielomian jest nast¦puj¡cej postaci:

h 2i−1 i
P (x) = x.
X

i=1 n

Dalej trzeba si¦ troch¦ nakombinowa¢ aby wyliczy¢ P (1), P ′ (1) i P ′′ (1) a
z tych warto±ci ªatwo wyliczy¢ ave(Xn ) i var(Xn ).

21 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
W celu uproszczenia oblicze«, przyjmijmy, »e n = 2h − 1, wtedy drzewko
poszukiwa« binarnych na ostatnim poziomie jest wpeªni wypeªnione.
Zauwa»my jeszcze, »e na poziomie h = 1 mamy jeden w¦zeª - korze«. Przy
oznaczeniu Q(x) = hi=1 xi , dostaniemy:
X

h 2i−1 i X (2x)
h i
Q(2x)
P (x) = x = = ,
X

i=1 n i=1 2n 2n
a st¡d: log2 h

Q′ (2x) Q′ (2)
P ′ (x) = n , P ′ (1) = ,
n
′
2Q′′ (2x) 2Q (2)
P ′′ (x) = n , P ′′ (1) = .
n

22 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Mo»emy teraz wykona¢ stosowne obliczenia:
xh+1 − 1
Q(x) = Σhi=1 xi = Σhi=0 xi − 1 = − 1,
x−1
(x − 1)Q(x) = xh+1 − x,
Q(x) + (x − 1)Q′ (x) = (h + 1)xh − 1,
′ ′′
2Q (x) + (x − 1)Q (x) = h(h + 1)xh−1 .

Po podstawieniu x = 2 otrzymamy:
Q(2) = 2h+1 − 2,
Q′ (2) = (h + 1)2h − 1 − 2h+1 + 2 = (h − 1)2h + 1,
Q′′ (2) = h(h + 1)2h−1 − 2 (h − 1)2h + 1 = (h2 − 3h + 5)2h−1 − 2.

23 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
A zatem:
(h − 1)2h + 1
   
h log n
P ′ (1) = = h − 1 ± O = log (n + 1) − 1 ± O
2h − 1 2h n+1
 
log (n)
= log (n) − 1 ± O ,
n


2 (h2 − 3h + 5)2h−1 − 2
 2
h
P ′′ (1) = = h 2
− 3h + 5 ± O
2h − 1 2h
 2 
log (n)
= log2 (n) − 3 log (n) + 5 ± O .
n

Uwaga: Tutaj uprasza si¦ studentów, aby sprawdzili, »e wszelkie przej±cia,

gdzie zostaªy u»yty symbol O-du»e, s¡ uprawnione. Dodatkowo
prawdopodobnie b¦dzie jeszcze potrzebna nierówno±¢:
1
ln(1 + x) ¬ ln(x) + ,
x
która mo»na ªatwo otrzyma¢ ze wzoru Taylora z reszta Lagrange'a.
24 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Po podstawieniu do wzoru na warto±¢ ±redni¡ ave(Xn ) oraz wariancj¦
var(Xn ) otrzymamy:
 
′ log (n)
ave(Xn ) = P (1) = log (n) − 1 ± O ,
n

′′ ′ ′

2
var(Xn ) = P (1) + P (1) − P (1)
   
2 log2 (n) log (n)
= log (n) − 3 log (n) + 5 ± O + log (n) − 1 ± O
n n
  2
log (n)
− log (n) − 1 ± O
n
 
log2 (n)
= 3±O .
n

Jak wida¢ algorytm wyszukiwania binarnego zwykle musi przej±¢ prawie caªe
drog¦ od korzenia a» do li±cia.

Uwaga: Ponownie, studenci powinni zwerykowa¢ obliczenia, zwªaszcza tam

gdzie zostaª u»yty symbol O - du»e. Prosz¦ zastanowi¢ si¦, jak uzasadni¢
przyj¦te w rozwa»aniach n = 2h − 1, tzn. wynik dla n takiego, »e
2h − 1 ¬ n < 2h+1 − 1 b¦dzie niewiele si¦ ró»niª od przedstawionego, tak
napraw¦ ró»nica b¦dzie w ganicach ±1.
25 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Przykªad 3: Wyszukiwanie miejsca na element x, którego brakuje w tablicy
uporzadkowanej za pomoc¡ wyszukiwania binarnego.
W przypadku brakujacego elementu, algorytm wyszukiwania binarnego
zawsze wykona h lub h + 1 kroków, gdy
2h − 1 ¬ n < 2h+1 − 1.

Oczywi±cie h = ⌊log2 n⌋. Mo»emy przyj¡¢, »e ph,n = α

(prawdopodobie«stwo wykonania h kroków), wtedy ph+1,n = 1 − α i
pk,n = 0 dla k ̸= h i k ̸= h + 1.
Dla funkcji P (x) zdeniowanej jak w poprzednim przykªadzie otrzymamy:
P (x) = pi,n xi = αxh + (1 − α)xh+1 ,
X

i­0

P ′ (x) = hαxh−1 + (h + 1)(1 − α)xh ,

P ′′ (x) = h(h − 1)αxh−2 + (h + 1)h(1 − α)xh−1 .

26 / 78
Wykorzystanie wielomianów do liczenia zlo»ono±ci
Podstawiaj¡c x = 1, dostaniemy
P (1) = α(1 − α) = 1,
′
P (1) = hα + (h + 1)(1 − α) = h + 1 − α,
P ′′ (1) = h(h − 1)α + (h + 1)h(1 − α) = h(h + 1 − 2α).

Teraz mo»emy obliczy¢ ave(Xn ) i dev(Xn )

ave(Xn ) = P ′ (1) = h + 1 − α,
var(Xn ) = h(h + 1 − 2α) + h + 1 − α − (h + 1 − α)2
= h2 + h − 2hα + h + 1 − α − h2 − 1 − α2 − 2h + 2hα + 2α
1
= α − α2 = α(1 − α) ¬ .
4
Jak wida¢, ±rednio wykonujemy ilo±¢ kroków h + 1 − α bardzo zbli»on¡ do
wysoko±ci drzewa, dodatkowo
p odchylenie od tej ilo±ci kroków jest bardzo
maªe i wynosi dev(Xn ) = var(Xn ) ¬ 12 .

27 / 78
Koszt Amortyzowany
Przykªad 1: listowa implementacja stosu:
push( S, x ) - wkªada element x na stos S, koszt O(1)
pop( S ) - zabiera element ze stosu S, koszt O(1)
mpop( S, k ) - zabiera ze stosu min{rozmiar(S), k }elementów,
koszt O(min{rozmiar(S), k })
Zwykle wykonujemy ci¡g n operacji z czasami odpowiednio t1 , . . . , tn i
interesuje nas czas sumaryczny
n
X
t= ti .
i=1

Zamiast konkretnych czasów, przypisujemy koszt zamortyzowany ai do czasu

ti , tak aby
n n
!
ai lub t = O
X X
t= ai
i=1 i=1

28 / 78
Koszt Amortyzowany - Rodzaje
metoda kosztu sumarycznego - okre±la si¦ górne ograniczenie na koszt
n ,
caªkowity, wtedy koszt amortyzowany jednej operacji to T (n)
metoda ksi¦gowa - przypisujemy wi¦kszy koszt pewnym operacjom, dzi¦ki
temu bierzemy niejako kredyt, za pomoc¡ którego mo»emy spªaci¢
wykonanie pó¹nijeszych operacji o rzeczywistym koszcie wi¦kszym ni»
koszt amorytyzowany,
metoda potencjaªu - podobnie jak poprzednio wcze±niejsze operacje maj¡
wy»szy koszt, tak aby mogªy spªaci¢ pó¹niejsze nadmierne "wydatki", z
tym, »e w tej metodzie "kredyt" jest przyznawany za pomoc¡ potencjaªu.

29 / 78
Koszt Amortyzowany - Koszt Sumaryczny
Podej±cie naiwne - prawda, tylko po co:
w czasie wykonania n operacji na stosie pustym, mo»e zosta¢ dodane co
najwy»ej n elementów,
wykonuj¡c operacj¦ mpop(S, k) na stosie co najwy»ej n elementowym
mamy koszt O(n),
poniewa» mo»emy wykona¢ co najwy»ej n operacji mpop, zatem zªo»ono±¢
wynosi n ∗ O(n) = O(n2 ).
Koszt sumaryczny:
ª¡czny koszt nie wi¦kszy ni» O(n),
ka»dy element mo»e by¢ raz wªo»ony i raz ±ci¡gni¦ty,
liczba faktyczna operacji pop nie wi¦ksza ni» ilo±¢ elementów czyli O(n),
±redni koszt amortyzowany O(n)/n = O(1).

30 / 78
Koszt Amortyzowany - Metoda Ksi¦gowa
pewnym operacjom przypisujemy koszt wi¦kszy od faktycznego, wtedy
przy innych operacjach mo»emy skorzysta¢ z kredytu,
Operacja Rzeczywisty Koszt Koszt Amortyzowany
push(S, x) 1 2
pop(S) 1 0
mpop(S, k) min{|S|, k} 0

koszt n operacji nie wi¦kszy ni» 2n,

31 / 78
Koszt Amortyzowany - Metoda Potencjaªu
zamiast reprezentowa¢ nadpªat¦ jako kredyt na pó¹niejsze operacje,
nadpªat¦ traktuj¦ si¦ j¡ jako "energi¦ potencjaln¡", któr¡ mo»na wyzwoli¢
podczas wykonywania pó¹niejszych operacji.
Je±li zaªo»ymy:

φ0 = 0
φi ­ 0
ai = ti + φi − φi−1

to wtedy:
n
X n
X
ai = t i + φn − φ0
i=1 i=1

co poci¡ga za sob¡:
n
X n
X
t = ti ¬ ai
i=1 i=1

32 / 78
Koszt Amortyzowany - Metoda Potencjaªu
Przyjmijmy:
φ(S) = |S|

to wtedy:
Operacja Rzeczywisty Koszt Koszt Amortyzowany
push(S, x) 1 1+1
pop(S) 1 1−1
mpop(S, k) min{|S|, k} min{|S|, k}-min{|S|, k} = 0

koszt n operacji nie wi¦kszy ni» 2n,

33 / 78
Metoda Kompresji
Obliczenie zlo»ono±ci ±redniej, w tradycyjny sposób zwykle jest niezwykle
trudne. "Tradycyjna" metod¡ do tej pory nie udaªo si¦ jeszcze oszacowa¢
zªo»ono±ci ±redniej HeapSort'u.

Zªo»ono±¢ ±redni¡ dla algorytmu HeapSort policzono, dzi¦ki argumentowi

kompresji (zªo»ono±¢ Koªmogorowa).

Przykªady wykorzystanie kompresji (zlo»ono±ci Koªmogorowa):

Liczb pierwszych mniejszych od n jest co najmniej loglog 2n
2 log2 n
.
Liczba Ramseya R(k, k) > e√k 2 2k/2 . Liczba Ramseya R(k, k) okre±la
minimaln¡ liczb¦ wierzchoªków grafu peªnego, z ka»d¡ kraw¦dzi¡
pomalowan¡ na jeden z dwóch kolorów, W którym wystepuje
jednobarwny graf peªny o k wierzchoªkach.
Szacowanie zªo»ono±ci ±redniej algorytmów.

34 / 78
Metoda Kompresji - Ilo±¢ Liczb Pierwszych
Liczb pierwszych mniejszych od n jest co najmniej loglog 2n
2 log2 n
.
dla liczb z zakresu 1 do n potrzeba co najmniej ⌊log2 n⌋ bitów aby
zapisa¢, zakodowa¢ jednoznacznie ka»d¡ z nich. Przykªadowo aby
zapisa¢/zakodowa¢ jednoznaczne wszystkie liczby z zakresu 1 do 14
potrzebujemy co najmniej ⌊log2 14⌋ = 3 bitów.
ka»d¡ liczb¦ 1 ¬ x ¬ n mo»emy jednoznacznie rozªo»y¢ na iloczyn
odpowiednich pot¦g liczb pierwszych 1 ¬ pi ¬ n. Otrzymuj¡c
x = pl11 pl22 . . . plkk , gdzie pi kolejne, wszystkie liczby pierwsze pi ¬ n

Poniewa» pi ­ 2, to :
n ­ x ­ plii ­ 2li to log2 (n) ­ li , zatem log2 log2 (n) ­ log2 (li )

Ka»d¡ liczb¦ 1 ¬ x ¬ n, mo»na zapisa¢/zakodowa¢ podaj¡c jedynie

pot¦gi przy kolejnych liczbach pierwszych l1 , l2 , . . . , lk .
Ka»d¡ liczb¦ 1 ¬ x ¬ n, mo»na zakodowa¢, przy uzyciu k log2 log2 (n)
bitów.
Liczb pierwszych jest co najmniej loglog 2 (n)
2 log2 (n)
w przedziale od 1 do n.
35 / 78
Metoda Kompresji - Liczb Ramsey'a
Oszacowanie liczb Ramsey'a
k
R(k, k) > √ 2k/2
e 2
Je±li w grae o n wierzchoªkach zawsze mamy k elementow¡ klik¦ lub
antyklik¦, to dany graf mo»emy zakodowa¢ na jeden z dwóch sposobów:
Poprzez kodowanie ka»dej z n2 wszystkich mo»liwych kraw¦dzi


1

n
oddzielnie, co daje 2( 2 ) unikalnych mo»liwo±ci, na co potrzeba co
n
najmniej log2 2( 2 ) = n2 bitów.

2 Wykorzystuj¡c informacj¦ o wyst¦powaniu kliki lub antykliki k

elementowej, dany graf mo»emy zapisa¢ nast¦puj¡co:
▶ zapisa¢, czy mamy do czynienia z klik¡ czy antyklik¡: 2 mo»liwo±ci,
▶ zapisa¢, które

wierzchoªki wchodz¡ w skªad k elementowej kliki lub
antykliki: nk mo»liwo±ci,
n k
zakodowa¢ ka»d¡ z pozostaªych n − k kraw¦dzi jest czy nie: 2( 2 )−(2)



▶
2 2
mo»liwo±ci. 
n k 
na co potrzeba log2 2 nk 2( 2 )−(2) = 1 + log2 n n k
bitów.




k + 2 − 2

36 / 78
Metoda Kompresji - Liczb Ramsey'a
Poniewa» dowolny graf mozna zakodowac w jeden z podanych sposobów,
kodowanie za pomoc¡ okre±lenia ka»dej z kraw¦dzi jest unikalne, a kodowanie
za pomoc¡ klik i antyklik niekoniecznie, to st¡d mamy nierówno±¢:
       
n n n k
¬ 1 + log2 + −
2 k 2 2
 
k n
2(2)−1 ¬
k
ne k
Poniewa» n
, to



k ¬ k
k(k−1)    
2 2
( k
)−1 n ne k
= 2 2 ¬ ¬
2 k k
k s
2
√2 k(k−1) r  ne k
2 k 2 2 k ne
√
k
= ¬ =
2 2 k k
k k
√ 22 ¬ n(1 + o(1)) ≈ n
e 2
37 / 78
Algorytmiczna Metoda Kompresji
Metod¦ kompresji mo»na w prosty sposób wykorzysta¢ do szacowania
zlo»ono±ci ±redniej algorytmu.
Informacje o wykonanych krokach przez dziaªaj¡cy algorytm mo»na
wykorzysta¢ do zakodowania danych.
Przykªadowo: Wychodz¡c od ci¡gu posortowanego i odtwarzaj¡c kroki
dziaªania algorytmu sortowania wstecz (od ko«ca do pocz¡tku) mo»na
odtworzy¢ pocz¡tkow¡ permutacj¦ ciagu.
Poniewa» mamy du»o danych (przy sortowaniu n!) to jakikolwiek sposób
kodowania, równie» u»ywaj¡c kodowanie z wykorzystaniem algorytmu,
taki sposób kodowania musi by¢ dªugi (mie¢ du»¡ dªugo±¢).
Z reguªy du»a dªugo±¢ kodowania danych za pomoc¡ algorytmu b¦dzie
poci¡ga¢ za sob¡ dªugi czas dziaªania tego algorytmu dla tych danych.
Je±li udowodnimy, »e wi¦kszo±¢ danych musi mie¢ dªugie kodowanie, to
dzi¦ki powi¡zaniu czasu dziaªania z dªugo±ci¡ kodowania, ta metoda
pozwoli na oszacowanie od doªu zªo»ono±ci ±redniej danego algorytmu.
Uwaga: Korzystaj¡c z tej metody spróbujemy oszacowa¢ zªo»ono±¢ ±redni¡
Binary Search i Heapsort
38 / 78
Troch¦ teorii
Nie wszystkie dane da si¦ skompresowa¢.
Je±li na n bitach mo»emy zapisa¢ 2n ró»nych danych, to na mniejszej
ilo±ci bitów mo»emy zapisa¢ co najwy»ej
1 + 2 + 22 + 23 + . . . + 2n−1 = 2n − 1
ró»nych danych.
Ogólnie, je±li mamy skrócic zapis (skompresowa¢) z n bitów na mniej ni»
n − t bitów, to na n − t bitach mo»emy zapisa¢ co najwy»ej
1 + 2 + 22 + 23 + . . . + 2n−t−1 = 2n−t − 1
ró»nych danych. St¡d natychmiast dostajemy twierdzenie o dªugo±ci
kodów.
Twierdzenie
Je±li przez m oznaczymy liczb¦ danych, to na zakodowanie (1 − c)m spo±ród
tych danych potrzeba co najmniej log2 cm bitów na ka»d¡ dan¡.
Jedynie cm − 1 danych mo»e by¢ zakodowanych na nie wi¦cej ni» log2 (cm)
bitach.
39 / 78
Metoda Kompresji - Wyszukiwanie Binarne
16

8 24

4 12 20 28

2 6 10 14 18 22 26 30

1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31

Wykorzystamy informacj¦ o przebiegu algorytmu wyszukiwania binarnego do

zakodowania liczby 12 i 21:
liczba posta¢ bitowa kodowanie
12 1100 01
21 10101 1010
Za pomoc¡ kodowania wykonania wyszukiwania binarnego, które w naszym
przypadku wykonuje co najwy»ej 5 porówna« (zej±cie o 4 poziomy), mo»na
zakodowa¢ co najwy»ej:
20 + 21 + 22 + 23 + 24 = 31
ró»nych liczb. 40 / 78
Metoda Kompresji - Wyszukiwanie Binarne
16

krótkie kody (7 elementów)

8 24

4 12 20 28

dªugie kody (24 elementy)

2 6 10 14 18 22 26 30

1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31

‘rednia dªugo±¢ kodu:

krótkie kody dªugie kody
z }| { z }| {
(0 × 20 + 1 × 21 + 2 × 22 ) + (3 × 23 + 4 × 24 ) 98
= ≈ 3.1613
31 31
Mo»na oszacowa¢ dªugo±¢ kodowania w klasie krótkich i dªugich kodów.
0 ¬ dªugo±¢ kodu w klasie krótkiej ¬ 2,
3 ¬ dªugo±¢ kodu w klasie dªugiej ¬ 4.
0 × 7 + 3 × 24 krótkie + dªugie 2 × 7 + 4 × 24
2.3226 ≈ ¬ ¬ ≈ 3.5484
31 31 31
41 / 78
Metoda Kompresji - Wyszukiwanie Binarne
16

8 24

4 12 20 28

2 6 10 14 18 22 26 30

1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31

Kodowanie liczby 12 i 21:

liczba posta¢ bitowa kodowanie
12 1100 01
21 10101 1010
Poniewa» dªugo±¢ kodu jest o jeden mniejsza ni» ilo±¢ porówna«, któr¡
wykonaª algorytm wyszukiwania binarnego by wyszuka¢ dan¡ liczb¦, to
rzeczywista ±rednia ilo±¢ porówna« 4.1613, zostaªa t¡ metod¡ oszacowana
przez
±rednia ilo±¢ porówna« w wyszukiwaniu binarnym
3.3226 ¬ ¬ 4.5484
dla 31 elementów
42 / 78
Metoda Kompresji - Wyszukiwanie Binarne(ogólnie)

krótkie kody
cm - elementów
wszystkie kody
m - elementów

dªugie kody
(1 − c)m - elementów

Zapis kodu w klasie dªugiej ma co najmniej ⌊log(cm)⌋ ≈ log(cm) cyfr, gdy» za

pomoc¡ krótszych kodów mo»emy zapisa¢ co najwy»ej
20 + 21 + 22 + . . . + 2⌊log(cm)⌋−1 = 2⌊log(cm)⌋ − 1 ≈ cm − 1

elementów, czyli tyle ile jest w klasie krótszych kodów. Zatem:

0 × cm + log(cm) × (1 − c)m
±rednia dªugo±¢ kodu ­ = log(cm) × (1 − c)
m
43 / 78
Metoda Kompresji - Wyszukiwanie Binarne(ogólnie)
Do ostatniej nierówno±ci
±rednia dªugo±¢ kodu ­ log(cm) × (1 − c)
podstawmy c = log(m) .
1
Wtedy
   
m 1
±rednia dªugo±¢ kodu ­ log × 1−
log(m) log(m)
log log(m)
= log(m) − 1 − log log(m) +
log(m)
= log(m) − O (log log(m))

Poniewa», ilo±¢ porówna« w wysukiwaniu binarnym jest o jeden wi¦ksza od

dªugo±ci kodu, to tym samym dostajemy oszacowanie na ±redni¡ ilo±¢
porówna« w wysukiwaniu binarnym:
±rednia ilo±¢ porówna«
­ log(m) − O (log log(m)) + 1
wyszukiwania binarnego
= log(m) − O (log log(m))
44 / 78
Zlo»ono±¢ ±rednia HeapSort

L.Banachowski, K.Diks, W.Rytter: Algorytmy i Struktury Danych, 2018

"Nie jest znana peªna analiza oczekiwanej zªo»ono±ci

czasowej tego algorytmu (Heapsort).
Wyniki przeprowadzonych bada« wskazuj¡, »e
wspóªczynnik przy n log n jest bliski 2."

990000 Elements Sorted by HeapSort(Williams) in

48.000205265000204
990000 Elements Sorted by QuickSort in 27.064761648000058
HeapSort vs QuickSort: 1.773531423971
AVG HeapSort vs QuickSort: 1.907360701709

45 / 78
Zlo»ono±¢ ±rednia HeapSort
Poka»emy prawdziwo±¢ nast¦puj¡cego twierdzenia
Twierdzenie
‘rednio Heapsort potrzebuje n log2 n + O(n) przesuni¦¢ w obu metodach
przesiewania,
‘rednia ilo±¢ porówna« zale»y od metody przesiewania i wynosi co
najmniej:
▶ 2n log2 n − O(n) przy metodzie Williamsa,
▶ n log2 n + O(n) przy metodzie Floyda,

46 / 78
Przypomnienie - HeapSort(kopcowanie)

Program Procedura testowa

##Test
def BuildHeap( arr, ShiftFun ):
arr=[random.randint(0,10**10) for k in range(100)]
for i in range( (int)(len(arr)/2), 0, -1 ):
#sol=arr.copy()
ShiftFun(arr, i, len(arr))
#sol.sort()
#HeapSort( arr, ShiftWilliams )
def ShiftDown( arr, ShiftFun ):
#assert sol==arr
for i in range( len(arr), 0, -1 ):
arr[i-1], arr[0] = arr[0], arr[i-1]
ShiftFun( arr, 1, i-1)
%load_ext line_profiler
#%timeit -r 100 HeapSort( arr, ShiftWilliams )
def HeapSort( arr, ShiftFun ):
%lprun -f HeapSort HeapSort( arr, ShiftWilliams )
BuildHeap( arr, ShiftFun )
ShiftDown( arr, ShiftFun )

47 / 78
Zlo»ono±¢ ±rednia HeapSort

990000 Elements Sorted by HeapSort(Williams) in

48.000205265000204
990000 Elements Sorted by QuickSort in 27.064761648000058
HeapSort vs QuickSort: 1.773531423971
AVG HeapSort vs QuickSort: 1.907360701709

Wykres czasu wykonania quicksort podobny ksztaªtem do czasu wykonania

Heapsort, to sugeruje, »e zªo»ono±¢ ±rednia Heapsort to Θ(n log2 n).

48 / 78
HeapSort - Test
Test dla 100
Timer unit: 3.0186e-07 s

Total time: 0.00135233 s

File: <ipython-input-1-ae557fec286f>
Function: HeapSort at line 31

Line # Hits Time Per Hit % Time Line Contents

==============================================================
31 def HeapSort(arr, ShiftFun ):
32 1 811.0 811.0 18.1 BuildHeap( arr, ShiftFun )
33 1 3669.0 3669.0 81.9 ShiftDown( arr, ShiftFun )
Test dla 10000
Timer unit: 3.0186e-07 s

Total time: 0.305819 s

File: <ipython-input-1-5d53b62bf167>
Function: HeapSort at line 31

Line # Hits Time Per Hit % Time Line Contents

==============================================================
31 def HeapSort(arr, ShiftFun ):
32 1 88832.0 88832.0 8.8 BuildHeap( arr, ShiftFun )
33 1 924282.0 924282.0 91.2 ShiftDown( arr, ShiftFun )

Poni»sze zestawienie pokazuje, »e czas budowy kopca jest maªo istotny w

stosunku do czasu dziaªania caªo±ci sortowania. Rzeczywi±cie dokªadna analiza
poka»e, »e:
Czas budowy kopca Θ(n),
Czas procedury przesiewania Θ(n log2 n),
Poniewa», »e Θ(n) + Θ(n log2 n) = Θ(n log2 n), to wida¢, »e w szacowaniu
zªo»ono±ci sortowania Heapsort, czas budowy kopca jest maªo istotny i nie
trzeba go dokªadnie szacowa¢. 49 / 78
HeapSort - budowa kopca
Program
def BuildHeap( arr, ShiftFun ):
for i in range( (int)(len(arr)/2), 0, -1 ):
ShiftFun(arr, i, len(arr))

def ShiftDown( arr, ShiftFun ):

for i in range( len(arr), 0, -1 ):
arr[i-1], arr[0] = arr[0], arr[i-1]
ShiftFun( arr, 1, i-1)

def HeapSort( arr, ShiftFun ):

BuildHeap( arr, ShiftFun )
ShiftDown( arr, ShiftFun )

0 1 2 3 4 5 6 7 8 9 10 11

22 13 11 30 71 32 55 15 85 17 20 33

22

13 11

30 71 32 55

15 85 17 20 33

50 / 78
HeapSort - budowa kopca
22 22

13 11 13 11

30 71 32 55 30 71 33 55
zam zam

Krok 1 15 85 17 20 33
Krok 3 15 85 17 20 32

22 22

13 11 13 11 zam

30 71 33 55 85 71 33 55

Krok 2 15 85 17 20 32
Krok 4 15 30 17 20 32

51 / 78
HeapSort - budowa kopca

Krok 5 85

22
71 55

zam 13 55
30 22 33 11

85 71 33 11

Krok 7
zam

15 13 17 20 32

15 30 17 20 32
zam

zam 22

85 zam
zam 55

30 71 33 11

Krok 6 15 13 17 20 32

52 / 78
HeapSort - budowa kopca
Je±li caªe drzewo z lewej strony ma wyso-
ko±¢ h, to zªo»ono±¢ budowy kopca mo»na
zam 22

85 zam
zam 55
wyrazi¢ jak poni»ej.
Krok 6 30 71 33 11
Uwaga: Budow¦ kopca mo»na przeprowa-
15 13 17 20 32 dzi¢ rekurencyjnie za pomoc¡ metody dziel
i zwyci¦»aj.
22

zam 13 55

22

Krok 5
85 zam 71 33 11

15 30 17 20 32
zam

T =
T1 T2

22

(
dla h = 0
13 11 zam

Krok 4 0,
T (h) =
dla h > 0
85 71 33 55
2T (h − 1) + O(h),
15 30 17 20 32

53 / 78
Zlo»ono±¢ Pesymistyczna Tworzenia Kopca w HeapSort
Rozwi¡zuj¡c równanie rekurencyjne na piechot¦ dla h = ⌈log2 n⌉
otrzymamy:
T (h) = 2T (h − 1) + O(h) = 22 T (h − 2) + 2O(h − 1) + O(h) = . . .
= 2h T (1) + 2h−1 O(1) + . . . + 2O(h − 1) + 20 O(h)
 
⌊log2 n⌋
X h
= ⌈2log2 n ⌉O  
2h
h=0

= O(n)
,
Pó¹niej poka»emy, »e ilo±¢ przesuni¦¢ nie przekracza 2n,
Poniewa», jak poka»emy sortowanie Heapsort ma zlo»ono±¢ ±redni¡
Θ(n log2 n) (to zostanie lepiej oszacowane), to koszt budowania kopca
wynosz¡cy pesymistycznie O(n) jest maªo znacz¡cy.
O(n) + Θ(n log2 n) = Θ(n log2 n).
A to oznacza, »e zªo»ono±ci¡ O(n) nie nale»y si¦ zanadto przejmowa¢
szacuj¡c zªo»ono±¢ caªkowit¡ Heapsortu.
54 / 78
Zlo»ono±¢ Pesymistyczna Przesiewania HeapSort
Przesiewanie - zªo»ono±¢ pesymistyczna:
▶ Przy usuni¦ciu jednego z n w¦zªów wykonujemy O(log2 n) operacji, zatem:

T (1) = 0
T (n) = T (n − 1) + O(⌈log2 n⌉) = T (n − 2) + O(⌈log2 n − 1⌉) + O(⌈log2 n⌉)
n
X
= O(⌈log2 k⌉) = O(n log2 n)
k=1

55 / 78
Zªo»ono±¢ ‘rednia Heapsort'u
Twierdzenie
‘rednio Heapsort potrzebuje n log2 n + O(n) przesuni¦¢ w obu metodach
przesiewania,
Ilo±¢ porówna« zalezy od metody przesiewania i wynosi:
▶ 2n log2 n − O(n) przy metodzie Williamsa,
▶ n log2 n + O(n) przy metodzie Floyda,

Dowód na kolejnych slajdach!

56 / 78
Kodowanie Permutacji w HeapSort
Permutacje mo»na zakodowa¢ poprzez wykorzystanie algorytmu
sortowania:
▶ zapisa¢ kolejne kroki algorytmu sortowania permutacji,
▶ odwracaj¡c operacje, odtworzy¢ pocz¡tkow¡ permutacje.
W przypadku sortowania Heapsort, wystarczy zakodowa¢ informacj¦ o
miejscu w¦zªa w kopcu, który ulegnie przesuni¦ciu w danym kroku.
Miejsce w¦zla mo»na zakodowa¢ poprzez podanie ±cie»ki od korzenia
kopca do danego w¦zªa jako sekwencje kroków postaci stop lewo prawo .

Przykªadowo w drzewie
0 1 0 22

1 0 1 85 55

30 71 33 11

15 13 17 20 32

w¦zeª 71, b¦dzie kodowany jako 0 1 0 1 0 1 .

57 / 78
Kodowanie budowy kopca
22 22

13 11 13 11

30 71 32 55 30 71 33 55
zam

1 1 0
15 85 17 20 33 15 85 17 20 32

1 1 0

22 22

1 0 0
13 11 13 11

30 71 33 55 30 71 33 55

15 85 17 20 32 15 85 17 20 32

1 1 0 1 0 0

58 / 78
Kodowanie budowy kopca
22 22

13 11 13 11

1 0 1 30
zam
71 33 55 85 71 33 55

15 85 17 20 32 15 30 17 20 32

1 1 0 1 0 0 1 0 1
22 22

13 11 zam 1 0 1 13 55

85 71 33 55 85 71 33 11

15 30 17 20 32 15 30 17 20 32

1 1 0 1 0 0 1 0 1 1 0 1

59 / 78
Kodowanie budowy kopca
22

0 1 0 zam 13 11

22

1 0 1 85 zam 71 33 55

85 55
15 30 17 20 32
zam

30 71 33 11

15 13 17 20 32

1 1 0 1 0 0 1 0 1 1 0 1 0 1 0 1 0 1
0 1 0 zam 22 85

1 0 1 85 zam
zam 55 71 55

30 71 33 11 30 22 33 11

15 13 17 20 32 15 13 17 20 32

1 1 0 1 0 0 1 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

60 / 78
Dekodowanie permutacji z kopca w HeapSort

1 1 0 1 0 0 1 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

0 1 0 zam 85 22

1 0 1 71 zam
zam 55 85 55

30 22 33 11 30 71 33 11

15 13 17 20 32 15 13 17 20 32

1 1 0 1 0 0 1 0 1 1 0 1 0 1 0 1 0 1
22 22

0 1 0 zam 85 11 13 11

1 0 1 30
zam
zam
71 33 55 85 71 33 55

15 13 17 20 32 15 30 17 20 32

61 / 78
Dekodowanie permutacji z kopca

1 1 0 1 0 0 1 0 1 1 0 1
22 22

13 55 zam 1 0 1 13 11

85 71 33 11 85 71 33 55

15 30 17 20 32 15 30 17 20 32

1 1 0 1 0 0 1 0 1
22 22

13 11 13 11

1 0 1 85
zam
71 33 55 30 71 33 55

15 30 17 20 32 15 85 17 20 32

62 / 78
Dekodowanie permutacji z kopca

1 1 0 1 0 0
22 22

1 0 0
13 11 13 11

30 71 33 55 30 71 33 55

15 85 17 20 32 15 85 17 20 32

1 1 0
22 22

13 11 13 11

30 71 33 55 30 71 32 55
zam

1 1 0
15 85 17 20 32 15 85 17 20 33

63 / 78
Odkodowana permutacja
22

13 11

30 71 32 55

15 85 17 20 33

0 1 2 3 4 5 6 7 8 9 10 11
22 13 11 30 71 32 55 15 85 17 20 33

64 / 78
Kodowanie kopcowania w HeapSort
Podobnie jak poprzednio przy wyliczaniu zªo»ono±ci pesymistycznej, mamy co
najwy»ej ⌈n/2h+1 ⌉ wierzchoªków o wysoko±ci h w kopcu o n wierzchoªkach.
Zatem maksymalna ilo±¢ przesuni¦¢ b¦dzie szacowana przez
⌊log2 n⌋ l n m
X
h .
2h+1
h=0

Poniewa»
∞
X h 1/2
= = 2,
2h (1 − 1/2)2
h=0

to ilo±¢ przesuni¦¢ jest ograniczona z góry przez 2n.

Zatem na zakodowanie caªego przebiegu algorytmu budowy kopca potrzeba

najwy»ej 3 ∗ 2n = 6n bitów (3 bity na jedno przesuni¦cie).
kopcowanie
permutacja −−−−−−−→ kopiec + kodowanie przebiegu kopcowania
65 / 78
Kodowanie przesiewania w HeapSort
Analogicznie kodujemy przesiewanie. Ka»de przesuni¦cie za pomoc¡ 3
bitów.
Je±li w czasie przesiewania wykonamy t kroków, to na ich zakodowanie
potrzeba 3t bitów
Kodowanie przesiewania, wraz z kodowaniem kopcowania umo»liwia
odtworzenie wcze±niejszej permutacji.
przesiewanie−1 kopiec−1
6n + 3t bitów −−−−−−−−−−→ 6n bitów + kopiec −−−−−−→ permutacja

66 / 78
Szacowanie zªo»ono±ci ±redniej ilo±ci przesuni¦¢
Korzystaj¡c z twierdzenia (1), dla c = 21n i m = n!, wiemy, »e do
zapisu co
najmniej (1 − 21n )n! permutacji potrzeba co najmniej log2 21n n! bitów.
Zatem przynajmniej dla (1 − 21n )n! permutacji mamy
 
1
6n + 3t ­ log2 n! = log2 n! − n ­ n log2 n − 2n − n
2n

uzasadnienienie ze wzoru Stirlinga na n! na nast¦pnym slajdzie

67 / 78
Szacowanie zªo»ono±ci ±redniej ilo±ci przesuni¦¢
Korzystaj¡c ze wzoru Stirlinga na n! mo»emy oszacowa¢ warto±¢ log n!.
 n n √
n! = 2πn(1 + o(1))
e
wtedy
log n! ¬ log nn + log (2 ∗ 4 ∗ 2n) ¬ n log n + 4 log n

oraz
log n! ­ n log n − n log e ­ n log n − 2n

co daje oszacowanie:
log n! = n log n ± O(n)

68 / 78
Szacowanie zªo»ono±ci ±redniej ilo±ci przesuni¦¢
W efekcie mamy oszacowanie
1 9 1
t­ n log2 n − n = n log2 n − 3n
3 3 3
dla co najmniej 1 − 2n n! permutacji.
1

Zatem mo»emy szacowa¢ zªo»ono±¢ ±redni¡ ilo±ci przesuni¦¢ od doªu przez

1
n! × ( 13 n log2 n − 3n) + 1


1− 2n 2n n! ×0
n!
czyli
 
1 1 1 1
n log2 n − 3n − n n log2 n − 3n = n log2 n − O(n) ± o(1).
3 2 3 3
Od góry wiemy, »e maksymalna ilo±c przesuni¦¢ jest szacowana przez
n log2 n + O(n).
To troch¦ maªo dokªadne!
Ró»nica mi¦dzy wpóªczynnikami oszacowa« na ilo±¢ przesuni¦¢ przy
najbardziej znacz¡cym skªadniku, czyli mi¦dzy 13 i 1 jest du»a,
poprawiaj¡c kodowanie spróbujemy t¡ ro»nic¦ zmniejszy¢.
69 / 78
Dowód twierdzenia 2
Najpierw lekkie przypomnienie jak wygl¡da wyznaczana jest ±cie»ka do
przesiewania za pomoc¡ przesiewania wg. Floyd'a i William'sa.

Metoda Willimasa jest najcz¦±ciej implementowan¡ i nauczan¡ metod¡ ±ciezki

przesiewania.

Oczywi±cie ilo±¢ przesuni¦¢ przy obu metodach jest dokªadnie taka sama,
natomiast ilo±¢ porówna« najcz¦±ciej znacznie si¦ ró»ni.

70 / 78
Przesiewanie Floyd
32 32

71 ¬ 55?
71 55 71 55

30 22 33 11 30 22 33 11

Krok 1 15 13 17 20 15 13 17 20

32
Krok 3 15 ¬ 13?

32

71 55
32 ¬ 15? 71 55

30 ¬ 22?
30 22 33 11
30 22 33 11

Krok 2 15 13 17 20

Krok 4 15 13 17 20

71 / 78
Przesiewanie Floyd
32 zamiana 32 i 71 71
32 ¬ 30?

71 55 32 55

30 22 33 11 30 22 33 11

Krok 5 15 13 17 20
Krok 7 15 13 17 20

32
32 ¬ 71?

71 55

30 22 33 11

Krok 6 15 13 17 20

72 / 78
Przesiewanie Willimas
32 32

71 ¬ 55?
71 55 71 55

30 22 33 11 30 22 33 11

Krok 1 15 13 17 20
Krok 3 15 13 17 20

32 ¬ 71? 32 zam 32 i 71 71

71 55 32 55

30 22 33 11 30 22 33 11

Krok 2 15 13 17 20
Krok 4 15 13 17 20

73 / 78
Przesiewanie Willimas
71 71

32 ¬ 30? 32 55 32 55

30 22 33 11 30 22 33 11

Krok 5 15 13 17 20
Krok 7 15 13 17 20

71

32 32 ¬ 22? 55

30 22 33 11

Krok 6 15 13 17 20

74 / 78
Dowód Twierdzenia 2

poprzednie kodowanie za sªabe by

udowoodni¢ twierdzenie (3).
lepsze kodowanie
▶ najpier kodujemy liczb¦ δi log2 n − δi

nast¦puj¡co log2 δi jedynek,

log2 n

zero, nast¦pnie liczb¦ δi w

postaci binarnej.
▶ kodujemy ±cie»k¦ od korzenia do δi

w¦zªa na poziomie δi za pomoca

0 id¦ w lewo 1 id¦ w prawo.
Przykªadowo, je±li wysoko±¢ aktualnego kopca wynosi 10, to maj¡c
kodowanie 11101011101111110111 . . . mo»na.
▶ kod podzieli¢ nast¦puj¡co 111|0|101|11011|11 . . ., wtedy:
▶ 111 - liczba δi jest okre±lona na 3 bitach, czyli jest to 101, a wi¦c 5
poszukiwany wierzchoªek jest na poziomie 5 od podstawy kopca, czyli
dªugo±¢ ±cie»ki wynosi wysoko±¢ kopca - poziom na którym ko«czymy
(10 − 5) a zatem 5,
▶ 11011 - oznacza, »e idziemy najpierw dwa razy w prawo, raz w lewo i
znowu dwa razy w prawo.
75 / 78
Dowód Twierdzenia 2
W kroku i algorytm wykona log2 i − δi przesuni¦¢, które mog¡ zosta¢
zakodowane na log2 i − δi + 2⌊log2 δi ⌋ + 1 bitach.
W sumie algorytm wykonuje:
1
X
(⌊log2 i⌋ − δi )
i=n

przesuni¦¢, które kodujemy na

1
X
((⌊log2 i⌋ − δi ) + 2⌊log2 δi ⌋ + 1)
i=n
1
X 1
X 1
X
¬ log2 i − δi + 2 log2 δi + n
i=n i=n i=n
1
X 1
X
= log2 n! − δi + 2 log2 δi + n
i=n i=n

bitach.
76 / 78
Dowód Twierdzenia 2
We¹my 1 − 21n n! permutacji, dla których kodowanie ma co najmniej

log2 2n!n bitów zgodnie z twierdzeniem.

Za pomoca kodowania zdeniowanego na poprzednim slajdzie, mo»emy
zakodowa¢ tak¡ permutacj¦ na
1
X 1
X
6n + log2 n! − δi + 2 log2 δi + n
i=n i=n
bitach. Zatem dla wybranych permutacji
1 1
n! X X
log2 = log 2 n! − n ¬ 6n + log 2 n! − δ i + 2 log2 δi + n
2n i=n i=n
czyli
1
X 1
X
δi − 2 log2 δi ¬ 8n
i=n i=n
a to jest mo»liwe tylko gdy
1
X
δi = O(n).
i=n 77 / 78
Dowód Twierdzenia 2
Zatem dla 1 − 21n n! permutacji, algorytm wykonuje n log(n) + O(n)

przesuni¦¢.
Dla
P1 przesiewania zarówno algorytm Williamsa jak i Floyda wykonuje
i=n (⌊log2 i⌋ − δi ) przesuni¦¢, a tym samym
▶ dla algorytmu Williamsa wykonujemy
1
X
2 (⌊log2 i⌋ − δi ) = 2n log2 n − O(n)
i=n

porówna«.
▶ dla algorytmu Floyda wykonujemy
1 1 1
X X X
(⌊log2 i⌋) + δi = n log2 n + δi + O(n) = n log2 n + O(n)
i=n i=n i=n

porówna«.
Dokªadaj¡c czas potrzebny na utworzenie kopca, daje to dowód
twierdzenia 2.

78 / 78