1 / 65

Lezione 9

Lezione 9. Code con priorità Ordinamento. Sommario. Code con priorità Ordinamento Selection Sort Bubble Sort Heap Sort Quick Sort. Coda con priorità. Una coda con priorità è una struttura dati dinamica che permette di gestire una collezione di dati con chiave numerica.

conway
Télécharger la présentation

Lezione 9

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lezione 9 Code con priorità Ordinamento

  2. Sommario • Code con priorità • Ordinamento • Selection Sort • Bubble Sort • Heap Sort • Quick Sort

  3. Coda con priorità • Una coda con priorità è una struttura dati dinamica che permette di gestire una collezione di dati con chiave numerica. • Una coda con priorità offre le operazioni di • inserimento: di un elemento nell’insieme • massimo: restituisce l’elemento con chiave più grande • cancellazione-massimo: restituisce l’elemento con chiave più grande e lo rimuove dalla collezione

  4. Applicazioni della Coda con Priorità • Le Code con priorità sono strutture dati molto comuni in informatica. • Es: • Gestione di processi: ad ogni processo viene associata una priorità. Una coda con priorità permette di conoscere in ogni istante il processo con priorità maggiore. In qualsiasi momento i processi possono essere eliminati dalla coda o nuovi processi con priorità arbitraria possono essere inseriti nella coda. • Per implementare una coda con priorità utilizzeremo una struttura dati chiamata heap

  5. Nota su gli alberi binari • Intuitivamente (vedremo meglio successivamente) un albero binario è una struttura dati formata da nodi collegati fra di loro (come per la struttura dati lista) • come per una lista, per ogni nodo esiste un unico nodo predecessore • a differenza di una lista, ogni nodo è collegato con uno o due nodi successori

  6. Heap • La struttura dati heap binario è un albero binario quasi completo • un albero binario quasi completo è un albero binario riempito completamente su tutti i livelli tranne eventualmente l’ultimo che è riempito da sinistra a destra

  7. Heap • Perché un albero binario quasi completo sia uno heap deve valere la seguente: • Proprietà dell’ordinamento parziale dello heap • il valore di un nodo figlio (successore) è minore o uguale a quello del nodo padre (predecessore)

  8. Heap • Si implementa l’albero tramite un vettore • Uno heap A ha un attributo heap-size[A] che specifica il numero di elementi contenuto nello heap • nessun elemento in A[1,length[A]] dopo heap-size[A] è un elemento valido dello heap • La radice dell’albero è A[1] • L’indice del padre di un nodo di posizione i è i/2 • L’indice del figlio sinistro di un nodo i è 2 i • L’indice del figlio destro di un nodo i è 2 i +1

  9. 16 14 10 8 7 9 3 2 4 1 Visualizzazione di uno heap 1 2 3 4 5 6 7 8 9 10 16 14 10 8 7 9 3 2 4 1 1 2 3 4 5 6 7 8 9 10

  10. Pseudocodice Operazioni Heap Parent(i) 1 return i/2 Left(i) 1 return 2 i Right(i) 1 return 2 i + 1

  11. Mantenimento proprietà heap • A seguito di varie operazioni sullo heap può accadere che un nodo violi la proprietà dello heap • La procedura Heapify prende in ingresso uno heap A e l’indice i di un nodo che potenzialmente viola la proprietà e ristabilisce la proprietà di ordinamento parziale sull’intero heap • si assume che i sottoalberi figli del nodo i siano radici di heap che rispettano la proprietà di ordinamento parziale

  12. Spiegazione • L’idea è di far “affondare” il nodo che viola la proprietà di ordinamento parziale fino a che la proprietà non viene ripristinata • per fare questo si determina il nodo figlio più grande e si scambia il valore della chiave fra padre e figlio • si itera ricorsivamente il procedimento sul nodo figlio sostituito

  13. Pseudocodice Heapify Heapify(A,i) 1 l Left(i) 2 r Right(i) 3 if l  heap-size[A] e A[l]>A[i] 4 then largest  l 5 else largest  i 6 if r  heap-size[A] e A[r]>A[largest] 7 then largest  r 8 if largest  i 9 then scambia A[i]  A[largest] 10 Heapify(A,largest)

  14. Visualizzazione Heapify 16 16 i 4 10 14 10 9 3 14 7 i 9 3 4 7 2 8 1 2 8 1 16 14 10 9 3 8 7 2 4 1

  15. Nota sugli alberi binari • Un albero binario completo di altezza h ha 2h+1-1 nodi • infatti intuitivamente: • un albero binario completo di altezza 0 ha un unico nodo: la radice • un albero binario completo di altezza 1 è composto dalla radice e dai suoi due figli • all’aumentare di un livello ogni figlio genera altri due figli e quindi si raddoppia il numero di nodi del livello precedente • Ogni livello di un albero binario completo contiene tanti nodi quanti sono contenuti in tutti i livelli precedenti +1 • infatti passando da h a h+1 si passa da 2h+1-1 a 2h+2-1 nodi ovvero a 2(2h+1) -1 nodi quindi il nuovo livello ha aggiunto 2h+1 nodi ad un albero che prima ne conteneva 2h+1-1

  16. Tempo di calcolo di Heapify • Le istruzioni per determinare il maggiore fra i, l e r impiegano un tempo (1) • Ricorsivamente si chiama Heapify su uno dei sottoalberi radicati in l o r • Il sottoalbero dei figli hanno al più dimensione 2n/3 • il caso peggiore è quando l’ultimo livello è pieno per metà ovvero uno dei sottoalberi è completo • Il tempo di esecuzione è pertanto: • T(n)=T(2n/3)+ (1) • per il Teorema Principale si ha T(n)= (lg n)

  17. Costruzione di uno heap • Si può usare la procedura Heapify in modo bottom-up, cioè a partire dai livelli più bassi dell’albero, per convertire un Array in uno Heap • Gli elementi A[ n/2+1 .. n] sono tutte foglie dell’albero e pertanto ognuno di essi è già uno heap di 1 elemento • Si inizia dagli elementi padri dei nodi A[ n/2+1 .. n] • Dato che procediamo in modo bottom-up allora sicuramente i sottoalberi di un nodo sottoposto a Heapify sono heap

  18. Pseudocodice Costruzione Heap Build-Heap(A) 1 heap-size[A] Length[A] 2 for i length[A]/2 downto 1 3 do Heapify(A,i)

  19. 16 4 4 4 4 4 16 14 1 1 1 1 10 10 10 3 3 3 14 14 14 2 8 2 16 16 16 16 7 7 9 9 9 9 9 9 10 10 10 3 3 3 14 14 2 2 2 2 8 8 8 4 8 8 1 7 7 7 7 1 Visualizzazione Costruzione 1 2 3 4 5 6 7 8 9 10 4 1 3 2 16 9 10 14 8 7

  20. Coda con priorità con heap • Risulta semplice implementare le varie operazioni di una coda con priorità utilizzando uno heap • Extract Max: basta restituire la radice dello heap • Heap Extract Max: dopo la restituzione dell’elemento massimo, posiziona l’ultimo elemento dello heap nella radice ed esegue Heapify per ripristinare la proprietà di ordinamento parziale • Heap Insert: la procedura inserisce il nuovo elemento come elemento successivo all’ultimo e lo fa salire fino alla posizione giusta facendo “scendere” tutti padri

  21. Pseudo codice operazioni di coda con priorità Heap-Extract-Max(A) 1 max  A[1] 2 A[1]  A[heap-size[A]] 3 heap-size[A]  heap-size[A]-1 4 Heapify(A,1) 5 return max Heap-Insert(A,key) 1 heap-size[A]  heap-size[A]+1 2 i  heap-size[A] 3 while i>1 e A[Parent(i)]<key 4 do A[i]  A[Parent(i)] 5 i  Parent(i) 6 A[i]  key

  22. Visualizzazione Heap Insert 16 16 14 10 14 10 Key:15 9 3 8 7 9 3 8 7 2 4 1 / 2 4 1 16 16 / 10 15 10 9 3 9 3 8 14 8 14 7 7 2 4 1 2 4 1

  23. Ordinamento • Il problema consiste nell’elaborare insiemi di dati costituiti da record • Esiste un elemento del record è detto chiave • L’obiettivo dei metodi di ordinamento consiste nel riorganizzare i dati in modo che le loro chiavi siano disposte secondo un ordine specificato (generalmente numerico o alfabetico)

  24. Metodi • Si distinguono metodi: • interni: se l’insieme di dati è contenuto nella memoria principale • esterni: se l’insieme di dati è immagazzinato su disco o nastro • Per metodi interni è possibile l’accesso casuale ai dati, mentre per i metodi esterni è possibile solo l’accesso sequenziale o a grandi blocchi

  25. Tipo di ordinamento • Si distinguono i metodi di ordinamento in stabili o non stabili. • Un metodo di ordinamento si dice stabile se preserva l’ordine relativo dei dati con chiavi uguali all’interno del file da ordinare • Se si usa un metodo stabile per ordinare per anno di corso una lista di studenti già ordinata alfabeticamente otterremo una lista in cui gli studenti dello stesso anno sono ordinati alfabeticamente

  26. Tipo di ordinamento • Si distinguono i metodi di ordinamento in diretti o indiretti. • Un metodo di ordinamento si dice diretto se accede all’intero record del dato da confrontare, indiretto se utilizza dei riferimenti (puntatori) per accedervi • Metodi indiretti sono utili quando si devono ordinare dati di grandi dimensioni • In questo modo non è necessario spostare i dati in memoria ma solo i puntatori ad essi.

  27. Tipo di ordinamento • Si distinguono i metodi di ordinamento sul posto e non, che fanno cioè uso di strutture ausiliare • Un metodo si dice che ordina sul posto se durante l’elaborazione riorganizza gli elementi del vettore in ingresso all’interno del vettore stesso • Se il metodo, per poter operare, ha necessità di allocare un vettore di appoggio dove copiare i risultati parziali o finali dell’elaborazione (della stessa dimensione del vettore in ingresso) abbiamo il secondo caso

  28. Selection Sort • E’ uno degli algoritmi più semplici • Il principio è: • si determina l’elemento più piccolo di tutto il vettore • lo si scambia con l’elemento in prima posizione del vettore • si cerca il secondo elemento più grande • lo si scambia con l’elemento in seconda posizione del vettore • si procede fino a quando l’intero vettore è ordinato • Il nome deriva dal fatto che si seleziona di volta in volta il più piccolo elemento fra quelli rimanenti

  29. Pseudocodice per SelectionSort SelectionSort(A) 1 for i  1 to length[A] 2 do min  i 3 for j  i+1 to length[A] 4 do if(A[j]<A[min]) 5 then min  j 6 scambia A[i]  A[min]

  30. Caratteristiche del SelectionSort • Il tempo di calcolo è T(n)= (n2) • infatti: • per ogni dato di posizione i si eseguono n-1-i confronti • il numero totale di confronti è pertanto (posto j= n-1-i ) • j=n-1..1 j = n(n-1)/2 = (n2) • Più precisamente il Selection Sort effettua circa n2/2 confronti e n scambi

  31. Caratteristiche del SelectionSort • Uno svantaggio è che il tempo di esecuzione non dipende (in modo significativo) dal grado di ordinamento dei dati iniziali • Un vantaggio è che ogni elemento è spostato una sola volta. • Se è necessario spostare i dati, allora per dati molto grandi questo è l’algoritmo che asintoticamente effettua il minor numero di spostamenti possibili. • Se il tempo di spostamento è dominante rispetto al tempo di confronto diventa un algoritmo interessante

  32. BubbleSort • E’ un metodo elementare • Il principio di funzionamento è: • si attraversa il vettore scambiando coppie di elementi adiacenti • ci si ferma quando non è più richiesto alcuno scambio • Il nome deriva dal seguente fenomeno: • quando durante l’attraversamento si incontra l’elemento più piccolo non ancora ordinato questo viene sempre scambiato con tutti, affiorando fino alla posizione giusta come una bolla • nel processo gli elementi maggiori affondano e quelli più leggeri salgono a galla

  33. PseudoCodice per il BubbleSort BubbleSort(A) 1 for i  1 to length[A] 2 do for j  length[A] downto i-1 4 do if(A[j-1] > A[j]) 5 then scambia A[j-1]  A[j]

  34. Caratteristiche del BubbleSort • Il tempo di calcolo è T(n)= (n2) • infatti: • per ogni dato di posizione i si eseguono i confronti e i scambi • il numero totale di confronti è pertanto • i=1..n-1 i = n(n-1)/2 = (n2) • Il Bubble Sort effettua circa n2/2 confronti e n2/2 scambi • in generale è peggiore del selection sort

  35. Heap Sort • Il metodo di ordinamento Heap Sort sfrutta la proprietà di ordinamento parziale dello Heap • L’idea è di selezionare l’elemento più grande, eliminarlo dallo heap e poi utilizzare la procedura Heapify per ripristinare la proprietà di ordinamento parziale • in pratica piuttosto che eliminare gli elementi si inseriscono come elemento più prossimo oltre i limiti dello heap

  36. Pseudocodice per HeapSort HeapSort(A) 1 BuildHep(A) 2 for i  length[A] downto 2 3 do scambia A[1]  A[i] 4 heap-size[A]  heap-size[A]-1 5 Heapify(A,1)

  37. 16 10 14 9 3 8 4 2 7 14 10 10 2 8 7 8 2 8 1 4 3 3 3 1 3 3 9 1 4 8 1 4 4 4 4 4 7 7 2 7 7 7 2 7 7 1 8 1 9 8 8 9 8 1 2 9 9 9 9 9 3 3 3 10 10 10 10 10 10 2 2 2 14 14 14 14 14 14 14 1 4 16 16 16 16 16 16 16 16 1 Visualizzazione HeapSort

  38. Tempo di Calcolo dell’HeapSort • L’algoritmo chiama n-1 volte la procedura Heapify • Si deve determinare il tempo di calcolo di Heapify • Abbiamo visto che per Heapify si ha T(n)= (lg n) • Pertanto il tempo di calcolo per HeapSort è: • T(n)= (n lg n)

  39. QuickSort • Il QuickSort, come il MergeSort, è un algoritmo basato sul paradigma Divide et Impera • Fasi: • Divide: il vettore A[p..r] è riorganizzato in modo da avere due sottosequenze A[p..q] e A[q+1..r] tali che qualsiasi elemento in A[p..q] è minore di un qualsiasi elemento in A[q+1..r]. L’indice q è calcolato da questa procedura di partizionamento • Impera: le due sottosequenze sono ordinate ricorsivamente • Combina: non ce ne è bisogno. Infatti, poiché le sottosequenze sono già ordinate internamente e qualsiasi elemento in A[p..q] è minore di un qualsiasi elemento in A[q+1..r], l’intero vettore A[p..r] è subito ordinato

  40. PseudoCodice QuickSort(A,p,r) 1 if p<r 2 then q  Partition(A,p,r) 3 QuickSort(A,p,q) 4 QuickSort(A,q+1,r)

  41. Spiegazione Intuitiva della Procedura Partition • Si prende un elemento, ad es. il primo elemento della prima sottosequenza, come elemento perno • si vuole dividere il vettore A in due sottosequenze: • nella prima devono esserci solo elementi <= 5 • nella seconda solo elementi >=5 p r 5 3 2 6 4 1 3 7 x=A[p]=5

  42. Spiegazione Intuitiva della Procedura Partition • Si fanno crescere due regioni da entrambi gli estremi, utilizzando gli indici i,j a partire dagli estremi i i j j Elementi <=5 Elementi >=5

  43. Spiegazione Intuitiva della Procedura Partition • Mentre le due regioni crescono si verifica il valore degli elementi • Se un elemento non deve appartenere alla regione in cui si trova (o se l’elemento ha un valore eguale al valore perno) si smette di far crescere la regione • Quando non è possibile far crescere nessuna delle due regioni si scambiano gli elementi fra loro i i j j 7 3 3 7 Elementi <=5 Elementi <=5 Elementi >=5 Elementi >=5

  44. Spiegazione Intuitiva della Procedura Partition • Quando i diventa maggiore di j allora abbiamo completato le due regioni • La procedura termina i j Elementi <=5 Elementi >=5

  45. PseudoCodice per Partition Partition(A,p,r) 1 x  A[p] 2 i p-1 3 j r+1 4 while TRUE 5 do repeat j j-1 6 until A[j]  x 7 repeat i i+1 8 until A[i]  x 9 if i < j 10 then scambia A[i]  A[j] 11 else return j

  46. Visualizzazione i j i j 5 3 2 6 4 1 3 7 5 3 2 6 4 1 3 7 i j i j 5 3 2 6 4 1 3 7 3 3 2 6 4 1 5 7 i j i j 3 3 2 6 4 1 5 7 3 3 2 6 4 1 5 7 i j i j 3 3 2 1 4 6 5 7 3 3 2 1 4 6 5 7 i j j i 3 3 2 1 4 6 5 7 3 3 2 1 4 6 5 7

  47. Prestazioni del QuickSort • Il tempo di esecuzione del QuickSort dipende dal fatto che il partizionamento sia più o meno bilanciato • il partizionamento dipende dagli elementi pivot. • Se il partizionamento è bilanciato si hanno le stesse prestazioni del MergeSort • altrimenti può essere tanto lento quanto l’InsertionSort

  48. Caso peggiore • Il caso di peggior sbilanciamento si ha quando il partizionamento produce due sottosequenze di lunghezza 1 e n-1 • Il partizionamento richiede un tempo (n) e il passo base della ricorsione richiede T(1)=(1) pertanto: • T(n)=T(n-1)+ (n) • ad ogni passo si decrementa di 1 la dimensione dell’input, occorreranno pertanto n passi per completare la ricorsione • T(n)= k=1..n(k) = (k=1..nk) = (n2)

  49. Caso migliore • Il caso migliore si ha se ad ogni partizionamento di divide in due sottosequenze di dimensione identica l’input • in questo caso si ha, come nel caso del MergeSort • T(n)=2T(n/2)+ (n) • ovvero, per il Teorema Principale: • T(n)= (n lg n)

  50. Caso medio • Per avere una intuizione di cosa accade nel caso medio può risultare utile introdurre il concetto di albero di ricorsione

More Related