Capitolo 4 Ordinamento: lower bound Ω(n log n) e MergeSort ((*) l’intera lezione) Algoritmi e...

Capitolo 4Ordinamento: lower bound Ω(n log n) e

MergeSort ((*) l’intera lezione)

Algoritmi e Strutture Dati

Camil Demetrescu, Irene Finocchi, Giuseppe F. ItalianoAlgoritmi e strutture dati

Copyright © 2004 - The McGraw - Hill Companies, srl2

Stato dell’arte

Insertion Sort 2

Insertion Sort 1

Θ(n)

Caso migliore

T(n)

Selection Sort Θ(n2)

Θ(n2)

Caso medio

Θ(n2)

Θ(n2)

Θ(n2)

Θ(n2)

Θ(n2)

Θ(n2)

Caso peggiore

Θ(n2)

Θ(n2)

O(n2)

S(n)

Θ(n)

Θ(n)

Θ(n)

Insertion Sort 3 Θ(n log n) Θ(n2) Θ(n2) O(n2) Θ(n)

Bubble-Sort Θ(n2) Θ(n2) Θ(n2) Θ(n2) Θ(n)


Upper e lower bound di un algoritmo e di un problema



Delimitazioni superiori (upper bound)Definizione (complessità di un algoritmo)Un algoritmo A ha costo di esecuzione O(g(n)) su istanze di dimensione n e rispetto ad una certa risorsa di calcolo (spazio o tempo), se la quantità f(n) di risorsa sufficiente per eseguire A su qualunque istanza di dimensione n (e quindi in particolare anche nel caso peggiore) verifica la relazione

f(n)=O(g(n)).Definizione (upper bound di un problema)Un problema P ha una delimitazione superiore alla complessità O(g(n)) rispetto ad una certa risorsa di calcolo (spazio o tempo) se esiste un algoritmo che risolve P il cui costo di esecuzione rispetto a quella risorsa è O(g(n)).



Delimitazioni inferiori (lower bound)DefinizioneUn algoritmo A ha costo di esecuzione (g(n)) su istanze di dimensione n e rispetto ad una certa risorsa di calcolo (spazio o tempo), se la quantità f(n) di risorsa necessaria per eseguire A nel caso peggiore (e quindi non è detto che debba essere necessaria per ogni istanza di dimensione n: istanze facili potrebbero richiedere meno risorse!) verifica la relazione

fworst(n)= (g(n)).

Definizione (lower bound o complessità intrinseca di un problema)Un problema P ha una delimitazione inferiore alla complessità (g(n)) rispetto ad una certa risorsa di calcolo (spazio o tempo) se ogni algoritmo che risolve P ha costo di esecuzione (g(n)) rispetto a quella risorsa.



Ottimalità di un algoritmo

DefinizioneDato un problema P con complessità intrinseca (g(n)) rispetto ad una certa risorsa di calcolo (spazio o tempo), un algoritmo che risolve P è ottimo (in termini di complessità asintotica, ovvero a meno di costanti moltiplicative e di termini additivi/sottrattivi di “magnitudine” inferiore) se ha costo di esecuzione O(g(n)) rispetto a quella risorsa.



Convenzioni• Se scriverò che un algoritmo ha complessità T(n) =

O(g(n)), intenderò che su ALCUNE istanze costerà Θ(g(n)), ma sulle rimanenti costerà o(g(n).

• Se scriverò che un algoritmo ha complessità T(n)=Θ(g(n)), intenderò che su TUTTE le istanze costerà Θ(g(n))

• Da ora in poi, quando parlerò di UB di un problema, mi riferirò alla complessità del MIGLIORE ALGORITMO che sono stato in grado di progettare sino a quel momento (ovvero, quello con minore complessità nel caso peggiore).

• Da ora in poi, quando parlerò di LB di un problema, mi riferirò alla PIÙ GRANDE delimitazione inferiore che sono stato in grado di dimostrare sino a quel momento.



Quindi, per il problema dell’ordinamento…

• Lower bound temporale: (n)– “banale”: dimensione dell’input

• Upper bound temporale: O(n2)– Insertion Sort 2 e 3

Abbiamo un gap lineare tra upper bound e lower bound!

È possibile chiudere tale gap?



Ordinamento per confronti

Dati due elementi ai ed aj, per determinarne l’ordinamento relativo effettuiamo una delle seguenti operazioni di confronto:

ai aj ; ai aj ; ai aj ; ai 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.



• Consideriamo un generico algoritmo A, che ordina eseguendo solo confronti: dimostreremo che A esegue (nel caso peggiore) (n log n) confronti

• Un generico algoritmo di ordinamento per confronti 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.

Un algoritmo di ordinamento per confronti può essere descritto in modo astratto usando un albero di decisione, nel quale i nodi interni rappresentano i confronti, mentre le foglie rappresentano gli output prodotti

Lower bound (n log n) per l’ordinamento


• Descrive le diverse sequenze di confronti che A esegue su un’istanza <a1,a2,…,an> di lunghezza n; i movimenti dei dati e tutti gli altri aspetti dell’algoritmo vengono ignorati

• Nodo interno (non foglia): i:j (modella il confronto tra ai e aj)• Nodo foglia: i1,i2,…,in (modella una risposta (output) dell’algoritmo, ovvero

una permutazione <ai1,ai2

,…,ain> degli elementi)

• L’albero di decisione è associato ad un algoritmo e alla dimensione n dell’istanza

Albero di decisione



Esempio

2:3

1,2,3 1:3 2,1,3 2:3

1:3

1:2

1,3,2 2,3,13,1,2 3,2,1

Š

Š Š

Š Š

Input <a1,a2,a3> Riconoscete l’algoritmo associato?

È proprio l’Insertion Sort 2!

Esercizio per casa: costruire l’albero di decisione per il SS e per il BS su una sequenza di 3 elementi.



• Per una particolare istanza, i confronti eseguiti da A su quella istanza rappresentano un cammino radice – foglia

• L’algoritmo segue un cammino diverso a seconda delle caratteristiche dell’input– Caso peggiore: cammino più lungo

– Caso migliore: cammino più breve

• Il numero di confronti nel caso peggiore è pari all’altezza dell’albero di decisione (ovvero alla lunghezza, in termini di numero di archi, del più lungo cammino radice-foglia)

Proprietà



Lemma: Un albero binario (ovvero, in cui ogni nodo interno ha al più due figli) con k foglie ha altezza h(k) log2 k.

Dim: Dimostrazione per induzione su k:– Caso base k=1: banale, perché ogni albero con una foglia deve avere

almeno altezza log21=0 (anche nel caso limite dell’albero costituito da un unico nodo )

– Caso k>1: supposto vero per k-1 foglie, dimostriamolo per k; poiché la radice ha almeno un figlio, uno dei suoi al più due sottoalberi deve contenere almeno la metà (parte intera superiore) delle foglie, e quindi

h(k) ≥1+h(k/2) ≥ (hp induttiva) 1+log2(k/2)

=1+log2k-log22=log2k. QED

Altezza in funzione delle foglie



• Consideriamo l’albero binario di decisione di un qualsiasi algoritmo che risolve il problema dell’ordinamento di n elementi

• Tale albero deve avere almeno n! foglie: infatti, se l’algoritmo è corretto, deve contemplare tutti i possibili output, ovvero le n! permutazioni della sequenza di n elementi in input

• Dal lemma precedente, avremo che l’altezza h(n) dell’albero di decisione sarà:

Il lower bound (n log n)

h(n) log2(#foglie) log2(n!)

Formula di Stirling:

n! (2n)1/2 ·(n/e)n

> (n/e)n

> log2 (n/e)n =

= n log2 (n/e)

= n log2 n – n log2 e

=

= (n log n) QED

=



• Problema dell’ordinamento:– Lower bound - (n log n) albero di decisione– Upper bound – O(n2) IS 2 e 3

• Abbiamo ridotto il gap tra LB e UB da Θ(n) a Θ(n/log n); proviamo a costruire un algoritmo ottimo (cioè a ridurre il gap a Θ(1)) usando 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

Un algoritmo ottimo: il MergeSort (John von Neumann, 1945)



Esempio di esecuzione

7 2 4 5 3 1 5 6

7 2 4 5 3 1 5 6

7 2 4 5 3 1 5 6

7 2 4 5 3 1 5 6

1 2 3 4 5 5 6 7

2 4 5 7 1 3 5 6

2 7 4 5 1 3 5 6

7 2 4 5 3 1 5 6

input

output

Input ed

output delle

chiamate

ricorsive



• 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 ancora completamente svuotato alla fine dell’array di output

Fusione di sequenze ordinate

Notazione: dato un array A e due indici x y, denotiamo con A[x;y] la porzione di A costituita da A[x], A[x+1],…,A[y]



Merge (A, i1, f1, f2)

1. Sia X un array ausiliario di lunghezza f2-i1+1

2. i=1

3. i2=f1+1

4. while (i1 f1 e i2 f2) do

5. if (A[i1] A[i2])

6. then X[i]=A[i1]

7. incrementa i e i1

8. else X[i]=A[i2]

9. incrementa i e i2

10. if (i1<f1) then copia A[i1;f1] alla fine di X

11. else copia A[i2;f2] alla fine di X

12. copia X in A[i1;f2]

fonde A[i1;f1] e A[f1+1;f2] output in A[i1;f2]

Osservazione: usa l’array ausiliario X

Algoritmo di fusione di sequenze ordinate



LemmaLa procedure Merge fonde due sequenze ordinate di lunghezza n1 e n2 eseguendo al più n1+ n2 -1 confrontiDim: Ogni confronto “consuma” un elemento di A.Nel caso peggiore tutti gli elementi tranne l’ultimo sonoaggiunti alla sequenza X tramite un confronto.Il numero totale di elementi è n1+ n2. Quindi il numero totaledi confronti è n1+ n2 -1. QED

Numero di confronti: C(n=n1+ n2)=O(n1+ n2)=O(n)(si noti che vale anche C(n)=Ω(minn1,n2))

Numero di operazioni (confronti + copie)? T(n)=(n1+ n2)

Costo dell’algoritmo di merge



MergeSort (A, i, f)

1. if (i f) then return

2. m = (i+f)/2

3. MergeSort(A,i,m)

4. MergeSort(A,m+1,f)

5. Merge(A,i,m,f)

MergeSort



• Il numero di confronti del MergeSort è descritto dalla seguente relazione di ricorrenza:

C(n) ≤ 2 C(n/2) + Θ(n) C(1)=0 (si noti che f(n)=Θ(n), in quanto il numero di confronti nelle fusioni è

ovviamente C(n)=O(n), ma anche C(n)=Ω(minn1,n2)=Ω(minn/2, n/2)=Ω(n))

• Usando il caso 2 del Teorema Master (infatti a=b=2, e quindi f(n)Θ(n)=Θ(nlog

22)Θ(nlog

ba)), si ottiene

C(n) = O(nlog22 log n) = O(n log n)

(si noti che utilizzo la notazione O in quanto nella relazione di ricorrenza compare il simbolo ≤)

• Infine, per il tempo di esecuzione totale (confronti + copie), si ha:T(n) = 2 T(n/2) + Θ(n) T(1)=1 T(n) = Θ(n log n)

(si noti che in questo caso utilizzo la notazione Θ in quanto nella relazione di ricorrenza compare il simbolo =)

Tempo di esecuzione


Più precisamente…

1. Nel caso peggiore, il MS esegue (n log ⌈ n - ⌉2 log ⌈ n⌉ + 1) confronti, che corrisponde ad un numero compreso tra (n log n - n + 1) e (n log n + n + O(log n))

2. Nel caso medio, il MS esegue (n log ⌈ n - ⌉2 log ⌈ n⌉ + 1) – 0.2645·n confronti

3. Nel caso migliore (array già ordinato), il MS esegue n-1 confronti



Osservazioni finali

• Problema dell’ordinamento: abbiamo chiuso il gap!

– Lower bound - (n log n) albero di decisione

– Upper bound – Θ(n log n) Merge Sort

• Il MergeSort è dunque un algoritmo (asintoticamente) ottimo rispetto al numero di confronti eseguiti nel caso peggiore

• Il MergeSort non ordina in loco, e utilizza memoria ausiliaria (l’occupazione di memoria finale è pari a 2n)

Capitolo 4 Ordinamento: lower bound Ω(n log n) e MergeSort ((*) l’intera lezione) Algoritmi e...

Documents

Transcript of Capitolo 4 Ordinamento: lower bound Ω(n log n) e MergeSort ((*) l’intera lezione) Algoritmi e...

Algoritmi e Strutture Dati - Computer Science Divisioncomputerscience.unicam.it/merelli/algoritmi06/Esercizi/... · Metodo della sostituzione Metodo di iterazione Metodo Master Metodo

Maturità Scientifica 2014 Problema 1 Corso di Ordinamento ... · Abbiamo così dimostrato che i numeri . hk, ... w in tre parti uguali. 3. ... Maturità Scientifica 2014 Corso di

Algoritmi di ordinamento lineari: • CountingSort ...twiki.di.uniroma1.it/pub/Intro_algo/AD/WebHome/Sorting_lineare.pdf · 3 Un esempio banale Problema: ordinare n interi presi nell’intervallo

Algoritmi e Strutture Dati - di.univaq.itproietti/slideASD2016/21-FloydWarshall.pdf · Capitolo 13 Cammini minimi: Algoritmo di Floyd e Warshall (1962) Algoritmi e Strutture Dati

Algorithm Mergesort: (nlogn) Complexity · Basic ideas behind the algorithm: 1 If the number of items is 0 or 1, return; otherwise: 1 Separate the list into two lists of equal or

Complessità e ordinamento di Ezio Sperduto

Scrivere la tesi di laurea con LaTeX - guit.sssup.it · 5.5 Creazione di PDF . . 29 5.6 Gli acronimi . . . . . 30 5.7 Codici ed algoritmi . 30 ... Italiani di TEX),2 che resta sempre

COSC 311: A HW1: S · HW1: SORTING Solutions 1) Theoretical predictions. Solution: On randomly ordered data, we expect the following ordering: Heapsort = Mergesort = Quicksort (deterministic

Algoritmi - UniPagrim/cdSISSIS/algoritmi.pdfAlgoritmo: La forma più antica di questo termine si trova nel latino medievale, in cui, con la parola algorithmus o algorismus, si designava

Mergesort CSE 2320 – Algorithms and Data Structures Vassilis Athitsos University of Texas at Arlington 1.

Opis in implementacija RSA - lkrv.fri.uni-lj.silkrv.fri.uni-lj.si/~ajurisic/kirv08/folije/f04.pdf · Ti algoritmi so hitri, vendar pa so probabilistiˇcni in ne deterministiˇcni.

Algorithm Mergesort: (nlogn) Complexity · Algorithm Mergesort: ( nlogn) Complexity Georgy Gimel’farb COMPSCI 220 Algorithms and Data Structures ... 91 2 25 8 70 20 65 15 50 31

Algoritmi e Strutture Dati 1 - cleii.unich.it · Si consideri una tabella hash con lista di trabocco contenente numeri interi. ... degli algoritmi di ordinamento Merge Sort Quick

PA - Curs 12 Algoritmi aleatorii - andrei.clubcisco.roandrei.clubcisco.ro/cursuri/f/f-sym/2pa/cursuri/2012cb/curs 13 CB.pdf · • Teorema mică a lui Fermat: n este prim n=> 0

EPITETI E TITOLI DI DEMETRA III parte (ἐν ἕλει – Λικμαίη)chi-lyra.com/pdf/studiodemetra/EPITETI_E_TITOLI_DI_DEMETRA_-_III.pdf · ordinamento la Vita è posta al di

ALGORITMI E PROGRAMMAZIONE STRUTTURATA

Controllo adattativo e algoritmi di stima per Uavcontrol.disp.uniroma2.it/~carnevale/archivio/Tesi/emanuelegentili/...• φ Angoli di Eulero • ωVelocità angolari • s Posizione

ΕΛΛΑΣ - vergaviagrande.gov.it · • ordinamento dello stato:repubblica ... greci vive nel moderno stato della Grecia (indipendente dal 1821) ed a ... • Per i discendenti delle