Complexitatea algoritmilor.

Sortare - continuare
O problemă – mai multe variante de rezolvare Factori care determină alegerea
Care algoritm e mai bun? Cum alegem? Timp de execuție

Nr. de operații primitive: ex. comparații

Dimensiunea datelor de intrare: nr. de elemente (masive), nr. de biți (operații aritmetice), nr. de muchii și
vîrfuri (grafuri)
Sursa datelor
Spațiu de memorie utilizat
ex. sortare „pe loc” / „în spațiu separat”
Echipamente

Exemplu: Sortare vector cu 10 mil. elemente

2∙(10 7)2
SC =20000 sec .=5 h :33 m:20 s
1010
50∙ 107 ∙ log ⁡(107 )
PC =1162.7 sec .=0 h :19 m:22.67 s
107
Obs.: pentru masive de dimensiuni mici, sortarea prin inserare e mai rapidă decît cea prin interclasare →
se pot combina
Pentru compararea algoritmilor - indicatori de complexitate, calculați la nivel teoretic, independent de
echipament

Timpul de execuție este măsurat prin timpii operațiilor primitive și este funcție de dimensiunea datelor
Timpul de execuție depinde și de valori concrete ale datelor: cel mai bun (favorabil) caz / caz mediu
(uzual) / cel mai rău (nefavorabil) caz
Analiza pentru dimensiuni mari ale datelor de intrare
Calculul timpul de execuție exact nu e eficient sau necesar
Termenul de rang maxim domină ceilalți termeni→ este factorul relevant, este singurul luat în calcul și se
numește ordin de creștere
Ordin de creștere (complexitate) mai mic în cel mai defavorabil caz → algoritm mai bun
Dacă ordinul de creștere este factor relevant → analiza este referită prin studiul eficienței asimptotice
Eficiență asimptotică mai bună → algoritm mai bun (eventual cu excepția cazurilor extreme)
 Ordin de creștere

Notația asimptotică Θ ( … ) limită superioară și inferioară strînsă

Θ ( g ( n ) )= {f ( n ) ∨∃c 1 , c 2 , n0 a .î . 0 ≤ c1 ∙ g ( n ) ≤ f ( n ) ≤ c 2 ∙ g ( n ) , ∀ n ≥ n0 }

g- limită asimtotică strânsă pentru f

Exemplu

f ( n )=3 n2−2n f ( n ) ∈ Θ ( n2 ) f ( n )=Θ ( n2 )

c 1 ∙ n2 ≤ 3 n2−2 n ≤c 2 ∙n 2 , ∀ n ≥n 0 ¿ n2
2 2
c 1 ≤ 3− ≤ c 2 → 3− ∈¿ → c 1=1, c 2=3 , n0 =1
n n
Exemplu

h ( n ) =2 n3 h ( n ) ∈Θ ( n2 ) ? c 1 ∙ n2 ≤ 2n3 ≤ c 2 ∙ n2 , ∀ n ≥ n0

c 1 ≤ 2 n ≤ c2 c 1=1, n0 =1 lim n=∞ → c =? Obs.:

n→∞ 2

c22*g(n)
• Coeficientul termenului de rang maxim

f(n)

c11*g(n)

n00 n
 • Afectează doar c 1 și c 2 cu un factor constant → se poate ignora
• Restul formulei
• compensată prin ajustarea c 1 și c 2 → se
poate ignora
0
• Θ ( 1 ) sau Θ ( n ) → timp de execuție constant
• Notația asimptotică O ( … ) limită superioară
• O ( g ( n ) )= {f ( n ) ∨∃c ,n 0 a. î . f ( n ) ≤ c ∙ g ( n ) , ∀ n ≥ n0 }
• g- limită asimtotică superioară pentru f
• Timp de execuție pentru cel mai nefavorabil caz c*g(n)
• Θ ( g ( n ) ) ⊆O ( g ( n ) )
• f ( n )=n f ( n ) ∈ O ( n ) f ( n ) ∈ O ( n2 ) f ( n ) ∈ O ( n3 ) f(n)
…
• Notația asimptotică Ω ( … ) limită inferioară
• Ω ( g ( n ) ) ={f ( n )∨∃c , n0 a . î . 0 ≤ c ∙ g ( n ) ≤ f ( n ) , ∀ n ≥ n0 }
• g- limită asimtotică inferioară pentru f
• Timp de execuție pentru cel mai favorabil caz
n00 n

Sortare rapidă
Q(x, p,u)
dacă p<u
k=poziționare(x, p, u)
Q(x, p, k-1)
Q(x, k+1, u)

*poziționare(x, p, u)
indi=0; indjj=-1; i=p; j=u;
while i<j
if x[i]>x[j]
x[i] <-> x[j]
if indi==0
indi=1; indj=0;
else
indi=0; indj=-1;
i=i+indi;j=j+indj;
return i (k=i)
Analiza complexității
Cel mai defavorabil caz - poziționarea produce de fiecare dată o secvență cu u-p elemente și secvența vidă
Fie n=u− p+1.
Costul poziționării - Θ ( n )
Costul sortarii secvenței vide - Θ ( 1 )
T R ( n ) =T R ( n−1 ) +Θ ( n ) →T R ( n )=O ( n2 )
Cel mai bun caz - fiecare partiție determină împărțirea secvenței inițiale în două subsecvențe balansate.
Rezultă
n
()
T B ( n )=2 ∙ T B
2
+Θ ( n ) →T B ( n ) =O ( n ∙ log ( n ) )

Sortare rapidă cu factor aleator

Sortare rapidă cu factor aleator
Introducerea unui factor aleator înainte de sortare - evită apariția cazului cel mai nefavorabil (chiar și
apropiat de cel mai nefavorabil)
Factor aleator în alegerea punctului de împărțire din secvența curentă
Interschimbă primul element (pivotul) cu altul ales aleator
Noul prim element din secvență este poziționat conform metodei quick sort
Cele două subsecvențe determinate de poziția pivotului sunt în medie relativ echilibrate ca număr de
elemente

Poziționare_rand( a, p, u) Qsort_rand( a, p, u)
nou = random(p,u) if p<u
a[p] ↔ a[nou]; poz = Poziționare_rand(a,p,u)
poz = poziționare (a, p, u) Qsort_rand(a, p, poz-1)
Qsort_rand(a, poz+1,u)