A LGORITMI DI ORDINAMENTO Cinzia Reverberi. COS’È UN ALGORITMO? Un algoritmo è un insieme ben ordinato di operazioni non ambigue ed effettivamente calcolabili.

Slides:



Advertisements
Presentazioni simili
1 La Standard Template Library vettori, liste, mappe, …. find, replace, reverse, sort, …. puntatori intelligenti La libreria standard STL e una libreria.
Advertisements

Gli Algoritmi di ordinamento
INFORMATICA Algoritmi fondamentali
Argomenti della lezione
Uso avanzato di C.
Nel C non esiste un dato primario di tipo stringa; queste sono rappresentate con un array monodimensionale di caratteri (tipo char). Così per definire.
Iterazione A. Ferrari.
Unità G3 Algoritmi notevoli. Ordinamento Un insieme di dati {a0, a1, a2, …, an} si dice ordinato in ordine crescente se a0 a1 a2 a3 … an I dati sono generalmente.
Stringhe di caratteri In linguaggio C.
Algoritmi notevoli.
Algoritmi notevoli In linguaggio C.
1 Informatica Generale Susanna Pelagatti Ricevimento: Mercoledì ore presso Dipartimento di Informatica, Via Buonarroti,
La ricorsione Simulazione. Il Main /* Programma che usa una funzione ricorsiva*/ #include #define MAX_N 8 main() int valore, dato; printf(Introduci n:
Camil Demetrescu, Irene Finocchi, Giuseppe F. ItalianoAlgoritmi e strutture dati Copyright © The McGraw - Hill Companies, srl 1 Ordinamenti ottimi.
Process synchronization
Algoritmi e strutture Dati - Lezione 7
Capitolo 4 Ordinamento: Selection e Insertion Sort Algoritmi e Strutture Dati.
Capitolo 4 Ordinamento: Selection e Insertion Sort Algoritmi e Strutture Dati.
Capitolo 4 Ordinamento: Selection e Insertion Sort Algoritmi e Strutture Dati.
INTRODUZIONE ALLA PROGRAMMAZIONE STRUTTURATA
Algoritmi e Strutture Dati III. Algoritmi di Ordinamento
Algoritmi di ordinamento
APPUNTI SUL LINGUAGGIO C
ITERAZIONE e RICORSIONE (eseguire uno stesso calcolo ripetutamente) ITERAZIONE: ripetere piu volte una sequenza di operazioni istruzioni: for, while, do.
ITERAZIONE e RICORSIONE (eseguire uno stesso calcolo ripetutamente)
Esercizi su alberi binari
Esercizio: Copiare un file in un nuovo file mediante le funzioni read e write.
Strutture di controllo nel C
Politecnico di Milano Esercizi Preparazione alla prima prova intermedia.
Esercizi C su array e matrici
Le liste dinamiche La ricorsione
Calcolo del Massimo Comun Divisore
Radix-Sort(A,d) // A[i] = cd...c2c1
Massimo Comun Divisore
Programmazione di Calcolatori
La complessità media O(n log n) di Quick-Sort vale soltanto se tutte le permutazioni dell’array in ingresso sono ugualmente probabili. In molte applicazioni.
Università degli Studi di BresciaA.A. 2012/2013 Fondamenti di Programmazione Docente: Alessandro SaettiA.A. 2012/2013 Università degli Studi di Brescia.
Esercizi La distanza di hamming tra due interi x e y si definisce come il numero di posizioni nella rappresentazione binaria di x e y aventi bit differenti.
Ricerca sequenziale in un array di interi
Complessità di un algoritmo
Algoritmi e Strutture dati a.a. 2013/2014 Informazioni sul corso
Algoritmi e Strutture dati a.a. 2012/2013 Informazioni sul corso Dr Maria Federico.
ALGORITMI a.
Algoritmo che viene utilizzato per elencare gli elementi di un insieme secondo una sequenza stabilita da una relazione d'ordine, in modo che ogni elemento.
Un algoritmo è un procedimento che risolve un determinato problema attraverso un numero finito di passi. Un problema risolvibile mediante un algoritmo.
Algoritmi di Ordinamento
Algoritmi CHE COS’è UN ALGORITMO di ORDINAMENTO?
Definizione di un algoritmo
ALGORITMI Un algoritmo è un insieme di istruzioni: -ordinate -non ambigue -effettivamente computabili.
Array (ordinamento) CORDA – Informatica A. Ferrari.
Programmazione Avanzata Java e C 12/01/ Lezione 28: Algoritmi di ordinamento.
Gli Algoritmi L’algoritmo è un insieme ordinato di operazioni non ambigue ed effettivamente computabili che, quando eseguito, produce un risultato e si.
Complessità del problema Se non facciamo ipotesi sul tipo degli elementi della sequenza le uniche operazioni permesse sono confronti e assegnazioni. Problema.
Algoritmi e Strutture Dati Luciano Gualà
Ordinamento1 Algoritmi di ordinamento  Selection Sort  Quick Sort  Lower bound alla complessità degli algoritmi di ordinamento.
ALGORITMO Un algoritmo è un procedimento che risolve un determinato problema attraverso un numero finito di passi. Un formalismo che permette di rappresentare.
GLI ALGORITMI VISIBILE SUL BLOG INFORMATICA ANNO SCOLASTICO 2013 / 2014 GABRIELE SCARICA 2°T.
Informatica B Allievi Elettrici - AA Fondamenti della programmazione in linguaggio C (II) Istruzioni e strutture di controllo.
Definizione di algoritmo: Un algoritmo è un procedimento che risolve un determinato problema attraverso un numero finito di passi. Un problema risolvibile.
TECNICA DIVIDE ET IMPERA
Paola Disisto, Erika Griffini, Yris Noriega.  Insieme ordinato di operazioni non ambigue ed effettivamente computabili che, quando eseguito, produce.
Lo strano mondo degli algoritmi di ordinamento Algoritmi.
Operatori di incremento e decremento
1 Informatica Generale Marzia Buscemi Ricevimento: Giovedì ore , Dipartimento di Informatica, stanza 306-PS o per posta.
Problema dell’Ordinamento. Problema dell’ordinamento Formulazione del problema –Si vuole ordinare una lista di elementi secondo una data proprietà P Esempio:
GLI ALGORITMI DI ORDINAMENTO
L’ALGORITMO Un algoritmo è un procedimento formale che risolve un determinato problema attraverso un numero finito di passi. Un problema risolvibile mediante.
Algoritmi e Strutture Dati HeapSort. Select Sort: intuizioni L’algoritmo Select-Sort  scandisce tutti gli elementi dell’array a partire dall’ultimo elemento.
APPUNTI SUL LINGUAGGIO C
APPUNTI SUL LINGUAGGIO C Esercizi sugli array e strutture
Transcript della presentazione:

A LGORITMI DI ORDINAMENTO Cinzia Reverberi

COS’È UN ALGORITMO? Un algoritmo è un insieme ben ordinato di operazioni non ambigue ed effettivamente calcolabili che, eseguito, produce un risultato e termina in una quantità finita di tempo. In pratica, i punti principali di un algoritmo sono: -un insieme ben ordinato di operazioni -operazioni non ambigue e calcolabili -produce un risultato -termina in una quantità finita di tempo

A LGORITMO DI ORDINAMENTO E’ un algoritmo che viene utilizzato per elencare gli elementi di un insieme secondo una sequenza stabilita da una relazione d’ordine. Vi sono numerosi tipi di algoritmi di ordinamento: -quelli più semplici, iterativi: * insertion sort * selection sort * bubble sort -applicabili solo in casi particolari: * counting sort * radix sort * bin o bucket sort -più complessi, ricorsivi: * merge sort * quicksort * heapsort

I NSERTION SORT È un algoritmo relativamente semplice che si occupa di ordinare un array. Esso si occupa di ciò senza l’utilizzo di un array di appoggio (algoritmo in place). L’algoritmo tende a spostare gli elementi maggiori verso destra: utilizza due indici. Il primo punta al secondo elemento dell’array, mentre il secondo punta al primo. Se il primo elemento è maggiore del secondo i due elementi vengono scambiati e successivamente il primo indice avanza di una posizione mentre il secondo parte da quello precedentemente puntato dal primo.

#include #define MAX 100 /* * Legge in input il numero n ed n numeri interi * che memorizza nell'array. Restituisce il numero * di elementi letti (n). */ int leggi_array(int x[ ]) { int i, n; printf("Numero di elementi: "); scanf("%d", &n); printf("Inserisci %d elementi: ", n) ; for (i=0; i<n; i++) scanf("%d", &x[i]); return(n); } /* * Stampa in output l'array. * void stampa_array(int x[ ], int n) { int i; for (i=0; i<n; i++) printf("%d ", x[i]); printf("\n"); return; } /* * Funzione che implementa l'algoritmo Insertion sort. * Riceve come argomento l'array ed il numero di * elementi contenuti nell'array. Non restituisce alcun * valore, ma modifica il contenuto dell'array, ordinandolo. */ void insertion_sort (int x[ ], int n) { int i, j, app; for (i=1; i<n; i++) { app = x[i]; j = i-1; while (j>=0 && x[j]>app) { x[j+1] = x[j]; j--; } x[j+1] = app; } return; } /* * Funzione principale */ int main(void) { int v[MAX], n; n = leggi_array(v); stampa_array(v, n); insertion_sort(v, n); stampa_array(v, n); return(1); }

S ELECTION SORT Come l’algoritmo precedente, opera in place. I passi che compie l’algoritmo per ordinare l’array sono i seguenti: - si inizializza un puntatore i che va da 1 a n (dove n è la lunghezza dell'array). -Si cerca il più piccolo elemento dell'array -Scambia l'elemento più piccolo con l'elemento alla posizione i -Incrementa l'indice i e si torna al passo uno fino alla fine dell'array.

/* SELECTION SORT Ricerca il minimo nella parte di array non ancora ordinata e lo ordina. Poi prosegue con altre ricerche ripetute nella parte di array non ancora ordinata. */ void selection_sort(int a[], int n) { //funzione tipo void, effettua modifiche permanenti e non restituisce nulla. int min = a[0], i = 0, j, p = 0; //dichiariamo il minimo dell'array uguale alla sua prima componente. while (i < n) { //scansioniamo tutto l'array for (j = i; j < n; j++){ //scansiona tutto l'array partendo da una posizione in più poichè uscendo da qua 1 elemento sarà già ordinato. if (a[j] < min) { //se l'elemento attuale è minore del minimo allora l'elemento attuale sarà il nuovo minimo min = a[j]; p = j; //memorizziamo la posizione del minimo nell'array } } scambia (&a[i],&a[p]); //uscendo dal ciclo for scambiamo di posizione l'elemento iniziale della scansione con il minimo trovato. i++; //incrementiamo i per passare a scansionare il restante array non ancora ordinato. min = a[i]; //settiamo il minimo uguale all'elemento dopo. }

B UBBLE SORT È un semplice algoritmo di ordinamento. Può essere utilizzato per ordinare tutti i tipi di elementi su cui sia definita una relazione d’ordine. Il suo nome deriva dal fatto che durante il suo procedimento ci sono dati che si muovono nell’array velocemente e altri che lo fanno più lentamente. Ciò ricorda il movimento delle bollicine in un bicchiere di champagne.

/* BUBBLESORT - Ordinamento di un Array. */ void bubblesort (int a[], int n) { int i, j; // N.B. n-1 è l'ultima componente dell'array. for(i = 0; i < n - 1; i++) //scansiona tutto l'array tranne l'ultima componente: n - 1 escluso. Quindi fino al penultimo elemento. for (j = n - 1; j > i; j--) //j settato all'ultima componente e decresce ad ogni iterazione. Esce dal ciclo solo se j <= i if (a[j] < a[j-1]) //se la componente corrente è più piccola della precedente, li scambia. scambia(&a[j],&a[j-1]); } //la funzione scambia è così composta: void scambia(int *a, int *b) { //richiede due indirizzi di memoria in entrata che verranno memorizzati in 2 puntatori. int temp; //la variabile d'appoggio che memorizza temporaneamente il valore di a. temp = *a; *a = *b; *b = temp; } //NB. l'asterisco * dei puntatori fa riferimento sempre al valore a cui punta il puntatore.

C OUNTING SORT Algoritmo di ordinamento per valori numerici interi L'algoritmo è semplice ed intuitivo: si calcolano i valori max(A) e min (A) e si prepara un array C di dimensione pari all'intervallo dei valori con C[i] che rappresenta la frequenza dell'elemento i+min(A) nell'array di partenza A. Si visita l'array A aumentando l'elemento di C corrispondente. Dopo si visita l'array C in ordine e si scrivono su A, C[i] copie del valore i+min(A).

R ADIX SORT è un algoritmo di ordinamento per valori numerici interi, dove l è la lunghezza dell'array e m è la media del numero di cifre dei numeri. Esegue gli ordinamenti per posizione della cifra ma partendo dalla cifra meno significativa. Questo affinché l'algoritmo non si trovi a dovere operare ricorsivamente su sottoproblemi di dimensione non valutabili a priori.

B UCKET SORT è un algoritmo di ordinamento per valori numerici interi si prepara un array C di dimensione pari a m (cioè al valore massimo che può essere nell'array) con C[i] che rappresenta la frequenza dell'elemento i nell'array di partenza A. Si visita l'array A aumentando l'elemento di C corrispondente. Dopo si visita l'array C in ordine e si scrivono su A, C[i] copie del valore i.

#include void bucketSort(int array[], int n) { int i, j; int count[n]; for(i=0; i 0; (count[i])--) { array[j++] = i; } } } int main() { int array[] = {1,3,4,6,4,2,9,1,2,9}; int n = 10; int i; for (i = 0;i < n;i++) { printf("%d ", array[i]); } printf("\n"); bucketSort(array, n); for (i = 0;i < n;i++) { printf("%d ", array[i] ); } printf("\n"); return 0; }

M ERGE SORT consiste nella suddivisione del problema in sottoproblemi via via più piccoli. Il merge sort opera quindi dividendo l'insieme da ordinare in due metà e procedendo all'ordinamento delle medesime ricorsivamente. Quando si sono divise tutte le metà si procede alla loro fusione (merge appunto) costruendo un insieme ordinato

/* * Legge in input il numero n ed n numeri interi * che memorizza nell'array. Restituisce il numero * di elementi letti (n). */ int leggi_array(int V[]) { int n, i; printf("Numero di elementi: "); scanf("%d", &n); for (i=0; i<n; i++) scanf("%d", &V[i]); return(n); } /* * Stampa in output l'array. */ void stampa_array(int V[], int n) { int i; for (i=0; i<n; i++) { printf("%d ", V[i]); } return; }

/* * Funzione Merge per la fusione di due * componenti ordinate dell'array. */ void Merge(int A[], int p, int q, int r) { int i, j, k, B[MAX]; i = p; j = q+1; k = 0; while (i<=q && j<=r) { if (A[i]<A[j]) { B[k] = A[i]; i++; } else { B[k] = A[j]; j++; } k++; } while (i<=q) { B[k] = A[i]; i++; k++; } while (j<=r) { B[k] = A[j]; j++; k++; } f or (k=p; k<=r; k++) A[k] = B[k-p]; return ;

} /* * Funzione ricorsiva MergeSort. */ void MergeSort(int A[], int p, int r) { int q; f (p<r) { q = (p+r)/2; MergeSort(A, p, q); MergeSort(A, q+1, r); Merge(A, p, q, r); } return; } /* * Funzione principale */ int main(void) { int n, V[MAX]; n = leggi_array(V); MergeSort(V, 0, n-1); stampa_array(V, n); return(1); }

Q UICKSORT è un ottimo algoritmo di ordinamento ricorsivo in place a base del suo funzionamento è l'utilizzo ricorsivo della procedura partition: preso un elemento da una struttura dati (es. array) si pongono gli elementi minori a sinistra rispetto a questo e gli elementi maggiori a destra.

void scambia (tipobase v[], long i, long j) { tipobase tmp=v[i]; v[i]=v[j]; v[j]=tmp; } void QSort (tipobase v[], long inf, long sup) { tipobase pivot=v[(inf+sup)/2]; long i=inf,j=sup; while (i<=j) { while (v[i]<pivot) i++; while (v[j]>pivot) j--; if (i<j) scambia(v,i,j); if (i<=j) { i++; j--; } if (inf<j) QSort(v,inf,j); if (i<sup) QSort(v,i,sup); }

H EAPSORT basa la sua potenza sull’utilizzo di una struttura dati chiamata Heap, che gestisce intelligentemente le informazioni durante l’esecuzione dell’algoritmo di ordinamento.