Algoritmi e Strutture Dati

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


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


3


Luigi Laura

Algoritmi di ordinamento

4



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)


5


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



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


7


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



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



Luigi Laura

Esempio di esecuzione

10



Luigi Laura

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


11


Luigi Laura

1. QuickSort 2. MergeSort 3. HeapSort

12



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


13


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



Luigi Laura

Partizione in loco: un esempio


15


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



Luigi Laura

Esempio di esecuzione L’albero delle chiamate ricorsive può essere sbilanciato


17


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



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


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



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


Luigi Laura

Mergesort: esempio di esecuzione

Input ed output delle chiamate ricorsive

22



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)


23


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



Luigi Laura

Struttura dati heap Rappresentazione ad albero e con vettore posizionale

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


25


Luigi Laura

Heap con struttura rafforzata Le foglie nell’ultimo livello sono compattate a sinistra

Il vettore posizionale ha esattamente dimensione n

26



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


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



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


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


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



Luigi Laura

Possiamo fare meglio di O(n log n)?

32



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



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



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


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



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



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



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


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



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)


41


Luigi Laura

Ordinamenti lineari (per dati con proprietà particolari)

42



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


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



Luigi Laura

IntegerSort: fase 2 Scandisci Y da sinistra verso destra. Se Y[x] = k, scrivi in X il valore x per k volte


45


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



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



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



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


49


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



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


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



Luigi Laura

Esempio di esecuzione

53
