ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO

3. ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO 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 sia minore (o maggiore) di quello che lo segue.

4. SELECTION SORT SELECTION SORT L'algoritmo seleziona di volta in volta il numero minore nella sequenza di partenza e lo sposta nella sequenza ordinata; di fatto la sequenza viene suddivisa in due parti: la sottosequenza ordinata, che occupa dell'array, e la sottosequenza da ordinare, che costituisce la parte restante dell'array. le prime posizioni

5. SELECTION SELECTIONSORT SORT void selsort(int x[ ], int y) { int z=0; for (z=0;z<n;z++) { int y=0; for (y=z+1;y<n;y++) {if (x[y] < x[y]) { int t=x[y]; x[y]=x[z]; x[z]=t; } } } Alla prima iterazione verrà selezionato l’elemento più piccolo dell’intero insieme e sarà scambiato con quello che occupa la prima posizione. Alla seconda iterazione è selezionato il secondo elemento più piccolo dell’insieme è viene scambiato con l’elemento che occupa la seconda posizione. Si ripete fino ad aver collocato nella posizione corretta tutti gli n elementi.

6. INSERTION SORT INSERTION SORT L'algoritmo solitamente ordina la sequenza sul posto. Si assume che la sequenza da ordinare sia partizionata in una sottosequenza già ordinata, all'inizio composta elemento, e una ancora da ordinare. da un solo

7. INSERTION INSERTIONSORT SORT Ad ogni iterazione, il vettore è costituito da una parte iniziale ordinata e da la parte rimanente che contiene i valori da ordinare. Per ogni valore ancora da inserire, viene fatta una ricerca binaria nella parte ordinata del vettore e vengono spostati in avanti tutti gli elementi per liberare una posizione Nella posizione liberata viene inserito il valore. void inssort(int a[ ] ,int n) { int i=0,j=0; for (i=1;i<n;i++) { int x=a[i], s=1, d=i-1; while (s<=d) { int m=(s+d)/2; if (x<a[m]) d=m-1; else s=m+1; } for (j=i-1,j>=s;j--) a[j+1]=a[j]; a[s]=x; } }

8. BUBBLE SORT BUBBLE SORT Il suo funzionamento è semplice: 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.

9. BUBBLE SORT BUBBLE SORT void bubbsort(int x[ ], int y) { bool scambio=true; int ultimo=y-1,i=0; while (scambio) { scambio=false; for (i=0;i<ultimo;i++) { if ( x[i]> x[i+1]) { int t= x[i]; x[i]=x[i+1]; x[i+1]=t; scambio=true; } } ultimo --; } } L’algoritmo BUBBLE SORT (ordinamento a bolle) so basa sull’idea di far emergere pian piano gli elementi più piccoli verso l’inizio dell’insieme da ordinare facendo sprofondare gli elementi maggiori verso il fondo: un po’ come le bollicine in un bicchiere di acqua gassata da qui il nome di ordinamento a bolle.

10. QUICK SORT QUICK SORT L'idea base può esprimersi agevolmente in termini ricorsivi. Ad ogni stadio si effettua un ordinamento parziale di una sequenza di oggetti da ordinare. Assunto perno dello stadio, si confrontano con esso gli altri elementi e si posizionano alla sua sinistra i minori e a destra i maggiori, senza tener conto del loro ordine. Dopo questo stadio si ha che il perno è nella sua posizione definitiva. un elemento come

11. QUICK SORT QUICK SORT void sort(int a[ ], int inizio, int fine) { int x, y, z; if (fine >inizio) { x = a [inizio]; y= inizio + 1; z= fine+1; while (y < z) { if (a [y] < x) y++; else { r--; swap(a[y], a[z]); } void swap(int & x, int & y) { int temp=x; x=y; y=temp; } Assunto un elemento come perno, si confrontano con esso gli altri elementi e si posizionano alla sua sinistra i minori e a destra i maggiori, senza tener conto del loro ordine. Dopo questo stadio si ha che il perno è nella sua posizione definitiva. Successivamente si procede in modo ricorsivo all'ordinamento parziale delle sottosequenze di elementi rimasti non ordinati, fino al loro esaurimento.

12. MERGE SORT MERGE SORT Le due sottosequenze ordinate vengono fuse. Per fare questo, si estrae ripetutamente il minimo delle due sottosequenze e lo si pone nella sequenza in uscita, che risulterà ordinata.

13. MERGE SORT MERGE SORT void mersort (int x[ ], int sinistra, int centro, int destra) int i = sinistra, j=centro+ 1,k=0; int y[ ]; while ((i <= centro) && (j <= destra)) { if (x[i] <= x[j]){ y[k]=a[i]; i=i + 1; } else { y[k] = x[j]; j=j + 1; } k=k + 1; } for (k =left ;k<right;k++) { a[k] = b[k - left];} void mergesort (int[] a, int left, int right) { int center; if (left < right) { center = (left + right) / 2; mergesort(a, left, center); mergesort(a, center+1, right); merge(a, left, center, right); }

14. HEAP SORT HEAP SORT In 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. uno mucchio decrescente (utilizzato per

15. HEAP SORT HEAP SORT void HeapSort(int a[ ], int n){ int i; int lh = n; Costruisci_Heap(a, n); for(i = n-1; i > 0; i--){ temp = a[i]; a[i] = a[0]; a[0] = temp; lh--; Rendi_Heap(a, n, lh, 0); } }

16. COUNTING SORT COUNTING SORT 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 immediatamente successivo. del valore

17. COUNTING SORT COUNTING SORT void counting_sort(int* A,int Alen,int* B,int k){ int i; int C[k]; for(i=0; i<k; i++) C[i] = 0; int j; for(j=0; j<Alen; j++) C[A[j]] = C[A[j]]+1; for(i=1; i<k; i++) C[i] = C[i]+C[i-1]; for (j=Alen-1; j>=0; j--){ B[C[A[j]]-1] = A[j]; C[A[j]] = C[A[j]]-1; } } Per ogni elemento x dell'insieme da ordinare si determinano quanti elementi sono minori di x, si usa questa informazione per assegnare ad x la sua posizione finale nel vettore ordinato. Se, ad esempio, vi sono 8 elementi minori di x, allora x andrà messo nella posizione 9 bisogna fare attenzione al caso in cui vi siano elementi coincidenti. In questo caso infatti non vogliamo assegnare a tutti la stessa posizione.

18. BUCKET SORT BUCKET SORT 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 immediatamente successivo. del valore

19. BUCKET SORT BUCKET SORT void bucketSort(int array[ ], int n) { int i, j; int count[n]; for(i=0; i < n; i++) { count[i] = 0; } for(i=0; i < n; i++) { (count[array[i]])++; } for(i=0,j=0; i < n; i++) { for(; count[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"); Il concetto che sta alla base dell’algoritmo è quello di dividere l’intervallo in n sottointervalli della stessa dimensione, detti bucket, nei quali vengono distribuiti gli n valori di input. A questo scopo lo pseudocodice che definisce l’algoritmo suppone che l’input sia un array A di n elementi e richiede un array ausiliario B[0...n−1] di liste concatenate (bucket). L’algoritmo procede semplicemente ordinando i valori in ogni bucket tramite un ordinamento di tipo insertion sort.