Sei sulla pagina 1di 27

Algoritmi e Strutture Dati

Capitolo 4 Ordinamento

Algoritmi e strutture dati

Giuseppe F. Italiano

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 desame 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

Giuseppe F. Italiano

Algoritmi e tempi tipici


Numerosi algoritmi Tre tempi tipici: O(n2), O(n log n), O(n)
n n log2 n n2 10 ~ 33 100 100 ~ 665 104 1000 106 109

~ 104 ~ 2107 ~ 31010 106 1012 1018

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Algoritmi di ordinamento

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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)
7 1 1 1
5

2 2 2 2

4 4 4 3

5 5 5 5

3 3 3 4

1 7 7 7

1 1 1

2 2 2

3 3 3

4 4 4

5 5 5

7 7 7

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

SelectionSort: analisi
k - esima estrazione di minimo costa tempo O(n-k)
In totale, il tempo di esecuzione :

O(n-k)
k=1

n-1

( i) = O(n )
2

n-1

i=1

[ cambiamento di variabile (i = n k) e serie aritmetica ]

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

InsertionSort
Approccio incrementale. Estende ordinamento da k a (k+1) elementi, posizionando elemento (k+1)-esimo nella posizione corretta rispetto ai primi k elementi

7 2 2

2 7 4

4 4 7

5 5 5

3 3 3

1 1 1

2 2 1

4 3 2

5 4 3

7 5 4

3 7 5

1 1 7

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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 :

O
[ serie aritmetica ]
8

( k) = O(n )
2

n-1

k=1

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

BubbleSort
Esegue una serie di scansioni dellarray
In ogni scansione confronta coppie di elementi adiacenti, scambiandoli se non sono nellordine corretto Dopo una scansione in cui non viene effettuato nessuno scambio larray 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
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Esempio di esecuzione
(1)

7 2 4 5 3 1 2 7 4 7 5 7 3 7 1 7

(3)

2 4 3 1 5 7 2 4 3 4 1 4 2 3 1 4 5 7 2 3 1 3 2 1 3 4 5 7 1 2 1 2 3 4 5 7

(4)

(2)

2 4 5 3 1 7 2 4 4 5 3 5 1 5 2 4 3 1 5 7

(5)

10

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

O( n2 ) quanto di peggio si possa fare: tutti i confronti possibili! Possiamo fare di meglio ?

11

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

1. QuickSort 2. MergeSort 3. HeapSort

12

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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

13

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Partizione in loco
Scorri larray 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

Giuseppe F. Italiano

Partizione in loco: un esempio


45 12 93 3 67 43 85 29 24 92 63 3 21

45 12 21 3

67 43 85 29 24 92 63 3

93

45 12 21 3

3 43 85 29 24 92 63 67 93

45 12 21 3

3 43 24 29 85 92 63 67 93

15

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Analisi nel caso peggiore


Nel caso peggiore, il pivot scelto ad ogni passo il minimo o il massimo degli elementi nellarray 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

Giuseppe F. Italiano

5 5 6 7 1 2 3 4 2 5 4 3 1 5 7 6 1 2 3 4 5 5 6 7 2 5 4 3 1 1 2 4 3 5 1 2 3 4 5 1 1 1 3 3 3
17

input dopo partition output

Esempio di esecuzione
Lalbero delle chiamate ricorsive pu essere sbilanciato

7 6 6 7 6 7 6 6 6

4 3 5 3 4 5 3 4 5 5 5 5

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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 :
C(n)=

n-1

a=0

1 n-1+C(a)+C(n-a-1) = n-1+ C(a) 2 n n


a=0

n-1

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

Giuseppe F. Italiano

Analisi nel caso medio


La relazione di ricorrenza C(n)= n-1+ 2 C(a) n ha soluzione C(n) 2 n log n
a=0 n-1

Dimostrazione per sostituzione Assumiamo per ipotesi induttiva che C(i) 2 i log i
C(n) n-1+ 2 2 i log i n-1+ 2 n n
i=0 n-1

x log x dx

Integrando per parti si dimostra che C(n) 2 n log n


19
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

MergeSort
Usiamo la tecnica del divide et impera: 1 Divide: dividi larray 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

Giuseppe F. Italiano

Fusione (Merge)
Due array ordinati A e B possono essere fusi rapidamente:
estrai ripetutamente il minimo di A e B e copialo nellarray di output, finch A oppure B non diventa vuoto copia gli elementi dellarray non vuoto alla fine dellarray di output

Tempo: O(n), dove n il numero totale di elementi


21
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Mergesort: esempio di esecuzione


7 2 4 5 3 1 5 6 1 2 3 4 5 5 6 7 7 2 4 5 2 4 5 7 7 2 2 7 7 7
22

input output

3 1 5 6 1 3 5 6 3 1 1 3 5 5 3 3 1 1 5 5 5 6 5 6 6 6

4 5 4 5 2 2 4 4

Input ed output delle chiamate ricorsive

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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)

23

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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 dellalbero 3) chiave(padre(v)) chiave(v) per ogni nodo v
24
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Struttura dati heap


Rappresentazione ad albero e con vettore posizionale
37 22 13 7 15 3 25 12 31 14 9

sin(i) = 2i des(i) = 2i+1


12 9

vettore posizionale
37 22 31 13 15 25 14 0 1 2 3 4 5 6 7 8 9 7 3

10 11 12 13 14 15

25

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Heap con struttura rafforzata


Le foglie nellultimo livello sono compattate a sinistra
37 22 13 7 3 12 15 9 25 31 14

vettore posizionale
37 22 31 13 15 25 14 0 1 2 3 4 5 6 7 7 8 3 12 9 9

Il vettore posizionale ha esattamente dimensione n

10 11

26

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Propriet salienti degli heap


1) Il massimo contenuto nella radice 2) Lalbero ha altezza O(log n) 3) Gli heap con struttura rafforzata possono essere rappresentati in un array di dimensione n
27
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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

Giuseppe F. Italiano

Estrazione del massimo


Copia nella radice la chiave contenuta nella la foglia pi a destra dellultimo livello Rimuovi la foglia Ripristina la propriet di ordinamento a heap richiamando fixHeap sulla radice Tempo di esecuzione: O(log n)
29
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Costruzione dellheap
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

Giuseppe F. Italiano

HeapSort
Costruisci un heap tramite heapify Estrai ripetutamente il massimo per (n-1) volte
ad ogni estrazione memorizza il massimo nella posizione dellarray che si appena liberata

O(n) O(n log n)

ordina in loco in tempo O(n log n)


31
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Possiamo fare meglio di O(n log n)?

32

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Lower bound
Dimostrazione (matematica) che non possiamo andare pi veloci di una certa quantit Pi precisamente, ogni algoritmo allinterno 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

Giuseppe F. Italiano

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

Giuseppe F. Italiano

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
35
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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 lunica 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

Giuseppe F. Italiano

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

Giuseppe F. Italiano

Alberi di decisione = algoritmi basati su confronti!


Ogni algoritmo basato su confronti pu essere rappresentato da un albero di decisione:
confronti scelti dallalgoritmo 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 nellalbero descrive confronti da effettuare e permutazione che produce soluzione
38
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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 allaltezza dellalbero di decisione Un albero di decisione per lordinamento di n elementi contiene almeno (n!) foglie
(una per ogni possibile permutazione degli n oggetti)
39
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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

Giuseppe F. Italiano

Il lower bound (n logn)


Lalbero di decisione ha almeno n! foglie La sua altezza almeno log2 (n!) Formula di Stirling: n! (2n)1/2 (n/e) n Quindi: log2 (n!) = (n log n)

41

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Ordinamenti lineari
(per dati con propriet particolari)

42

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

Sappiamo che gli n elementi da ordinare sono tutti distinti e nellintervallo [1,n] In quanto tempo possiamo ordinarli? O(1) Contraddice il lower bound? No. Perch?
43
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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
X Y 5 0 1 X Y 5 1 1 1 0 2 1 0 2 6 0 3 6 0 3 8 0 4 8 0 4 6 1 5 6 1 5 1 6 0 7 1 8 0 6 0 7 0 8 5 1 1 5 1 1 1 0 2 1 0 2 6 0 3 6 0 3 8 0 4 8 0 4 6 1 5 6 1 5 2 6 0 7 1 8 0 6 0 7 0 8 5 1 1 1 0 2 6 0 3 8 0 4 6 1 5 1 6 0 7 0 8

(a) Calcolo di Y

44

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

IntegerSort: fase 2
Scandisci Y da sinistra verso destra. Se Y[x] = k, scrivi in X il valore x per k volte
X Y 1 1 1 X Y 1 0 1 0 2 5 0 2 0 3 6 0 3 0 4 6 0 4 0 5 2 6 0 7 1 8 1 5 2 6 0 7 1 8 1 0 1 0 2 0 3 6 0 3 0 4 6 0 4 0 5 0 6 0 7 1 8 1 5 2 6 0 7 1 8 1 0 1 1 0 1 5 0 2 5 0 2 0 3 6 0 3 0 4 6 0 4 1 5 8 0 5 0 6 0 7 1 8 2 6 0 7 1 8

1 5 0 1 0 2

(b) Ricostruzione di X

45

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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

Giuseppe F. Italiano

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
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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

Giuseppe F. Italiano

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

49

Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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

Giuseppe F. Italiano

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 logk logn

Tempo lineare se k = O(nc), c costante


51
Da Demetrescu et al. McGraw Hill 2004

Algoritmi e strutture dati

Giuseppe F. Italiano

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

Giuseppe F. Italiano

Esempio di esecuzione
37 31 13 15 25 22 13 25 15 31 25 22 13 15 37 (2) 31 22 13 25 15 22 13 31 37 (3) 15 25 22

37 31 22 13 15 25 (1)

22 15 13 13

15

13

22 15 13 25 31 37 (4)

15 13 22 25 31 37 (5)

13 15 22 25 31 37 (6)
Da Demetrescu et al. McGraw Hill 2004

53