ALGORITMI Docente: Prof. Domenico Cantone

Transcript

1 CORSO SPECILE DI DURT NNULE PER IL CONSEGUIMENTO DELL BILITZIONE LL INSEGNMENTO NELL SCUOL SECONDRI DI I e II GRDO Indirizzo Fisico - Informatico - Matematico a.a. 00/07 - Classe - Informatica LGORITMI Docente: Prof. Domenico Cantone Modulo: LGORITMI DI ORDINMENTO Lucidi a cura del Dott. Salvatore Cristofaro

2 Problema dell ordinamento (Sorting) Il problema dell ordinamento è formalmente definito come segue: Input: Una sequenza di numeri (a, a,...,a n ), chiamata sequenza-input. Output: Una permutazione (i, i,..., i n ) di (,,...,n), chiamata soluzione, tale che si abbia a i a i a in. In tal caso, (a i, a i,..., a in ) è chiamata sequenza-output. Es. Data la sequenza-input (0, 0,,, 0, 9, ) a = 0 a = 0 a = a = a = 0 a = 9 a 7 = le permutazioni π a = (,,,, 7,, ) e π b = (,,,, 7,, ) sono soluzioni del problema dell ordinamento, a cui corrisponde la stessa sequenza-output (,, 0, 0,, 0, 9). Si osservi che, per una data sequenza-input S, il problema dell ordinamento può avere anche due o più soluzioni, ma ad esse corrisponde una stessa (unica) sequenza-output.

3 Una soluzione al problema dell ordinamento: ordinamento sul posto () Rappresentiamo la sequenza-input (a, a,..., a n ) mediante un array [.. n] di lunghezza n tale che [i] = a i, per i =,,..., n. sequenza-input (0, 0,,, 0, 9, ), con n = () Senza usare alcun array di supporto, riordiniamo gli elementi dell array, eventualmente scambiandoli di posto, in modo che alla fine si abbia [] [] [n]. sequenza-output (,, 0, 0,, 0, 9)

4 L algoritmo Insertion-Sort Insertion-Sort(). for j := to n do. k := [j]. i := j. while (i and [i] > k) do. [i + ] := [i]. i := i 7. [i + ] := k L algoritmo Insertion-Sort scandisce l array da sinistra verso destra, facendo scorrere l indice j da a n, e ogni volta sistema l elemento [j] al posto giusto nel sottoarray [.. j] spostando di una posizione verso destra tutti gli elementi più grandi di [j], lasciano al loro posto tutti gli altri. [j] > [j] [j] [.. j] [j +.. n] Si osservi che subito dopo che l algoritmo sistema [j] nel sottoarray [.. j], quest ultimo risulta ordinato.

5 Esempio j = j = j = j = j = rray ordinato

6 Complessità di Insertion-Sort Insertion-Sort() Costo. for j := to n do c. k := [j] c. i := j c. while (i and [i] > k) do c. [i + ] := [i] c. i := i c 7. [i + ] := k c 7 Per j =,,..., n, sia t j il numero di volte che la condizione del ciclo while in linea viene testata durante l esecuzione della (j )-esima iterazione del ciclo for: ISTRUZIONI Costo Numero di esecuzioni Costo totale. k := [j] c c. i := j c c. while (i and [i] > k) do c t j c t j. [i + ] := [i] c t j c (t j ). i := i c t j c (t j ) 7. [i + ] := k c 7 c 7 Durante la (j )-esima iterazione del ciclo for

7 La (j )-esima iterazione del ciclo for contribuisce dunque con un costo totale C(j) = c + c + c 7 c c + (c + c + c ) t j Il costo complessivo dovuto alle (n )-iterazioni del ciclo for risulta pertanto n C(j) = (c + c + c 7 c c ) (n ) + (c + c + c ) j= n j= t j Tenendo infine conto dell istruzione in linea (che viene eseguita n-volte), il running time di Insertion-Sort è dato da: n T(n) = c n + (c + c + c 7 c c ) (n ) + (c + c + c ) t j. () Caso Migliore (Best-Case) Il caso migliore occorre quando l array è già inizialmente ordinato (in senso non decrescente). In questo caso si ha che t j = (la condizione nel while viene testata una sola volta dato che [j ] [j]), e quindi T best (n) = (c + c + c + c + c 7 ) n (c + c + c + c 7 ) = Θ(n) j= (lineare). () Caso Peggiore (Worst-Case) Il caso peggiore occorre quando l array è inizialmente ordinato in senso decrescente. In questo caso si ha che t j = j (la condizione nel while viene testata j-volte dato che [],...,[j ] > [j]), e quindi T worst (n) = Θ(n ) (quadratico). () In generale: T(n) = O(n ) e T(n) = Ω(n).

8 L algoritmo Selection-Sort Selection-Sort(). for j := to n do. min := j. for i := j + to n do. if [i] < [min] then. min := i. temp := [j] 7. [j] := [min] 8. [min] := temp L algoritmo Selection-Sort scandisce l array da sinistra verso destra, facendo scorrere l indice j da a n, e per ogni tale j effettua le seguenti operazioni: ) trova la posizione min (più a sinistra) nel sottoarray [j.. n] contenente la chiave minima (cioè [min] [j], [j + ],..., [n]) (blocco di istruzioni nelle linee,, e ); ) scambia [j] con [min] (blocco di istruzioni nelle linee, 7 e 8). scambio x y y x j min j min

9 Esempio j = min = j = min = j = min = j = min = j = min = rray ordinato

10 Complessità di Selection-Sort Selection-Sort(). for j := to n do. min := j. for i := j + to n do. if [i] < [min] then. min := i. temp := [j] 7. [j] := [min] 8. [min] := temp Per j =,,...,n, sia t j il numero delle iterazioni eseguite dal ciclo for in linea durante la j-esima iterazione del for in linea. llora, il costo complessivo T(n) di Selection-Sort soddisfa n T(n) = Θ j= t j Poiché t j = n j, si ha che n j= t j = n (n j) = j= n(n ) ( ) n(n ) = T(n) = Θ = Θ ( n )

11 L algoritmo Heap-Sort Heap-Sort(). Build-Heap(). for i := n downto do. Exchange([], [i]). HeapSize[] := HeapSize[]. Heapify(, ) L algoritmo Heap-Sort inizia costruendo uno Heap effettuando la chiamata alla procedura Build-Heap() sull array input [.. n], dove n è la lunghezza di. Dato che il massimo elemento dello Heap si trova in [], esso può essere messo nella corretta posizione scambiandolo con [n]. questo punto, se scarichiamo il nodo n dallo Heap attuale (decrementando di HeapSize[]), possiamo osservare che il sottoarray [.. n ] può essere facilmente reso uno (n )-Heap, cioè uno heap con n nodi, mediante una chiamata alla procedura Heapify(, ). L algoritmo Heap-Sort ripete questo processo all indietro fino a quando la dimensione dello Heap attuale si riduce a. L algortimo Heap-Sort riporato sopra assume che tutti gli Heap siano dei Max-Heap. Nel caso si considerano dei Min-Heap si otterrà l ordinamento in senso non crescente dell array. La complessità di Heap-Sort è O(n log n), dato che la chiamata a Build-Heap() prende tempo O(n) e ciascuna delle n chiamate a Heapify impiega tempo O(log n).

12 = [,,,,, ] Build-Heap() I nodi colorati di grigio rappresentano i nodi che man mano vengono scaricati dallo Heap. Exchange([], []) HeapSize := HeapSize Heapify(, ) Exchange([], []) HeapSize := HeapSize Heapify(, ) Exchange([], []) HeapSize := HeapSize Heapify(, ) Exchange([], []) HeapSize := HeapSize Heapify(, ) Exchange([], []) HeapSize := HeapSize Heapify(, )

13 L algoritmo Merge-Sort Date due sequenze ordinate e B, si chiama merging ordinato di con B la sequenza M che si ottiene riordinando la concatenazione di con B. Esempio Il merging ordinato di = [ 7 ] con B = [ ] è la sequenza M = [ 7 ]. Il merging ordinato di con B può essere effettuato in tempo Θ(n + m), dove n ed m sono le lunghezze di e B, rispettivamente. Merge(, B). i := j :=. M := [ ]. while (i n and j m) do. if [i] < B[j] then. si prolunghi M con [i]. i := i + 7. else 8. si prolunghi M con B[j] 9. j := j + 0. if i n then. si prolunghi M con [i.. n]. else. si prolunghi M con B[j.. m]. return(m) B M [ 7 ] [ ] [ ] [ 7 ] [ ] i =, j = [ ] [ 7 ] [ ] i =, j = [ ] [ 7 ] [ ] i =, j = [ ] [ 7 ] [ ] i =, j = [ ] [ 7 ] [ ] i =, j = [ ] [ 7 ] [ ] i =, j = > m [ 7 ]

14 L algoritmo Merge-Sort (cont.) L algoritmo Merge-Sort si basa sulla strategia Divide and Conquer: un problema viene scomposto in sottoproblemi più piccoli, le cui soluzioni vengono poi combinate per ottenere una soluzione del problema originario. Il Merge-Sort opera come segue:. spezza a metà la sequenza input in due sottosequenze B e C;. chiama ricorsivamente se stesso sulle due sottosequenze B e C ottenendo le sequenze ordinate B e C, rispettivamente;. effettua il merging ordinato di B con C. Merge-Sort(, p, r). if p < r then. q := (p + r)/. Merge-Sort(, p, q). Merge-Sort(, q +, r). Merge(, p, q, r) Una chiamata alla procedura Merge-Sort(, i, j) permette di riordinare il sottoarray [i.. j]; La procedura Merge(, i, k, j) effettua il merging ordinato dei sottoarray (ordinati) [i.. k] e [k+.. j]; Effettuando una chiamata a Merge-Sort(,, n), dove n è la lunghezza di, verrà riordinato l intero array.

15 Esempio: operazioni eseguite da Merge-Sort sulla sequenza [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] Merging [ ] [ ] [ ] [ ]

16 Complessità di Merge-Sort Merge-Sort(, p, r). if p < r then. q := (p + r)/. Merge-Sort(, p, q). Merge-Sort(, q +, r). Merge(, p, q, r) Il running time T(n) di Merge-Sort, quando eseguito su un array [.. n] di lunghezza n, può essere espresso come segue: { Θ(), se n = T(n) = T(n/) + Θ(n), se n >. Il termine T(n/) rappresenta il costo della chiamata ricorsiva di Merge-Sort su cisacuna delle due sottosequenze [.. (n + )/ ] e [ (n + )/ +.. n] (linee. e.); Il termine Θ(n) rappresenta il costo della procedura di merging eseguita sulle sottosequenze ordinate ottenute al punto precedente (linea.) La soluzione della precedente equazione di ricorrenza è T(n) = Θ(n log n).

17 L algoritmo Quick-Sort Come il Merge-Sort anche il Quick-Sort si basa sulla strategia Divide and Conquer. Esso opera come segue:. la sequenza input viene partizionata in due sottosequenze B e C tali che ogni elemento di B è minore o uguale ad ogni elemento di C;. chiama ricorsivamente se stesso sulle due sottosequenze B e C, ottenendo le sequenze ordinate B e C, rispettivamente;. concatena B con C per ottenere l ordinamento di. Quick-Sort(, p, r). if p < r then. q := Partition(, p, r). Quick-Sort(, p, q). Quick-Sort(, q +, r) La procedura Partition(, p, r) riorganizza gli elementi del sottarray [p.. r], partizionandolo, in modo che ogni elemento del sottoarray [p.. q] sia minore o uguale ad ogni elemento del sottoarray [q +.. r] (vedi pagina seguente). Il valore x inizialmente contenuto in [p] (cioè prima dell esecuzione della procedura) viene usato come elemento pivot attorno al quale si effettuata la partizione: [p.. q] conterrà solanto elementi minori o uguali a x, [q +.. r] soltanto elementi maggiori o uguali a x.

18 L algoritmo Quick-Sort (cont.) Partition(, p, r). x := [p]. i := p. j := r +. while TRUE do. repeat. j := j 7. until [j] x 8. repeat 9. i := i + 0. until [i] x. if i < j then. Exchange([i], [j]). else. return(j) [... i [... [... 8 p 8 i [... [... 8 i [... i i j r... ] j... ] x = j... ] j 8... ] j 8... ] j 8... ] return(j) i Exchange([i], [j]) Exchange([i], [j]) Il running time della procedura Partition su un sottoarray [p.. r] è Θ(n) dove n = r p + è la lunghezza di [p.. r].

19 Complessità di Quick-Sort Il running time di Quick-Sort è strettamente legato al comportamento della procedura Partition. Worst Case: il caso peggiore occorre quando la procedura Partition produce sempre una partizione completamente sbilanciata del sottoarray [p.. r], in cui una regione della partizione contiene n elementi (n = r p + ) e l altra contiene solo elemento, cioè quando (a) Partition(, p, r) = p (Es. [p.. r] è inizialmente ordinato in senso crescente), oppure (b) Partition(, p, r) = r (Es. [p.. r] è inizialmente ordinato in senso decrescente). Nel caso peggiore, il running time T(n) di Quick-Sort può essere espresso dalla seguente equazione di ricorrenza: { Θ(), se n = T(n) = T(n ) + Θ(n), se n >, la cui soluzione è T(n) = Θ(n ). Best Case: il caso migliore occorre quando la procedura Partition produce sempre una partizione completamente bilanciata del sottoarray [p.. r], in cui una regione della partizione contiene n/ elementi (n = r p + ) e l altra ne contiene altrettanti (Es. quando gli elementi di [p.. r] sono tutti uguali tra loro). In questo caso si ha che: { Θ(), se n = T(n) = T(n/) + Θ(n), se n >, la cui soluzione è T(n) = Θ(n log n).