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)

L

0 2 4 5 7 8 1 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]

Merge(A,p,q,r) n1 = q – p + 1 n2 = r – q for i = 1 to n1

L[i] = A[p + i – 1] for j = 1 to n2

R[j] = A[q + j] L[n1 + 1] = R[n2 + 1] = i = j = 1 for k = p to r

if L[i] R[j] A[k] = L[i]

i = i + 1else A[k] = R[j]

j = j + 1

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 ordinati1 p r n

A

ordinati1 p r n

A

ordinati1 p r n

ordinatiq

A

Merge(A,p,q,r)

n1 = q – p + 1 n2 = r – q for i = 1 to n1 L[i] = A[p + i – 1] for j = 1 to n2 R[j] = A[q + j] L[n1 + 1] = R[n2 + 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 r nqA

1 p r nA

L ∞ R ∞1 n1 1 n2

1 p r nA

L ∞ R ∞1 n1 1 n2

k

i j

1 p r nA

L ∞ R ∞1 n1 1 n2

k

i j

Merge(A,p,q,r) // complessità // n1 = q – p + 1 // n2 = r – q // for i = 1 to n1 // L[i] = A[p + i – 1] // for j = 1 to n2 // R[j] = A[q + j] // L[n1 + 1] = R[n2 + 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 //

1c2c3c 114 nc

15nc 124 nc

25nc6c

2/)( rpq

211nc

7c 18 nc

111nc

nc9

110nc

210nc

1 prn

2/1 nn

2/2 nn

21 nnn

''

2

)()(

8764321

11109854

bna

ccccccc

nccccccnT M

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) //

1c

2c

3c

1nT MS

2nT MS

'' bnanT M

1 prn

1 se)()()(

1 se)(

21321

21

nnTnTnTccc

nccnT MMSMS

MS

11 pqn

qrn 2

21 nnn

1 se)()(

1 se)(

21 nnTnTban

ncnT MSMS

MS

cnnbnannT MS )1(log2

ban 1,1 ban 2,1 ban 1,2ban 2,2

n2log

c c c c c cc c c c c c

ban

ban 2

ban 4

cn

1 se

1 se

21 nnTnTban

ncnT MSMS

MS

ban 1nT MS 2nT MS

ban 1

1,1nT MS 2,1nT MS

ban 2

1,2nT MS 2,2nT MS

''log' 2 cnbnnanT MS

0

"""

''log'limlim

22

cnbna

cnbnna

nT

nTnIS

med

MS

n

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.

nTnT ISmed

MS

''log' 2 cnbnnanT MS

""")( 2 cnbnanT ISmed

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

nT ISmed

nT MS

n n2 n log2 nIS

n2 nsMS

n log2 n ns

10 100 33 0.1s 0.033s100 10000 664 10s 0.664s

1000 106 9965 1ms 10s10000 108 132877 0.1s 133s

106 1012 2·107 17m 20ms

109 1018 3·1010 30s109 1018 3·1010 70anni 30s

""

''log'limlim 2

bna

cnbnna

nT

nTnIS

min

MS

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.

nTnT ISmin

MS

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 .

nT MS

nT ISmax

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.

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)

Soluzione: Algoritmo Heap-Sort

Un array A[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]

a10 a11a9 a12

a2

a8

a4 a5 a6 a7

a3

a1

a1 a2 a12a3 a4 a5 a6 a7 a8 a9 a10 a11

1002

12

102 112

1012

1 2 3 4 5 6 7 8 9 10 11 12

11002

1102 1112

10002 10012 10102 10112

Albero binario quasi completo

“A[i] è maggiore o uguale di ogni suo discendente in A[1..n]”

Proprietà di un heap (mucchio)

Diciamo che A[1..n] è un (è ordinato a) max-heap se ogni elemento A[i] soddisfa la seguente proprietà:

Per brevità indicheremo questa proprietà con H(i)

6 13 2

8

4

5 7 4 0

7

9

9 8 27 5 7 4 0 4 3 6 1

4

1

2 3

5

1 2 3 4 5 6 7 8 9 10 11 12

12

6 7

8 9 10 11

Un max-heap

7 13 4

6

4

8 9 2 7

0

5

5 6 40 8 9 2 7 4 3 7 1

4

1

2 3

5

1 2 3 4 5 6 7 8 9 10 11 12

12

6 7

8 9 10 11

2

2

4

2

24

2

9

9 2

98

8 9

8

0

0 8

7

0

07

0

6

6 0

9

6

69

7

6

67

6

5

5 6

9

5

59

8

5

58

5

5

Costruzione di un max-heap