Scarica Analisi di Algoritmi: Ordinamento, Ricerca e Complessità e più Appunti in PDF di Elementi di Informatica solo su Docsity!
ALGORITMI
Algoritmo: Procedimento di calcolo meccanizzabile, ovvero deve essere eseguibile da una macchina priva di
intelligenza.
Pseudo-codice: programma scritto in modo informale, non in un linguaggio di programmazione.
BUBBLE SORT
Scopo: Ordinare gli elementi di un Array.
Complessità:
Es:
ALGORITMO DI EUCLIDE
Scopo: Trovare il massimo comune divisore tra due numeri.
Iterazioni: nel peggiore dei casi sono .
Complessità:
KNAPSACK
Scopo: Inserire quanti più oggetti, dotati di altezza, in una bisaccia di altezza h.
Pseudo codice:
1 2 3 4 5 6 do the following N-1 times
point the first element
do the following N-1 times
compare the element pointed with the next
if order is wrong, exchange them
point the next element
T (n) = O(n
2 )
Pseudo codice:
1 2 3 4 5 6 read m,n
begin
a,b=m,n
while b 0 di a,b=b, a mod b
end
print
2 log 2
b
T (n) = O(n
2 )
Pseudo codice:
1 2 3 4 5 6 7 v=
for i=1 to n
if H
then = 1
v=v+
h=h-
else
≥n i
x i
v i
h i
x i
Iterazioni: nel peggiore dei casi sono .
Complessità:
NOTAZIONE ASINTOTICA (o di Landau )
Big-O : Notazione utilizzata per valutare la complessità di calcolo di un algoritmo.
Simboli: -
∼ n
2
T (n) = O(n
2 )
O ⇒ ≤
MERGE (A, p, q, r)
L = Array di sinistra R = Array di sinistra —> devono essere ordinati in partenza
Iterazioni: 2(r-p)
Complessità: Lineare
Esempio:
TEOREMA MAESTRO (o PRINCIPALE)
con
Sia se:
- (^) , allora .
- (^) , allora
- (^) , allora .
Es: , —>
, —>
, —>
Pseudo codice:
1 2 3 4 5 6 7 8 9
10
11
12
13
= q-p+1; = r-q
for i= 1 to
do L[i]=A[p+i-1]
for j=1 to
do R[j]=A[q+j]
L[ +1]= ; R[ ]=
i=1; j=
for k= p to r
do if L[i] R[j]
then A[k]=L[i]
i=i+
else A[k]=R[j]
j=j+
n 1
n 2
n 1
n 2
n 1
+∞ n 2
Θ(m)
T (n) = aT (
n
b
a ≥ 1
b > 1
φ (n)
Δ = n
logba[± ε ]
f (n) = O(n
log b
a− ε ) T (n) = Θ(n
log b
a )
f (n) = Θ(n
logba ) T (n) = Θ(n
logba logn)
f (n) = Ω(n
logba+ ε ) + condizione T (n) = Θ( f (n))
T (n) = 9 T (
n
2 [± ε ] T (n) = Θ(n
2 )
T (n) = 9 T (
n
2 φ (n) = n
2 [± ε ] T (n) = Θ(n
2 logn)
T (n) = 9 T (
n
n
2
ln n
φ (n) = n
2 [± ε ]
n
2
ln n
= O(n
2 − ε ) ⇒
n
2
ln n
≤ c(n
2 − ε ) ⇒
n
ε
ln n
≤ c
lim
n→+∞
n
ε
ln n
⇐ lim
n→+∞
ε
ε − 1
1
n
= ε lim
n→+∞
n
− ε
COMPLESSITÀ IN GENERALE
- (^) Normalmente gli algoritmi hanno complessità .
- (^) Nel caso peggiore e nel caso medio è almeno loglineare .
—> per questo Merge Sort è asintoticamente ottimo
GRAFI
Sia ed esiste un insieme formato da coppie ordinate di vertici ( edge ) collegati da archi.
Esempio di grafo:
Grado: numero di archi passanti per
Cardinalità di :
Ciclo: percorso di un arco usato solo una volta, ovvero un percorso chiuso
Grafo connesso: esiste almeno un percorso aperto che congiunge il primo vertice all’ultimo
Albero: grafo connesso senza cicli
il più grande numero di archi necessari per andare dalla radice alle
foglie
Si distinguono in binari, ternari, quaternari etc… in base al numero di figli.
Albero binario completo= si completa da sinistra a destra con un massimo di due archi uscenti da ogni
nodo.
Altezza dell’albero= , asintoticamente
.
Albero binario zeppo= albero binario completo con due archi uscenti da ogni nodo .
Numero nodi in un livello= , quindi in ogni livello ci sono più nodi rispetto a quanti ce ne siano in tutta
la parte precedente del grafo.
Es: n=13 può essere binario completo, ma non zeppo.
n=15 può essere un albero binario zeppo.
HEAP SORT
(Heap= catasta , che viene ordinata dal basso verso l’alto)
Struttura: graph= grafo
A= Array, n=length(A)
Procedure: PARENT(i), LEFT(i), RIGHT(i)
Ω(n)
Ω(nlogn)
0
d eg(a) = 3
d eg(x) = x
k (k − 1 )
= O(k
2 )
h =
h ≤ n ≤ 2
h+ 1 ⇒ h ≤ log 2
n ≤ h + 1 ⇒ h = ⌊log 2
n⌋
h = Θ(logn)
⟺ n = 2
h+ 1 − 1
n = 2
h
n = 10
PARENT(i)
return i/
LEFT(i)
return 2i
RIGHT(i)
return 2i+
A B
C D
Notazione: - length(A)=n oppure heapsize= n
Complessità: , poiché nella notazione O-grande nelle le complessità in serie prevale la
maggiore.
QUICK SORT
Complessità: - nel caso peggiore
—> pivot = “ perno ”
PARTITION(A,p,r)
Iterazioni: nel ciclo for le iterazioni sono i confronti con il perno = #confronti con i perni
QUICK SORT (A,p,r)
Metodo: Ricorsivo
Iterazioni: #cilecche + #confronti con i perni —> nella notazione O-grande= #confronti con i perni
- caso peggiore: (n-1)+(n-2)+(n-3)+…
- caso migliore: 1+1+1+…= n
Complessità: - caso peggiore:
- caso medio: —> sia che
- caso migliore:
PROBABILITÀ
Concezione combinatoria:
Concezione statistica (oggettiva):
Concezione Bayesiana (soggettiva): in base all’esperienza personale
Pseudo codice:
1
2
3
4
5
BUILD-HEAP(A)
for i=n down to 2
do A[1] <—>A[i]
hs[A]=h[A]-
HEAPIFY(A,1)
T (n) = Ω(nlogn)
T (n) = Θ(n
2 )
T (n) = Θ(n)
r =
Pseudo codice:
1 2 3 4 5 6 7 8 x=A[r]
i=p-
for j= p to r-
if A[j] x
then i=j+
A[i] <—>A[j]
A[i+1] <—> A[i]
return i+
Pseudo codice:
1
2
3
4
if p<r
then q=PARTITION (A,p,r)
QUICKSORT(A,p,q-1)
QUICKSORT(A,q+1,r)
T (n) = Θ(n
2 )
T (n) = Θ(nlogn) T (n) = Ω(nlogn) T (n) = O(nlogn)
T (n) = Θ(nlogn)
P(E )
Δ
casi favorevoli
casi possibili
P(E ) ≅
successi
esperimenti
esperimenti ≫ 1
p r
i (^) j
C
S
B
—> eventi.
dove e . Sia un evento composto. Si ha:
- e^ sono disgiunti e si dicono^ incompatibili
-
—> probabilità condizionata
-
- è indipendente da^ è indipendente da^ .
Baricentro:
Varianza:
Scarto quadratico medio:
TRANSFER THEOREM : —> non occorre il calcolo delle distribuzioni
Se e sono indipendenti, allora:
Es:
, , , .
, ,
, ,
, ,
𝒜 = {a 1
, a 2
,... , a k
} 0 < k < 𝒳 0
P = {p 1
, p 2
,... , p k
} p i
n i
n
i
p i
= 1 E = {e 1
,... , e n
P(E ) = 1 − P(E )
P(E or F ) =
n E
− n E and F
n
= P(E ) + P(F ) − P(E and F )
P(E or F ) = P(E ) + P(F ) ⟺ E F
P(E and F ) =
P(E | F ) =
n E∩F
nF
n E∩F
nF
n
n
P(E ∩ F )
P(F )
P(E | F ) = P(E )
E F ⟺ P(E ∩ F ) = P(E )P(F ) = P(F ∩ E ) ⟺ F E
E[X ] =
i
p i
x i
varX = E[(X − μ )
2 ] = E[(X − E X )
2 ]
sqn X = varX
E[Y ] =
i
p i
f (x i
E(X + a) = ∑
i
p i
(x i
var (X + a) = varX
E[a X ] = a E[X ]
var (a X ) = a
2 varX
sqn(a X ) = | a | sqn X
W = X + Y = f (X, Y )
E[W ] = ∑ x,y
px,y f (x, y) = ∑ x
∑ y
px,y f (x + y) = ∑ x
∑ y
px,y x + ∑ x
∑ y
px,y y = ∑ x
x ∑ y
px,y + ∑ y
y ∑ x
px,y = E[X ] + E[Y ]
⇒varX = E[(X − μ )
2 ] = E[X
2 − 2 μ X + μ
2 ] = E[X
2 ] − 2 μ E[X ] + E[ μ
2 ] = E[X
2 ] − E[X ]
2
X Y E[X Y ] = E[X ]E[Y ]
var (X + Y )
indip = varX + varY
X ∈ {0,1} E[X ] = 0 q + 1 p = p E[X
2 ] = 0 q + 1 p = p varX = E[X
2 ] − E[X ]
2 = p − p
2 = pq
Z = X
1
+... + X
n
E[Z ] = n p varZ = n pq
F =
Z
n
EF = p varF =
pq
n
n≫ 1
≅ 0
P{Z = i} = (
n
i )^
= p
i q
n−i 0 ≤ i ≤ n a 1
, a 2
,... , a n
E[Z ] =
n
i= 0
n
i )^
p
i ( 1 − p)
n−i i
ℬ
𝒜
∀a P{X = a} =
1
n
P{X = a | X ∈ ℬ} =
P{X = a, X ∈ ℬ}
P{X ∈ ℬ}
=
0
1
n
k
n
=
1
k
a ∈ ℬ
a ∉ ℬ
Notazione: - k= quantità di ogni numero
- C = Array dove nel ciclo: 1) tutti 0 2) numero di ogni numero 3) numero di numeri
- B = Array
Iterazioni: (k+1)+n+k+n= (k+n)
Complessità: - se
FORMULA DI STIRLING
Siano .
Errore assoluto: , con
Errore relativo: , con
Se l’errore assoluto è trascurabile l’errore relativo è trascurabile (non vale il viceversa)
Scopo: approssimazione
posso controllare
—>
—> NO, infatti
—> SI, hanno quindi lo stesso ordine di grandezza infatti:
Conclusione:
k = O(n) ⇒ k ≪ n ⇒ T (n) = Θ(n)
T (n) = Ω(nlogn)
k = Ω(n) ⇒ k ≫ n ⇒ T (n) = Ω(nlogn)
f (n), g(n) → + ∞
| f (n) − g(n) | → 0 f (n) = g(n) + ε n
f (n)
g(n)
→ 1 f (n) = g(n) + ε n
g(n)
n!
St (n)
Δ = 2 π n (
n
e
n
n! ≅ St (n) ⇒ lim
St (n)
n!
n!
St (n)
11 n
⇒ n!
Θ(n!) = Θ 2 π n (
n
e
n
Θ(n!)
? = Θ(n
n ) ⇒ lim
n!
n
n
= 0 ⇒ Θ(n!) ≠ Θ(n
n )
Θ(log(n!))
? = Θ(log(n
n )) = Θ(nlogn)
n!
St (n)
St (n) ≤ n! ≤ 2 St (n) ⇒ log 2
St (n) − 1 ≤ log 2
n! ≤ log 2
St (n) + 1
[ 0 + log 2
n
n − log 2
e
n ] ≤ log 2
n! ≤ 2 log 2
2 π n + 2 log 2
n
n − 2 log 2
e
n
log 2
n
n ≤ log 2
n! ≤ 4 log 2
n
n ⇒
nlog 2
n ≤ log 2
n! ≤ 4 nlog 2
n
⇒ Θ(logn!) = Θ(nlogn)
