Algoritmi e strutture dati da Demetrescu et al. McGraw Hill 2004. 11. Possiamo
fare di meglio ? O( n2 ) è quanto di peggio si possa fare: tutti i confronti possibili!
Algoritmi e Strutture Dati Capitolo 4 Ordinamento
Algoritmi e strutture dati
Luigi Laura
Ordinamento Dato un insieme S di n oggetti presi da un dominio totalmente ordinato, ordinare S • Esempi: ordinare alfabeticamente lista di nomi, o insieme di numeri, o insieme di compiti d’esame in base a cognome studente • Subroutine di molti problemi • E’ possibile effettuare ricerche in array ordinati in tempo O(log n) 2
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Algoritmi e tempi tipici • Numerosi algoritmi • Tre tempi tipici: O(n2), O(n log n), O(n) n
10
100
n log2 n
~ 33
~ 665
n2
100
104
1000
106
109
~ 104 ~ 2 · 107 ~ 3 · 1010 106
1012
1018
da Demetrescu et al. McGraw Hill 2004
3
Algoritmi e strutture dati
Luigi Laura
Algoritmi di ordinamento
4
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
SelectionSort Approccio incrementale. Estende ordinamento da k a (k+1) elementi, scegliendo minimo tra (n-k) elementi non ancora ordinati e mettendolo in posizione (k+1)
da Demetrescu et al. McGraw Hill 2004
5
Algoritmi e strutture dati
Luigi Laura
SelectionSort: analisi k - esima estrazione di minimo costa tempo O(n-k) In totale, il tempo di esecuzione è: n-1
∑ O(n-k) k=1
n-1
=
O
( ∑ i) = O(n ) 2
i=1
[ cambiamento di variabile (i = n – k) e serie aritmetica ]
6
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
InsertionSort Approccio incrementale. Estende ordinamento da k a (k+1) elementi, posizionando elemento (k+1)-esimo nella posizione corretta rispetto ai primi k elementi
da Demetrescu et al. McGraw Hill 2004
7
Algoritmi e strutture dati
Luigi Laura
InsertionSort: analisi Inserimento del k-esimo elemento nella posizione corretta rispetto ai primi k richiede tempo O(k) nel caso peggiore In totale, il tempo di esecuzione è : n-1
O
( ∑ k) = O(n ) 2
k=1
[ serie aritmetica ] 8
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
BubbleSort • Esegue una serie di scansioni dell’array – In ogni scansione confronta coppie di elementi adiacenti, scambiandoli se non sono nell’ordine corretto – Dopo una scansione in cui non viene effettuato nessuno scambio l’array è ordinato • Dopo la k-esima scansione, i k elementi più grandi sono correttamente ordinati ed occupano le k posizioni più a destra correttezza e tempo 2 di esecuzione O(n ) 9
Algoritmi e strutture dati
da Demetrescu et al. McGraw Hill 2004
Luigi Laura
Esempio di esecuzione
10
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
O( n2 ) è quanto di peggio si possa fare: tutti i confronti possibili! Possiamo fare di meglio ?
da Demetrescu et al. McGraw Hill 2004
11
Algoritmi e strutture dati
Luigi Laura
1. QuickSort 2. MergeSort 3. HeapSort
12
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
QuickSort • Usa la tecnica del divide et impera: 1 Divide: scegli un elemento x della sequenza (pivot) e partiziona la sequenza in elementi ≤ x ed elementi > x 2 Risolvi i due sottoproblemi ricorsivamente 3 Impera: restituisci la concatenazione delle due sottosequenze ordinate
da Demetrescu et al. McGraw Hill 2004
13
Algoritmi e strutture dati
Luigi Laura
Partizione in loco • Scorri l’array “in parallelo” da sinistra verso destra e da destra verso sinistra – da sinistra verso destra, ci si ferma su un elemento maggiore del pivot – da destra verso sinistra, ci si ferma su un elemento minore del pivot
• Scambia gli elementi e riprendi la scansione Tempo di esecuzione: O(n) 14
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Partizione in loco: un esempio
da Demetrescu et al. McGraw Hill 2004
15
Algoritmi e strutture dati
Luigi Laura
Analisi nel caso peggiore • Nel caso peggiore, il pivot scelto ad ogni passo è il minimo o il massimo degli elementi nell’array • Il numero di confronti nel caso peggiore è : C(n) = C(n-1) + O(n) • Risolvendo per iterazione si ottiene C(n) = O(n2) 16
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Esempio di esecuzione L’albero delle chiamate ricorsive può essere sbilanciato
da Demetrescu et al. McGraw Hill 2004
17
Algoritmi e strutture dati
Luigi Laura
Randomizzazione • Possiamo evitare il caso peggiore scegliendo come pivot un elemento a caso • Poiché ogni elemento ha la stessa probabilità, pari a 1/n, di essere scelto come pivot, il numero di confronti nel caso atteso è: n-1
C(n)=
∑ a=0
n-1
1 n-1+C(a)+C(n-a-1) = n-1+ ∑ 2 C(a) n n a=0
dove a e (n-a-1) sono le dimensioni dei sottoproblemi risolti ricorsivamente 18
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Analisi nel caso medio n-1
La relazione di ricorrenza C(n)= n-1+ ∑ 2n C(a) ha soluzione C(n) ≤ 2 n log n
a=0
Dimostrazione per sostituzione Assumiamo per ipotesi induttiva che C(i) ≤ 2 i log i n-1
C(n)≤ n-1+ ∑ 2 2 i log i ≤ n-1+ 2 n n i=0
n
∫2
x log x dx
Integrando per parti si dimostra che C(n) ≤ 2 n log n da Demetrescu et al. McGraw Hill 2004
19
Algoritmi e strutture dati
Luigi Laura
MergeSort Usiamo la tecnica del divide et impera: 1 Divide: dividi l’array a metà 2 Risolvi il sottoproblema ricorsivamente 3 Impera: fondi le due sottosequenze ordinate Rispetto a QuickSort, divide semplice ed impera complicato
20
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Fusione (Merge) • Due array ordinati A e B possono essere fusi rapidamente: – estrai ripetutamente il minimo di A e B e copialo nell’array di output, finché A oppure B non diventa vuoto – copia gli elementi dell’array non vuoto alla fine dell’array di output
• Tempo: O(n), dove n è il numero totale di elementi da Demetrescu et al. McGraw Hill 2004
21
Algoritmi e strutture dati
Luigi Laura
Mergesort: esempio di esecuzione
Input ed output delle chiamate ricorsive
22
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Tempo di esecuzione • Numero di confronti del MergeSort descritto da relazione di ricorrenza: C(n) = 2 C(n/2) + O(n) • Da Teorema Master si ottiene la soluzione C(n) = O(n log n)
da Demetrescu et al. McGraw Hill 2004
23
Algoritmi e strutture dati
Luigi Laura
HeapSort • Stesso approccio incrementale del SelectionSort • Usa però struttura dati più efficiente per estrarre massimo ad ogni iterazione • Struttura dati heap associata ad insieme S : albero binario radicato con le seguenti proprietà: 1) completo fino al penultimo livello 2) elementi di S memorizzati nei nodi dell’albero 3) chiave(padre(v)) ≥ chiave(v) per ogni nodo v 24
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Struttura dati heap Rappresentazione ad albero e con vettore posizionale
sin(i) = 2i des(i) = 2i+1
da Demetrescu et al. McGraw Hill 2004
25
Algoritmi e strutture dati
Luigi Laura
Heap con struttura rafforzata Le foglie nell’ultimo livello sono compattate a sinistra
Il vettore posizionale ha esattamente dimensione n
26
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Proprietà salienti degli heap 1) Il massimo è contenuto nella radice 2) L’albero ha altezza O(log n) 3) Gli heap con struttura rafforzata possono essere rappresentati in un array di dimensione n da Demetrescu et al. McGraw Hill 2004
27
Algoritmi e strutture dati
Luigi Laura
La procedura fixHeap Se tutti i nodi di H tranne v soddisfano la proprietà di ordinamento a heap, possiamo ripristinarla come segue: fixHeap(nodo v, heap H) if (v è una foglia) then return else sia u il figlio di v con chiave massima if ( chiave(v) < chiave(u) ) then scambia chiave(v) e chiave(u) fixHeap(u,H)
Tempo di esecuzione: O(log n) 28
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Estrazione del massimo • Copia nella radice la chiave contenuta nella la foglia più a destra dell’ultimo livello • Rimuovi la foglia • Ripristina la proprietà di ordinamento a heap richiamando fixHeap sulla radice Tempo di esecuzione: O(log n) da Demetrescu et al. McGraw Hill 2004
29
Algoritmi e strutture dati
Luigi Laura
Costruzione dell’heap Algoritmo ricorsivo basato su divide et impera heapify(heap H) if (H è vuoto) then return else heapify(sottoalbero sinistro di H) heapify(sottoalbero destro di H) fixHeap(radice di H,H)
Tempo di esecuzione: T(n) = 2 T(n/2) + O(log n) T(n) = O(n) 30
dal Teorema Master da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
HeapSort • Costruisci un heap tramite heapify • Estrai ripetutamente il massimo per (n-1) volte
O(n) O(n log n)
– ad ogni estrazione memorizza il massimo nella posizione dell’array che si è appena liberata
ordina “in loco” in tempo O(n log n) 31
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Possiamo fare meglio di O(n log n)?
32
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Lower bound • Dimostrazione (matematica) che non possiamo andare più veloci di una certa quantità • Più precisamente, ogni algoritmo all’interno di un certo modello di calcolo deve avere tempo di esecuzione almeno pari a quella quantità • Non significa necessariamente che non è possibile fare di meglio • Potrebbe essere possibile fare di meglio al di fuori di quel modello 33
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Lower bound • Delimitazione inferiore: quantità di risorsa necessaria per risolvere un determinato problema • Dimostrare che Ω(n log n) è lower bound al numero di confronti richiesti per ordinare n oggetti. • Come? • Dobbiamo dimostrare che tutti gli algoritmi richiedono Ω(n log n) confronti! 34
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Modello basato su confronti • In questo modello, per ordinare è possibile usare solo confronti tra oggetti • Primitive quali operazioni aritmetiche (somme o prodotti), logiche (and e or), o altro (shift) sono proibite • Sufficientemente generale per catturare le proprietà degli algoritmi più noti da Demetrescu et al. McGraw Hill 2004
35
Algoritmi e strutture dati
Luigi Laura
Come dimostrare lower bound • Consideriamo un qualsiasi algoritmo A, che ordina solo mediante confronti • Non abbiamo assolutamente idea di come funziona A ! • Ciò nonostante, dimostreremo che A deve eseguire almeno Ω(n log n) confronti • Dato che l’unica ipotesi su A è che ordini mediante confronti, il lower bound sarà valido per tutti gli algoritmi basati su confronti! 36
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Alberi di decisione • Strumenti per rappresentare algoritmi di ordinamento • Descrivono sequenza di confronti che un algoritmo esegue su istanze di lunghezza n
37
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Alberi di decisione = algoritmi basati su confronti! • Ogni algoritmo basato su confronti può essere rappresentato da un albero di decisione: – confronti scelti dall’algoritmo possono dipendere solo dagli esiti dei confronti precedenti!
• Un albero di decisione può essere “letto” come algoritmo basato su confronti: – per ogni input, il cammino nell’albero descrive confronti da effettuare e permutazione che produce soluzione 38
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Proprietà alberi di decisione • Per una particolare istanza, i confronti eseguiti da A su quella istanza sono rappresentati da un cammino radice - foglia • Il numero di confronti nel caso peggiore è pari all’altezza dell’albero di decisione • Un albero di decisione per l’ordinamento di n elementi contiene almeno (n!) foglie (una per ogni possibile permutazione degli n oggetti) da Demetrescu et al. McGraw Hill 2004
39
Algoritmi e strutture dati
Luigi Laura
Lower bound • Un albero binario con k foglie tale che ogni nodo interno ha esattamente due figli ha altezza almeno log2 k • Dimostrazione per induzione su k: – Passo base: 0 ≥ log2 1 – h(k) ≥ 1 + h(k/2) poiché uno dei due sottoalberi ha almeno metà delle foglie – h(k/2) ≥ log2 (k/2) per ipotesi induttiva – h(k) ≥ 1 + log2 (k/2) = log2 k 40
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Il lower bound Ω (n log n) • L’albero di decisione ha almeno n! foglie • La sua altezza è almeno log2 (n!) • Formula di Stirling: n! ≥ (2πn)1/2 · (n/e) n • Quindi: log2 (n!) = Ω (n log n)
da Demetrescu et al. McGraw Hill 2004
41
Algoritmi e strutture dati
Luigi Laura
Ordinamenti lineari (per dati con proprietà particolari)
42
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Sappiamo che gli n elementi da ordinare sono tutti distinti e nell’intervallo [1,n] In quanto tempo possiamo ordinarli? O(1) Contraddice il lower bound? No. Perché? da Demetrescu et al. McGraw Hill 2004
43
Algoritmi e strutture dati
Luigi Laura
IntegerSort: fase 1 Meno banale: ordinare n interi con valori in [1,k]
Mantieni array Y di k contatori tale che Y[x] = numero di occorrenze di x
44
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
IntegerSort: fase 2 Scandisci Y da sinistra verso destra. Se Y[x] = k, scrivi in X il valore x per k volte
da Demetrescu et al. McGraw Hill 2004
45
Algoritmi e strutture dati
Luigi Laura
IntegerSort: analisi • O(k) per inizializzare contatori a 0 • O(n) per calcolare valori dei contatori • O(n + k) per ricostruire sequenza ordinata O(n + k) Tempo lineare se k = O(n) 46
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
BucketSort Per ordinare n record con chiavi intere in [1,k] • Basta mantenere un array di liste, anziché di contatori, ed operare come per IntegerSort • La lista Y[x] conterrà gli elementi con chiave uguale a x • Concatenare poi le liste Tempo O(n + k) come per IntegerSort 47
Algoritmi e strutture dati
da Demetrescu et al. McGraw Hill 2004
Luigi Laura
Stabilità • Un algoritmo è stabile se preserva ordine iniziale tra elementi uguali (stessa chiave) • QuickSort è stabile se la partizione lo rende stabile • MergeSort è stabile se divisione lo rende stabile (pari e dispari non lo rende stabile) • HeapSort non è stabile • BucketSort può essere reso stabile appendendo gli elementi di X in coda alla opportuna lista Y[i] 48
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
RadixSort • Cosa fare se k > n, ad esempio k = Θ(nc)? • Rappresentiamo gli elementi in base b, ed eseguiamo una serie di BucketSort • Procediamo dalla cifra meno significativa a quella più significativa Per b=10
2397 4368 5924
5924 2397 4368
5924 4368 2397
4368 2397 5924
2397 4368 5924
da Demetrescu et al. McGraw Hill 2004
49
Algoritmi e strutture dati
Luigi Laura
Correttezza • Se x e y hanno una diversa t-esima cifra, la t-esima passata di BucketSort li ordina • Se x e y hanno la stessa t-esima cifra, la proprietà di stabilità del BucketSort li mantiene ordinati correttamente Dopo la t-esima passata di BucketSort, i numeri sono correttamente ordinati rispetto alle t cifre meno significative 50
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Tempo di esecuzione • O(logb k) passate di bucketsort • Ciascuna passata richiede tempo O(n + b) O( (n + b) logb k) Se b = Θ(n), si ha O(n logn k) = O n
log k log n
Tempo lineare se k = O(nc), c costante da Demetrescu et al. McGraw Hill 2004
51
Algoritmi e strutture dati
Luigi Laura
Riepilogo • Nuove tecniche algoritmiche: – – – –
Incrementale (SelectionSort, InsertionSort) Divide et impera (MergeSort, QuickSort) Plug in di strutture dati efficienti (HeapSort) Randomizzazione (QuickSort)
• Alberi di decisione per dimostrare lower bound • Sfruttare proprietà dei dati in ingresso (fuori dal modello) per progettare algoritmi più efficienti: algoritmi lineari
52
da Demetrescu et al. McGraw Hill 2004
Algoritmi e strutture dati
Luigi Laura
Esempio di esecuzione
53
da Demetrescu et al. McGraw Hill 2004