TECNICA DIVIDE ET IMPERA. 5 2 8 0 4 7 1 9 3 2 6 0 47255 285 2 80 4 75 2 8 0 4 71 9 3 2 62 61 9 31 93629140 5 2 8 0 4 7 1 9 3 2 6 5 2 8 0 4 71 9 3 2 6.

Presentazione sul tema: "TECNICA DIVIDE ET IMPERA. 5 2 8 0 4 7 1 9 3 2 6 0 47255 285 2 80 4 75 2 8 0 4 71 9 3 2 62 61 9 31 93629140 5 2 8 0 4 7 1 9 3 2 6 5 2 8 0 4 71 9 3 2 6."— Transcript della presentazione:

1 TECNICA DIVIDE ET IMPERA

2 5 2 8 0 4 7 1 9 3 2 6 0 47255 285 2 80 4 75 2 8 0 4 71 9 3 2 62 61 9 31 93629140 5 2 8 0 4 7 1 9 3 2 6 5 2 8 0 4 71 9 3 2 6 5 2 80 4 72 61 9 3 5 28 25 0 471 93 4091 62 0 1 2 2 3 4 5 6 7 8 9 0 2 4 5 7 8 2 5 8 2 5 52 8 1 2 3 6 9 0 4 72 61 3 9 0 471 93 4091 62 Soluzione2: Algoritmo Merge-Sort

3 Merge-Sort(A,p,r) if p < r q =  (p+r)/2  Merge-Sort(A,p,q) Merge-Sort(A,q+1,r) Merge(A,p,q,r)

4 L 0 2 4 5 7 81 2 3 6 9 0 2 4 5 7 8  1 2 3 6 9  R A[p..q]A[q+1..r] 0 2 4 5 7 8  1 2 3 6 9  0 1 2 4 5 7 8  2 3 6 9  0 1 2 4 5 7 8  2 3 6 9  0 1 2 2 4 5 7 8  3 6 9  0 1 2 2 3 4 5 7 8  6 9  0 1 2 2 3 4 5 7 8  6 9  0 1 2 2 3 4 5 7 8  6 9  0 1 2 2 3 4 5 6 7 8  9  0 1 2 2 3 4 5 6 7 8  9  0 1 2 2 3 4 5 6 7 8  9  0 1 2 2 3 4 5 6 7 8 9   A[p..r]

5 Merge(A,p,q,r) n 1 = q – p + 1 n 2 = r – q for i = 1 to n 1 L[i] = A[p + i – 1] for j = 1 to n 2 R[j] = A[q + j] L[n 1 + 1] = R[n 2 + 1] =  i = j = 1 for k = p to r if L[i]  R[j] A[k] = L[i] i = i + 1 else A[k] = R[j] j = j + 1

6 Merge-Sort(A,p,r) if p < r // altrimenti A[p..r] è ordinato q =  (p+r)/2  Merge-Sort(A,p,q) Merge-Sort(A,q+1,r) Merge(A,p,q,r) Analisi di Merge-Sort: correttezza non ordinati 1 p rn A ordinati 1 p rn A 1 p rn q A

7 Merge(A,p,q,r) n 1 = q – p + 1 n 2 = r – q for i = 1 to n 1 L[i] = A[p + i – 1] for j = 1 to n 2 R[j] = A[q + j] L[n 1 + 1] = R[n 2 + 1] =  i = j = 1 for k = p to r if L[i]  R[j] A[k] = L[i] i = i + 1 else A[k] = R[j] j = j + 1 1 p rnq A 1 p rn A L ∞ R ∞ 1n1n1 1n2n2 1 p rn A L ∞ R ∞ 1n1n1 1n2n2 k ij 1 p rn A L ∞ R ∞ 1n1n1 1n2n2 k ij

8 Merge(A,p,q,r) // complessità// n 1 = q – p + 1// n 2 = r – q// for i = 1 to n 1 // L[i] = A[p + i – 1]// for j = 1 to n 2 // R[j] = A[q + j]// L[n 1 + 1] = R[n 2 + 1] =  // i = j = 1// for k = p to r // if L[i]  R[j]// A[k] = L[i]// i = i + 1// else A[k] = R[j]// j = j + 1//

9 Merge-Sort(A,p,r) //complessità// if p < r // q =  (p+r)/2  // Merge-Sort(A,p,q) // Merge-Sort(A,q+1,r)// Merge(A,p,q,r) //

10

11 Dunque esiste N tale che per ogni n > N. Qualunque siano i valori delle costanti a', b', c', a", b" e c" l’algoritmo Merge-Sort è superiore a Insertion-Sort per array di dimensione sufficientemente grande.

12 Possiamo dire che “cresce come” n 2 mentre “cresce come” n log 2 n. nn2n2 n log 2 n IS n 2 ns MS n log 2 n ns 1010033 0.1  s0.033  s 10010000664 10  s0.664  s 100010 6 99651ms 10  s 1000010 8 1328770.1s 133  s 10 6 10 12 2·10 7 17m20ms 10 9 10 18 3·10 10 30s10 9 10 18 3·10 10 70anni30s

13 dunque esiste N tale che per ogni n > N. Qualunque siano i valori delle costanti a', b', c', a", b" l’algoritmo Insertion-Sort è superiore a Merge-Sort per array (quasi) ordinati e sufficientemente grandi.

14 Insertion-Sort è anche superiore a Merge-Sort per array piccoli in quanto le costanti a', b', c' in sono generalmente molto maggiori delle costanti a", b" e c" in. Questo suggerisce una modifica di Merge-Sort in cui le porzioni di array di dimensione minore di una certa costante k si ordinano con Insertion-Sort invece di usare ricorsivamente Merge-Sort.

15 Soluzione3: Algoritmo Merge-Ins-Sort Merge-Ins-Sort(A,p,r) if p < r if r-p+1 < 32 InsertSort(A,p,r) else q =  (p+r)/2  Merge-Ins-Sort(A,p,q) Merge-Ins-Sort(A,q+1,r) Merge(A,p,q,r)