1

a1:a2

a2:a3 a1:a3

<a2,a1,a3> a2:a3

<a1,a3,a2> <a3,a1,a2> <a2,a3,a1> <a3,a2,a1>

a1:a3

Insertion-Sort

<a1,a2,a3>

a1:a2

a1:a3 a2:a3

<a2,a1,a3>

a1:a2

<a1,a3,a2> <a3,a1,a2> <a2,a3,a1><a3,a2,a1>

a2:a1

Selection-Sort

<a1,a2,a3>

a2:a3 a1:a3

2

Esercizio 2

Consideriamo una funzione f(n) tale che:

f(n) = (n log2(n))

La relazione precedente implica anche:

f(n) = (n logB(n)) B = base generica

-----------------------------------------

Infatti:

f(n) = (n log2(n)) c, n0 > 0 tali che n n0

0 c n log2(n) f(n)

Notiamo che:

log2(n) = logB(n) / logB(2)

Posso definire c’ = c / logB(2). Vale allora la relazione:

n n0 0 c’ n logB(n) f(n)

Da cui segue: f(n) = (n logB(n))

3

Esercizio – Fusione di due sequenze ordinateConsiderare il problema della fusione di 2 sequenze ordinate di lunghezza n/2 in una sequenza ordinata di lunghezza n. Scrivere un algoritmo, analizzarne la complessità, valutare se l’algoritmo scritto è un algoritmo ottimale.

Merge1(A,B)For i 1 to n/2 do C[i] A[i]

C[n/2+i] B[i]Insertion-Sort(C)

Alcune domande preliminari:

- Lower bound ? Boh…quello banale è pari ad Ω(n)- Upper bound ? Vediamo…parto con un algoritmo banale

-L’algoritmo è corretto?SI

- Complessità temporale e spaziale dell’algoritmo?O(n2), come l’Insertion Sort

- L’algoritmo è ottimale?

Direi di NO…

4

Un altro algoritmo di fusione…

Merge2(A,B)i 1j 1While (i n/2) and (j n/2) do if (A[i] < B[j]) then C[i+j-1] A[i] i i + 1 else C[i+j-1] B[j] j j + 1If (i > n/2) then for k j to n/2 do C[k+n/2] B[k] else for k i to n/2 do C[k+n/2] A[k]

-L’algoritmo è corretto?SI

- Complessità temporale e spaziale dell’algoritmo?O(n)

- L’algoritmo è ottimale?

SI!!

5

Algoritmi di ordinamento ottimali

Problema dell’ ordinamento per confronto:

Lower bound - (n log(n)) considerazioni teoriche

Upper bound – O(n2) IS,SS

Proviamo a costruire un algoritmo ottimale.

Notiamo che:

IS e SS utilizzano un approccio incrementale

alla k-esima iterazione essi producono una sequenza ordinata di k elementi

6

Approccio divide-et-impera (divide-and-conquer)

- Il problema è diviso in un certo numero di sotto-problemi (divide)

-I sottoproblemi vengono risolti separatamente (impera);

- Le soluzioni dei sottoproblemi vengono combinate per ottenere la soluzione del problema iniziale (combina).

L’ approccio incrementale non è l’unico approccio possibile:

7

Algoritmo Merge-Sort

Merge-Sort(A, p, r)If (p < r) then q = (p+r)/2 Merge-Sort(A, p,q) Merge-Sort(A, q+1, r) Merge(A, p, q, r) Merge(A, p, q, r) Assume che: A[p …… q] ordinata A[q+1 …… r] ordinata

Genera: A[p …… r] ordinata

Funzionamento del Merge-Sort per n=8: valore dei parametri p,r

1,8

1,4 5,8

5,6 7,8

3,3 4,4 7,7 8,8

1,2 3,4

Merge-Sort

1,1 2,2 5,5 6,6

p,r

Per ordinare A si lancia Merge-Sort(A,1,n)

8

Funzionamento del Merge-Sort: progressione delle chiamate ricorsive

p1 =1r1 =8q1 =4

p2 =1r2 =4q2 =2

p2 =5r2 =8q2 =6

p3 =5r3 =6q3 =5

p3 =7r3 =8q3 =7

p4 =3r4 =3q4 =

p4 =4r4 =4q4 =

p4 =7r4 =7q4 =

p4 =8r4 =8q4 =

p3 =1r3 =2q3 =1

p3 =3r3 =4q3 =3

Merge-Sort

p4 =1r4 =1q4 =

p4 =2r4 =2q4 =

p4 =5r4 =5q4 =

p4 =6r4 =6q4 =

9

Funzionamento del Merge-Sort: un esempio

5,2,4,6,1,3,8,7

5,2,4,6 1,3,8,7

1,3 8,7

4 6 8 7

5,2 4,6

Merge-Sort

5 2 1 3

2,5 4,6

2,4,5,6

1,3 7,8

1,3,7,8

1,2,3,4,5,6,7,8

n = 8A = < 5,2,4,6,1,3,8,7 >

10

Complessità temporale del Merge Sort

Ci aspettiamo che il comportamento asintotico del Merge-Sort sia migliore del comportamento asintotico di IS e SS. Infatti, l’approccio ricorsivo dovrebbe aggirare i problemi indotti dall’approccio incrementale.

Merge-Sort(A, p, r)If (p < r) then q = (p+r)/2 Merge-Sort(A, p,q) Merge-Sort(A, q+1, r) Merge(A, p, q, r)

11

Merge-Sort(A, p, r)If (p < r) then q = (p+r)/2 Merge-Sort(A, p,q) Merge-Sort(A, q+1, r) Merge(A, p, q, r)

Complessità temporale del Merge-Sort

Il Merge-Sort è un algoritmo ricorsivo Il tempo di esecuzione del MS verifica un equazione di ricorrenza

Tms(n) = d(n) + 2*Tms(n/2) + c(n)

d(n) tempo necessario a dividere in (1) 2 sequenze lunghe n/2 c(n) tempo necessario per combinare (n) 2 sequenze ordinate di n/2 elementi (Merge())

Tms(n) = 2 *Tms(n/2) + f(n)

f(n) = d(n) + c(n) = (n)

Questa equazione vale per tutti i valori di n eccetto che per n=1:

Notare: Se conoscessi Tms(n/2), potrei determinare Tms(n).

12

Teorema principale

Siano a, b,c costanti non negative. La soluzione dell’ equazione di ricorrenza:

T(n) = b per n = 1aT(n/c) + b n per n > 1

è:

Θ(n) se a < cT(n)= Θ(n log n) se a = c Θ(n logca) se a > c

13

Nel caso del Merge-Sort, a=b=2

La complessità temporale dell’algoritmo Merge-Sort è:

T(n) = (nlogn)

Ciò implica che l’algoritmo Merge-Sort è un

algoritmo di ordinamento ottimale!!