Docsity
Docsity

Prepara i tuoi esami
Prepara i tuoi esami

Studia grazie alle numerose risorse presenti su Docsity


Ottieni i punti per scaricare
Ottieni i punti per scaricare

Guadagna punti aiutando altri studenti oppure acquistali con un piano Premium


Guide e consigli
Guide e consigli


Sintesi degli algoritmi , Sintesi del corso di Algoritmi E Programmazione Avanzata

Sintesi dei principali algoritmi di ricerca, con una breve descrizione sul funzionamento e sui costi.

Tipologia: Sintesi del corso

2014/2015

In vendita dal 28/03/2015

pasqualerestaino
pasqualerestaino 🇮🇹

4

(1)

2 documenti

1 / 3

Toggle sidebar

Questa pagina non è visibile nell’anteprima

Non perderti parti importanti!

bg1
SINTESI ALGORITMI
ORDINAMENTI QUADRATICI
SELECTION SORT: L’ordinamento Selection Sort è un algoritmo di ordinamento, il cui tempo di
esecuzione non dipende dall’input, ma dalla dimensione dell’array. L’algoritmo seleziona di volta in
volta il numero minore della sequenza di partenza e lo sposta nella sequenza ordinata; di fatto la
sequenza viene suddivisa in due parti: la sottosequenza ordinata, che occupa le prime posizioni
dell’array, e la sottosequenza da ordinare, che costituisce la parte restante dell’array. Dovendo
ordinare un array A di lunghezza n, si fa scorrere l’indice i da 1 a n-1, ripetendo i seguenti passi: si
cerca il più piccolo elemento della sottosequenza A[i…n], e si scambia questo elemento con
l’elemento i-esimo.
CASO MIGLIORE, PEGGIORE E MEDIO ----- > O(n2)
INSERTIONSORT: L’insertion Sort è un algoritmo relativamente semplice per ordinare un array,
ordinandolo senza doverne crearne una copia, risparmiando memoria. Si assume che la sequenza da
ordinare sia partizionata in una sottosequenza già ordinata, all’inizio composta da un solo elemento,
e una ancora da ordinare. Alla k-esima iterazione, la sequenza già ordinata contiene k elementi. In
ogni iterazione viene rimosso un elemento dalla sottosequenza non ordinata e inserito nella posizione
corretta della sottosequenza ordinata, estendendola così di un elemento. Per fare questo,
un’implementazione tipica dell’algoritmo utilizza due indici: uno punta all’elemento da ordinare e
l’altro all’elemento immediatamente precedente. Se l’elemento puntato dal secondo indice è
maggiore di quello a cui punta il primo indice, i due elementi vengono scambiati di posto; altrimenti
il primo indice avanza. Il primo indice punta inizialmente al secondo elemento dell’array, il secondo
inizia dal primo.
CASO MIGLIORE,PEGGIORE E MEDIO ------ > O(n2)
BUBBLESORT:Nell’ algoritmo BubbleSort (ordinamento a bolle) ogni coppia di elementi adiacenti
della lista viene comparata e se essi sono nell’ordine sbagliato vengono invertiti. L’algoritmo scorre
poi tutta la lista finchè non vengono più eseguiti scambi, situazione che indica che la lista è ordinata.
CASO MIGLIORE, PEGGIORE E MEDIO ------- > O (n2)
ORDINAMENTI OTTIMI
MERGESORT: Algoritmo basato su confronti che utilizza un processo di risoluzione ricorsivo,
sfruttando la tecnica del divide et impera, che consiste nella suddivisione del problema in
sottoproblemi della stessa natura di dimensione via via più piccola. Se la sequenza da ordinare ha
lunghezza 0 oppure 1, è già ordinata, altrimenti la sequenza viene divisa in due metà. Ognuna di
queste due sottosequenza viene ordinata, applicando ricorsivamente l’algoritmo (impera). Alla fine le
due sottosequenze vengono fuse. Per fare questo, si estrae ripetutamente il minimo delle due
sottosequenze e lo si pone nella sequenza in uscita che risulterà ordinata.
CASO MIGLIORE, PEGGIORE E MEDIO ------ > O (n log n)
HEAPSORT: L’heapsort è un algoritmo iterativo che per eseguire l’ordinamento, utilizza una
struttura chiamata heap, il quale è rappresentabile con un albero binario in cui tutti i nodi seguono
una data proprietà, detta priorità. Esso è completo fino al penultimo livello dell’albero e ad ogni
nodo corrisponde uno ed uno solo elemento. In uno heap decrescente (utilizzato per ordinare ad
esempio un array in senso crescente) ogni nodo padre contiene un valore maggiore o uguale a quello
pf3

Anteprima parziale del testo

Scarica Sintesi degli algoritmi e più Sintesi del corso in PDF di Algoritmi E Programmazione Avanzata solo su Docsity!

SINTESI ALGORITMI

ORDINAMENTI QUADRATICI

SELECTION SORT: L’ordinamento Selection Sort è un algoritmo di ordinamento, il cui tempo di esecuzione non dipende dall’input, ma dalla dimensione dell’array. L’algoritmo seleziona di volta in volta il numero minore della sequenza di partenza e lo sposta nella sequenza ordinata; di fatto la sequenza viene suddivisa in due parti: la sottosequenza ordinata, che occupa le prime posizioni dell’array, e la sottosequenza da ordinare, che costituisce la parte restante dell’array. Dovendo ordinare un array A di lunghezza n, si fa scorrere l’indice i da 1 a n-1, ripetendo i seguenti passi: si cerca il più piccolo elemento della sottosequenza A[i…n], e si scambia questo elemento con l’elemento i-esimo.

CASO MIGLIORE, PEGGIORE E MEDIO ----- > O(n^2 )

INSERTIONSORT: L’insertion Sort è un algoritmo relativamente semplice per ordinare un array, ordinandolo senza doverne crearne una copia, risparmiando memoria. Si assume che la sequenza da ordinare sia partizionata in una sottosequenza già ordinata, all’inizio composta da un solo elemento, e una ancora da ordinare. Alla k-esima iterazione, la sequenza già ordinata contiene k elementi. In ogni iterazione viene rimosso un elemento dalla sottosequenza non ordinata e inserito nella posizione corretta della sottosequenza ordinata, estendendola così di un elemento. Per fare questo, un’implementazione tipica dell’algoritmo utilizza due indici: uno punta all’elemento da ordinare e l’altro all’elemento immediatamente precedente. Se l’elemento puntato dal secondo indice è maggiore di quello a cui punta il primo indice, i due elementi vengono scambiati di posto; altrimenti il primo indice avanza. Il primo indice punta inizialmente al secondo elemento dell’array, il secondo inizia dal primo.

CASO MIGLIORE,PEGGIORE E MEDIO ------ > O(n 2 )

BUBBLESORT:Nell’ algoritmo BubbleSort (ordinamento a bolle) ogni coppia di elementi adiacenti della lista viene comparata e se essi sono nell’ordine sbagliato vengono invertiti. L’algoritmo scorre poi tutta la lista finchè non vengono più eseguiti scambi, situazione che indica che la lista è ordinata.

CASO MIGLIORE, PEGGIORE E MEDIO ------- > O (n 2 )

ORDINAMENTI OTTIMI

MERGESORT: Algoritmo basato su confronti che utilizza un processo di risoluzione ricorsivo, sfruttando la tecnica del divide et impera , che consiste nella suddivisione del problema in sottoproblemi della stessa natura di dimensione via via più piccola. Se la sequenza da ordinare ha lunghezza 0 oppure 1, è già ordinata, altrimenti la sequenza viene divisa in due metà. Ognuna di queste due sottosequenza viene ordinata, applicando ricorsivamente l’algoritmo (impera). Alla fine le due sottosequenze vengono fuse. Per fare questo, si estrae ripetutamente il minimo delle due sottosequenze e lo si pone nella sequenza in uscita che risulterà ordinata.

CASO MIGLIORE, PEGGIORE E MEDIO ------ > O (n log n)

HEAPSORT: L’heapsort è un algoritmo iterativo che per eseguire l’ordinamento, utilizza una

struttura chiamata heap , il quale è rappresentabile con un albero binario in cui tutti i nodi seguono una data proprietà, detta priorità. Esso è completo fino al penultimo livello dell’albero e ad ogni nodo corrisponde uno ed uno solo elemento. In uno heap decrescente (utilizzato per ordinare ad esempio un array in senso crescente) ogni nodo padre contiene un valore maggiore o uguale a quello

dei suoi due figli diretti, di conseguenza risulterà maggiore anche di tutti i nodi che si trovano nel sottoalbero di cui esso è la radice; questo non implica affatto che nodi a profondità maggiore contengano valori minori di quelli a profondità minore. Quindi in ogni istante, in un heap decrescente, la radice contiene il valore maggiore. Questa struttura è molto usata, in particolare, per l'ordinamento di array. In questo caso si considera come radice l'elemento iniziale di indice 1; inoltre i figli di un nodo con indice j, avranno indice rispettivamente 2j, quello sinistro, 2j +1 quello destro.Per comprendere meglio il funzionamento dell'algoritmo è bene capire che gli elementi che si trovano nella seconda metà dell'array rappresenteranno foglie dello heap e quindi esse saranno già al loro posto giusto; non vi è infatti alcun elemento dopo di esse. L'algoritmo che ordina in senso crescente inizia creando uno heapdecrescente. Per ogni iterazione si copia la radice (primo elemento dell'array) in fondo all'array stesso, eseguendo uno scambio di elementi. L'algoritmo poi ricostruisce uno heap di elementi spostando verso il basso la nuova radice, e ricomincia con un altro scambio (tra il primo elemento dell'array e quello in posizione ), eseguendo un ciclo che considera array di dimensione progressivamente decrescente. CASO MIGLIORE, PEGGIORE E PESSIMO ----- > O (n log n)

QUICKSORT: E’ un algoritmo di ordinamento in loco, che come mergesort, si basa sul paradigma divide et impera. La base del suo funzionamento è l’utilizzo ricorsivo della procedura partition: preso un elemento da una struttura dati si pongono gli elementi minori a sinistra rispetto a questo e gli elementi maggiori a destra. Dopo questo stadio si ha che il perno è nella sua posizione definitiva.

CASO PEGGIORE ------- >

CASO OTTIMO E MEDIO ------- >

ORDINAMENTI LINEARI

INTEGERSORT: L’algoritmo integersort è un algoritmo di ordinamento per valori numerici interi con complessità lineare. L’algoritmo si basa sulla conoscenza a priori dell’intervallo in cui sono compresi i valori da ordinare. L’algoritmo conta il numero di occorrenze di ciascun valore presente nell’array da ordinare, memorizzando questa informazione in un array temporaneo di dimensione pari all’intervallo di valori. Il numero di ripetizioni dei valori inferiori indica la posizione del valore immediatamente successivo.

CASO MIGLIORE, PEGGIORE E MEDIO -------- > O (n + k )

BUCKETSORT: Il BucketSort è un algoritmo di ordinamento per valori numerici che si assume siano distribuiti uniformemente in un intervallo semichiuso [0,1). La complessità del bucketsort è lineare O ( n +m) (ove m è il valore massimo dell’array), questo è possibile in quanto l’algoritmo è basato su confronti. L’intervallo dei valori, noto a priori, è diviso in intervalli più piccoli, detti bucce. Ciascun valore dell’array è quindi inserito nel bucket vengono ordinati e l’algoritmo si conclude con a concatenazione dei valori contenuti nei bucket.

CASO PEGGIORE ----------- > O (n + k)

RADIXSORT: Il radixSort è un algoritmo di ordinamento per valori numerici interi con complessità computazionale O (nk), dove n è la lunghezza dell’array e k è la media del numero di cifre degli n numeri. RadixSort utilizza un procedimento contro intuitivo per l’uomo, ma più facilmente implementabile. Esegue gli ordinamenti per posizione della cifra ma partendo dalla cifra meno significativa. Questo affinchè l’algoritmo non si trovi a dover operare ricorsivamente su sottoproblemi di dimensione non valutabili a priori.

CASO PEGGIORE, MEDIO E MIGLIORE --------- > O (kN)