Ordinamento Continuiamo a discutere il problema dellordinamento Ordinamento

Ordinamento Continuiamo a discutere il problema dell’ordinamento: Ordinamento (Sorting) Input: Sequenza di n numeri <a 1, a 2, ……, an> Output: Permutazione π<a 1, a 2, ……, an> = <ai 1, ai 2, ……, ain> tale che: ai 1 ai 2 …… ain Algoritmo di Insertion-Sort problema dell’ordinamento risolve il La complessità temporale (tempo di esecuzione dell’algoritmo) dell’ Insertion-Sort verifica: Tworst(n) = Tavg(n)= (n 2) Tbest(n) = (n) La complessità spaziale (spazio di memoria necessario per ospitare le strutture di dati utilizzate dall’algoritmo) dell’Insertion Sort è (n). 1

Prima di continuare …… Quando forniamo limiti asintotici superiori/inferiori alla complessità di un algoritmo senza specificare le proprietà dell’input, ci riferiamo implicitamente al caso peggiore: Un algoritmo ha delimitazione superiore alla complessità (o più semplicemente complessità) O(f(n)) (upper bound) se per tutte le istanze di input T(n) = O(f(n)) Tbest(n) = O(f(n)), ma anche Tworst(n) = O(f(n)) Un algoritmo ha delimitazione inferiore alla complessità (f(n)) (lower bound) se esiste almeno una istanza di input per cui T(n) = (f(n)) Tworst (n) = (f(n)), ma non è detto che Tbest(n) = Ω(f(n)) Quindi: 1. Se scrivo che un algoritmo ha complessità T(n) = O(f(n)), intendo semplicemente dire che per tutte le istanze di input l’algoritmo termina in O(f(n)). 2. Se invece scrivo che un algoritmo ha complessità T(n) = Θ(f(n)), intendo dire che T(n)=O(f(n)), ma anche esiste almeno una istanza di input per cui T(n) = (f(n)). 2

L’algoritmo di Insertion Sort è l’ unico algoritmo possibile per risolvere il problema dell’ordinamento? Ovviamente NO! L’algoritmo di Selection Sort è definito dalla seguente strategia: • Al primo passo, si seleziona l’elemento più piccolo tra gli n elementi della sequenza, e lo si pone nella prima posizione (scambiandolo con l’elemento A[1] ); • Al secondo passo, si seleziona l’elemento più piccolo tra i rimanenti n-1 elementi di A, e lo si pone nella seconda posizione (scambiandolo con A[2] ); . . . • Al k-esimo passo, si seleziona l’elemento più piccolo tra i rimanenti n-(k-1) elementi di A, e lo si pone nella k-esima posizione (scambiandolo con A[k]); . . . • All’(n-1)-esimo passo, si seleziona l’elemento più piccolo tra gli ultimi 2 elementi di A, e lo si pone nella penultima posizione (scambiandolo con 3 A[n-1]).

Notare La strategia descritta prevede ad ogni step la risoluzione dello stesso problema (ricerca del minimo di una sequenza). Abbiamo risolto il problema dell’ordinamento riconducendo tale problema al più semplice problema di ricerca del minimo. Algoritmo per la ricerca dell’elemento minimo di una sequenza Min_elemento(A) ind_min 1 For i 2 to length(A) do if (A[i] < A[ind_min ]) then ind_min i Return ind_min Qual è la complessità spaziale di questo algoritmo? S(n) = (n) Qual è la complessità temporale di questo algoritmo? T(n) = (n) per tutti gli input 4

Algoritmo Selection Sort Selection-Sort(A) For j 1 to (length(A)-1) do ind_min j For i j+1 to length(A) do if (A[i] < A[ind_min ]) then ind_min i k A[ind_min] A[j] k Notiamo che l’algoritmo, oltre a terminare sempre, è corretto. Infatti, ragionando per induzione, devo mostrare che la seguente affermazione è vera per j=1, 2, 3, ……n-1: “Al j-esimo step l’algoritmo produce una sequenza ordinata non decrescente A[1], ……, A[j], dove A[1] è il più piccolo elemento, A[2] è il secondo elemento piu’ piccolo , …………, A[j] è il j-esimo elemento più piccolo della sequenza iniziale. ” § Verifico la validità dell’affermazione per j=1; § Assumo che la affermazione sia valida per un generico valore di j=h; § Mostro che da ciò segue che la affermazione è valida per j=h+1. 5

Analisi del Selection Sort Selection-Sort(A) For j 1 to (length(A)-1) do ind_min j For i j+1 to length(A) do if (A[i] < A[ind_min ]) then ind_min i k A[ind_min] A[j] k (*) Complessità temporale del Selection Sort - Qual è la linea (o il blocco di linee di codice) che viene eseguito più volte (operazione dominante)? if (A[i] < A[ind_min ]) - operazione di confronto - Quante volte viene eseguita? - Il numero di volte che questa linea viene eseguita dipende dall’ input? No! La complessità temporale del Selection Sort è T(n)= (n 2) (indip. dall’input). 6

Complessità intrinseca di un problema Abbiamo introdotto 2 algoritmi (IS, SS) che risolvono il problema dell’ordinamento: SS – T(n) = Θ(n 2) IS - T(n) = Θ(n 2) Ci chiediamo – Si può fare di meglio? Più precisamente – E’ possibile risolvere il problema dell’ ordinamento mediante algoritmi aventi un comportamento asintotico migliore? Notare – Per rispondere alla domanda, dobbiamo “alzare” il livello della nostra analisi. Dobbiamo discutere le proprietà generali del problema, indipendentemente dagli algoritmi specifici utilizzati per risolverlo. 7

Complessità intrinseca di un problema vs Complessità computazionale di un algoritmo Un problema computazionale ha delimitazione superiore alla complessità O(f(n)) (upper bound) se esiste un algoritmo per la sua risoluzione con delimitazione superiore O(f(n)). Un problema computazionale ha delimitazione inferiore alla complessità (f(n)) (lower bound) se tutti gli algoritmi per la sua risoluzione hanno delimitazione inferiore (f(n)). Se dimostro che un problema ha delimitazione inferiore (f(n)) e trovo un algoritmo risolutivo avente complessità O(f(n)) allora… …a meno di costanti, ho un algoritmo ottimale per risolvere il problema!!! Esempio di algoritmo ottimale Algoritmo per la ricerca del minimo in un insieme non ordinato, avente complessità O(n), Infatti, ogni algoritmo dovrà almeno leggere l’input, e quindi avrà complessità (n). 8

Problema dell’ordinamento Sappiamo per ora che: Lower bound - (n) Upper bound – O(n 2) (banale, dimensione dell’input) IS, SS Abbiamo un gap lineare tra upper bound e lower bound. Forse possiamo fare meglio …. …… 9

Lower Bound per il problema dell’ordinamento Ordinamento per confronti Dati due elementi ai ed aj, per determinarne l’ordinamento relativo effettuiamo una delle seguenti operazioni di confronto: a i aj ; ai aj Non si possono esaminare i valori degli elementi o ottenere informazioni sul loro ordine in altro modo. Notare – Tutti gli algoritmi di ordinamento considerati fino ad ora sono algoritmi di ordinamento per confronto. 10

Gli algoritmi di ordinamento per confronto possono essere descritti in modo astratto in termini di ALBERI DI DECISIONE. Un generico algoritmo di ordinamento per confronto lavora nel modo seguente: -Confronta due elementi ai ed aj (ad esempio effettua il test ai aj); - A seconda del risultato – riordina e/o decide il confronto successivo da eseguire. Albero di decisione - Descrive i confronti che l’algoritmo esegue quando opera su un input di una determinata dimensione. I movimenti dei dati e tutti gli altri aspetti dell’algoritmo vengono ignorati Albero di decisione dell’algoritmo Insertion Sort a 1: a 2: a 3 a 1: a 3 <a 1, a 2, a 3> <a 1, a 3, a 2> <a 2, a 1, a 3> <a 3, a 1, a 2> a 2: a 3 <a 2, a 3, a 1> <a 3, a 2, a 1> 11

Prima di discutere i dettagli, alcune definizioni …… radice a 1: a 2 Sotto-albero sinistro Sotto-albero destro a 2: a 3 a 1: a 3 <a 1, a 3, a 2> a 1: a 3 <a 1, a 2, a 3> nodo <a 2, a 1, a 3> a 2: a 3 cammino <a 3, a 1, a 2> <a 2, a 3, a 1> <a 3, a 2, a 1> foglia Profondità di un nodo = lunghezza del cammino che lo congiunge alla radice. Altezza di un albero = valore massimo della profondità dei nodi. Notare - (Numero di Foglie) 2 h h = altezza dell’albero 12

Torniamo al problema dell’ordinamento Insertion-Sort a 1: a 2: a 3 a 1: a 3 <a 1, a 2, a 3> <a 1, a 3, a 2> <a 2, a 1, a 3> <a 3, a 1, a 2> a 2: a 3 <a 2, a 3, a 1> <a 3, a 2, a 1> - Ogni foglia è etichettata con una permutazione della sequenza iniziale; - L’esecuzione dell’ algoritmo corrisponde a tracciare un cammino dalla radice ad una foglia; - L’algoritmo segue un cammino diverso a seconda delle caratteristiche dell’input caso migliore: cammino più breve caso peggiore: cammino più lungo - L’altezza dell’albero fornisce il numero di confronti che l’algoritmo esegue nel caso peggiore. 13

Limite inferiore al problema dell’ordinamento per confronti Insertion-Sort a 1: a 2: a 3 a 1: a 3 <a 1, a 2, a 3> <a 1, a 3, a 2> <a 2, a 1, a 3> <a 3, a 1, a 2> a 2: a 3 <a 2, a 3, a 1> <a 3, a 2, a 1> Notiamo che: - il numero di foglie dell’albero di decisione deve essere almeno pari al numero di possibili permutazioni della sequenza iniziale: (# foglie) n! - Come già detto, sussiste la seguente relazione tra il numero di foglie e l’altezza di un albero binario: (# foglie) 2 h Ciò implica: 2 h n! Da ciò segue h log 2(n!), e per l’approssimazione di Stirling su n!, che impone n!>(n/e)n, ne segue che h > log 2((n/e)n) = n(log 2 n-log 2 e) = (n log 2 n) 14

In conclusione: Ricordando che l’altezza dell’albero di decisione indica il numero di confronti che un generico algoritmo effettua nel caso peggiore, otteniamo: Algoritmo T(n) = (n log 2 n) Quindi: Lower Bound = (n log 2 n) (problema dell ’ordinamento per confronti) Esercizi – 1) Albero di decisione per SS (3 elementi) 2) Ho scritto T(n) = (n log 2 n). Implica T(n) = (n ln (n)) ? 15