Ordinamento per inserzione e per fusione

Transcript

1 Ordinamento per inserzione e per fusione Alessio Orlandi 15 marzo 2010

2 Fusione: problema Problema Siano A e B due array di n A e n B interi rispettivamente. Si supponga che A e B siano ordinati in modo non decrescente. Si crei C, l array contenente gli elementi di A e B, ordinato in modo non decrescente. Esempio: A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7, 7, 8, 10, 13, 14

3 Fusione: problema Problema Siano A e B due array di n A e n B interi rispettivamente. Si supponga che A e B siano ordinati in modo non decrescente. Si crei C, l array contenente gli elementi di A e B, ordinato in modo non decrescente. Esempio: Con le carte viene meglio A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7, 7, 8, 10, 13, 14

4 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C =

5 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2,

6 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4,

7 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5,

8 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7,

9 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7, 7,

10 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7, 7, 8,

11 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7, 7, 8, 10, Casi limite: terminata una lista, l altra si copia.

12 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7, 7, 8, 10, 13, Casi limite: terminata una lista, l altra si copia.

13 Fusione: soluzione Intuzione: osserviamo 2 elementi alla volta, spostiamo il più piccolo in output e avanziamo il suo array. A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7, 7, 8, 10, 13, 14 Casi limite: terminata una lista, l altra si copia.

14 Fusione: pseudocodice void merge ( i n t A, i n t na, i n t B, i n t nb, i n t C) { i n t Acur = 0, Bcur = 0, Ccur = 0 ; / Corpo p r i n c i p a l e. / while ( Acur < na && Bcur < nb ) i f ( A[ Acur ] <= B[ Bcur ] ) C [ Ccur++] = A[ Acur ++]; e l s e C [ Ccur++] = B[ Bcur ++]; / Una l i s t a t e r m i n a t a. / while ( Acur < na ) C [ Ccur++] = A[ Acur ++]; while ( Bcur < nb ) C [ Ccur++] = B[ Bcur ++]; }

15 Fusione: complessità QUIZ! Sia n = n A + n B. La complessità al caso pessimo di merge è: O(log n) O(n) O(n 2 )

16 Fusione: complessità QUIZ! Sia n = n A + n B. La complessità al caso pessimo di merge è: O(log n) O(n) O(n 2 ) Dimostriamolo..

17 Fusione in O(n) - I Abbiamo la complessità del ciclo principale: while ( Acur < na && Bcur < nb ) i f ( A[ Acur ] <= B[ Bcur ] ) C [ Ccur++] = A[ Acur ++]; e l s e C [ Ccur++] = B[ Bcur ++]; E quella di uno dei due cicli successivi: while ( Acur < na ) C [ Ccur++] = A[ Acur ++]; while ( Bcur < nb ) C [ Ccur++] = B[ Bcur ++]; Le due complessità si sommano

18 Fusione in O(n) - Limiti Liste terminate while ( Acur < na ) C [ Ccur++] = A[ Acur ++]; while ( Bcur < nb ) C [ Ccur++] = B[ Bcur ++]; Nel primo ciclo, copio un array: f 1 (n A ) O(n A ). Nel secondo ciclo, copio un array: f 2 (n B ) O(n B ). Complessità totale: O(n A ) + O(n B ) O(n): x t.c. f 1 (n A ) x n A. y t.c. f 2 (n B ) y n B. Se z = x + y, f 1 (n A ) + f 2 (n B ) z (n A + n B ) z n O(n).

19 Fusione in O(n) - principale while ( Acur < na && Bcur < nb ) i f ( A[ Acur ] <= B[ Bcur ] ) C [ Ccur++] = A[ Acur ++]; e l s e C [ Ccur++] = B[ Bcur ++]; A = 4, 7, 8, 13, 14 B = 2, 5, 7, 10 C = 2, 4, 5, 7, 7, 8, 10, 13, 14 Intuizione: il numero di iterazioni max Ccur, ovvero n A + n B = n. O(1) operazioni per ogni iterazione del ciclo La complessità del ciclo principale è O(n).

20 Ordinamento per inserzione

21 Ordinamento - motivazione Problema Sia A un array di n interi > 0, ordinati in modo non decrescente. Si fornisca il numero di elementi distinti contenuti all interno dell array Esempio: A = 3, 3, 6, 6, 6, 8, 8, 8. Facile! Soluzione già vista, in O(n).

22 Ordinamento - motivazione Problema Sia A un array di n interi > 0, Si fornisca il numero di elementi distinti contenuti all interno dell array Esempio A = 6, 3, 6, 3, 6, 8, 8, 8. Meno facile!. Una soluzione in O(n 2 ) : count = 0 ; f o r ( i = 0 ; i < n ; i++ ) i f ( A[ i ] > 0 ) { count++; f o r ( j = i ; j < n ; j++ ) i f ( A[ i ] == A[ j ] ) A[ j ] = 0 ; }

23 Ordinamento - motivazione Problema Sia A un array di n interi > 0, Si fornisca il numero di elementi distinti contenuti all interno dell array Esempio A = 6, 3, 6, 3, 6, 8, 8, 8. Altra strada: (1) ordino A, (2) soluzione ordinata. O(n log n)!!

24 Ordinamento - motivazione II Problema Sia A un array di interi. Ordinare A in modo non decrescente. Problema semplice da porre. Ordinare aiuta a lavorare dopo: uno strumento. Differenti velocità: da O(n log n) a O(n 2 ) a O(n + max A). Differenti algoritmi: insertion sort, mergesort, quicksort, heapsort,.. Differenti tecniche: divide et impera, ricorsione, heap. Oggi: insertion sort, mergesort.

25 Insertion sort Torniamo alle carte

26 Insertion sort Torniamo alle carte Composto da n passi. Ad ogni passo i = 0, 1,..., n 1: A[0..i 1] è già stata riordinata. Il resto no. Dobbiamo inserire A[i] nella sequenza mantenendo l ordine. Troviamo la posizione j i in cui va messo. Inseriamo A[i] lì, spingendo a destra il resto.

27 Insertion sort - fare spazio Passo i = 3, A[0..2] è ordinato. Estendiamo ad A[3] tmp = 4; 4 < < : A[1] = tmp

28 Insertion sort: pseduocodice void i n s e r t i o n S o r t ( i n t A, i n t n ) { i n t tmp ; f o r ( i = 0 ; i < n ; i++ ) { tmp = A[ i ] ; j = s h i f t (A, i ) ; A[ j ] = tmp ; } } Codifica completa: esercizio di laboratorio!

29 Insertion sort: pseduocodice void i n s e r t i o n S o r t ( i n t A, i n t n ) { i n t tmp ; f o r ( i = 0 ; i < n ; i++ ) { tmp = A[ i ] ; j = s h i f t (A, i ) ; A[ j ] = tmp ; } } Codifica completa: esercizio di laboratorio! QUIZ! Complessità?

30 Insertion sort: pseduocodice void i n s e r t i o n S o r t ( i n t A, i n t n ) { i n t tmp ; f o r ( i = 0 ; i < n ; i++ ) { tmp = A[ i ] ; j = s h i f t (A, i ) ; A[ j ] = tmp ; } } Codifica completa: esercizio di laboratorio! QUIZ! Complessità? O(n 2 )

31 Insertion sort: complessità Al passo i l operazione di shift esegue al più i spostamenti: O(i). Si eseguono poi altre due operazioni in tempo costante, ad ogni passo. Se sommiamo, per un qualche c: n 1 T (n) = O(i) i=0 n 1 c i = i=0 = c (n2 n) 2 c n (n 1) 2 O(n 2 )

32 Insertion sort: complessità Al passo i l operazione di shift esegue al più i spostamenti: O(i). Si eseguono poi altre due operazioni in tempo costante, ad ogni passo. Se sommiamo, per un qualche c: n 1 T (n) = O(i) i=0 n 1 c i = i=0 = c (n2 n) 2 c n (n 1) 2 O(n 2 ) Insertion sort è lento! Non ci aiuta per trovare i distinti!

33 Mergesort: idea Tecnica del divide et impera: riduciamo il problema a se stesso! Prendiamo il nostro array A e dividiamolo in due metà: A L e A R Ora, supponiamo di poter ordinare A L e A R indipendentemente: A questo punto possiamo usare merge e ottenere A ordinato!

34 Come ordinare A L e A R? Ecco il impera: mergesort! Dividiamo A L in (A L ) L e (A L ) R poi li ordiniamo usando mergesort, e poi li fondiamo, per ottenere A L ordinato. La stessa cosa succede con A R : dividiamo, ordiniamo, fondiamo. Quando fermarsi? Quando la lunghezza diventa < 1: a quel punto è pronto.

35 Come ordinare A L e A R? Ecco il impera: mergesort! Dividiamo A L in (A L ) L e (A L ) R poi li ordiniamo usando mergesort, e poi li fondiamo, per ottenere A L ordinato. La stessa cosa succede con A R : dividiamo, ordiniamo, fondiamo. Quando fermarsi? Quando la lunghezza diventa < 1: a quel punto è pronto. Ingredienti: Caso base semplice Possibilità di ricorrere su due sottoproblemi identici Possibilità di ricomporre la soluzione dei due sottoproblemi.

36 Mergesort: pseudocodice Mergesort = strategia di esecuzione merge. 1 void mergesort ( i n t A, i n t l e f t, i n t r i g h t ) 2 { 3 i f ( r i g h t l e f t > 0 ) { 4 i n t middle = ( l e f t+r i g h t ) / 2 ; 5 mergesort ( A, l e f t, middle ) ; 6 mergesort ( A, middle +1, r i g h t ) ; 7 newmerge ( A, l e f t, middle, r i g h t ) ; 8 } 9 } newmerge: variazione sul tema di merge, la vedremo dopo. Si usa l intervallo [left, right).

37 Mergesort: simulazione S(0,7)

38 Mergesort: simulazione S(0,7) S(0,3)

39 Mergesort: simulazione S(0,7) S(0,3) S(0,1)

40 Mergesort: simulazione S(0,0) S(0,7) S(0,3) S(0,1)

41 Mergesort: simulazione S(0,7) S(0,3) S(0,1) S(0,0) S(1,1)

42 Mergesort: simulazione S(0,7) S(0,3) S(0,1) S(0,0) S(1,1)

43 Mergesort: simulazione S(0,7) S(0,3) S(0,1) S(2,3) S(0,0) S(1,1)

44 Mergesort: simulazione S(0,7) S(0,3) S(0,1) S(2,3) S(0,0) S(1,1) S(2,2)

45 Mergesort: simulazione S(0,7) S(0,3) S(0,1) S(2,3) S(0,0) S(1,1) S(2,2) S(3,3)

46 Mergesort: simulazione S(0,7) S(0,3) S(0,1) S(2,3) S(0,0) S(1,1) S(2,2) S(3,3)

47 Mergesort: simulazione S(0,7) S(0,3) S(0,1) S(2,3) S(0,0) S(1,1) S(2,2) S(3,3)

48 Mergesort: simulazione S(0,7) S(0,3) S(4,7) S(0,1) S(2,3) S(0,0) S(1,1) S(2,2) S(3,3)

49 Mergesort: dettaglio Abbiamo usato newmerge, ma merge presupponeva di avere: 2 array in input un array per l output Noi vogliamo che funzioni sul posto, sia come input che come output. Soluzione: Primo elemento banale. Secondo elemento: introduciamo un array ausiliario di dimensione n che viene usato da merge di volta in volta: void mergesort ( i n t A, i n t l, i n t r, i n t TMP) void newmerge ( i n t A, i n t l, i n t c, i n t r, i n t TMP) Quando il risultato è pronto in TMP, lo spostiamo in A[l..r].

50 Mergesort: complessità Dimostrare la complessità di mergesort richiede l uso di equazioni di ricorrenza. Ad ogni passo i, sia x i = r i l i + 1. Sia T (x) il tempo di mergesort su x: Ad ogni passo, eseguiamo mergesort su x/2 per 2 volte (sx e dx) Quando le sottochiamate terminano, eseguiamo merge, con complessità O(x). Pertanto, T (x) dipende da T (x/2). In particolare: T (0) = T (1) = O(1) T (x) = T ( x/2 ) + T ( x/2 ) + O(x) 2T ( x/2 ) + O(x) Risoluzione effettiva: prof. Grossi. Ma è T (n) = O(n log n).

51 Mergesort: intuizione Solo le Merge contano: ogni nodo ha costo O(r l + 1). M(0,7) M(0,3) M(4,7) M(0,1) M(2,3) M(4,5) M(6,7) M(0,0) M(1,1) M(2,2) M(3,3) M(4,4) M(5,5) M(6, 6) M(7, 7) Quindi, ogni livello dell albero ha complessità O(n).

52 Quanti livelli ha l albero?

53 Quanti livelli ha l albero? 1 1 nodo 2 2 nodi 3 4 nodi n nodi 1, 2, 4, etc.. cresce come 2 i per i = 0, 1,.... Quando i = log 2 n, allora l albero termina di crescere. T (n) = log 2 n i=0 O(n) O(n log n). Quindi: O(n log n) per ordinare un array, O(n) per calcolare i distinti O(n log n), meglio di O(n 2 )!.

54 Mergesort: iterativo È proprio necessaria la ricorsione? NO! Mergesort iterativo! M(0,7) M(0,3) M(4,7) M(0,1) M(2,3) M(4,5) M(6,7) Eseguiamo le chiamate di merge per livelli, dal basso verso l alto. Ultimo livello: fusione di singoli. Le coppie diventano ordinate. Penultimo livello: fusione di coppie. Le quadruple diventano ordinate. Terzultimo livello: fusione di quadruple, le 8-uple diventano ordinate.... Proseguiamo fin quando non fondiamo solo 2 elementi (n/2 2)

55 Mergesort iterativo: codice void m e r g e I t e r ( i n t A, i n t n, i n t TMP) { i n t i, r ; f o r ( passo = 1 ; passo < n ; passo = 2 ) f o r ( i = 0 ; i+passo < n ; i +=2 passo ) { r = min ( n, i +2 passo ) ; merge (A, i, i+passo, r ) ; } } Vantaggio: niente ricorsione: può gestire dimensioni arbitrarie.