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

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

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

Merge(A,p,q,r) n1 = q – p + 1 n2 = r – q fori = 1 ton1 L[i] = A[p + i – 1] forj = 1 ton2 R[j] = A[q + j] L[n1 + 1] = R[n2 + 1] =  i = j = 1 fork = ptor ifL[i] R[j] A[k] = L[i] i= i + 1 else A[k] = R[j] j = j + 1

A non ordinati p 1 r n A ordinati ordinati p q r n 1 A ordinati p 1 r n Analisi di Merge-Sort: correttezza Merge-Sort(A,p,r) ifp<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)

A p 1 r n k L R ∞ ∞ 1 n1 1 n2 i j A p q r n 1 A p 1 r n A L R ∞ ∞ p 1 r n k 1 n1 1 n2 L R ∞ ∞ 1 n1 1 n2 i j Merge(A,p,q,r) n1 = q – p + 1 n2 = r – q fori = 1 ton1 L[i] = A[p + i – 1] for j = 1 ton2 R[j] = A[q + j] L[n1 + 1] = R[n2 + 1] =  i = j = 1 fork = ptor ifL[i] R[j] A[k] = L[i] i = i + 1 else A[k] = R[j] j = j + 1

Merge(A,p,q,r) // complessità// n1 = q – p + 1 // n2 = r – q// fori = 1 ton1// L[i] = A[p + i – 1] // forj = 1 ton2// R[j] = A[q + j] // L[n1 + 1] = R[n2 + 1] = // i = j = 1 // fork = ptor// ifL[i] R[j] // A[k] = L[i] // i = i + 1 // else A[k] = R[j] // j = j + 1 //

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

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.

Possiamo dire che “cresce come” n2 mentre “cresce come” n log2 n.

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.

Insertion-Sort è anche superiore a Merge-Sort per arraypiccoli 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-Sortinvece di usare ricorsivamente Merge-Sort.

Soluzione3: Algoritmo Merge-Ins-Sort Merge-Ins-Sort(A,p,r) ifp<r ifr-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)

Soluzione: Algoritmo Heap-Sort • Un arrayA[1..n] può essere interpretato come un albero binario: • A[1] è la radice, • A[2i] e A[2i+1] sono i figli di A[i] • A[ i / 2 ] è il padre di A[i]

a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 1 2 3 4 5 6 7 8 9 10 11 12 Albero binario quasi completo 12 102 112 1002 1012 1102 1112 10002 10012 10102 10112 11002

Proprietà di un heap (mucchio) Diciamo che A[1..n] è un (è ordinato a) max-heap se ogni elemento A[i] soddisfa la seguente proprietà: “A[i] è maggiore o uguale di ogni suo discendente in A[1..n]” Per brevità indicheremo questa proprietà con H(i)

9 8 7 5 7 4 0 4 3 6 1 2 9 8 7 5 7 4 0 4 3 6 1 2 Un max-heap 1 2 3 4 5 6 7 8 9 10 11 12 1 2 3 4 5 6 7 8 9 10 11 12

5 6 0 8 9 2 7 4 3 7 1 4 9 5 6 9 8 5 0 7 5 8 8 5 9 9 6 7 2 4 0 0 6 6 2 2 9 5 9 5 8 6 0 7 8 5 5 8 7 9 6 9 2 4 0 0 6 6 2 2 Costruzione di un max-heap 1 2 3 4 5 6 7 8 9 10 11 12 5 1 6 0 2 3 8 9 2 7 4 5 6 7 4 3 7 1 4 8 9 10 11 12

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