La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

INFORMATICA Algoritmi fondamentali. © Piero Demichelis 2 Riordinamento di un vettore Il problema del riordinamento di un vettore è frequente e talvolta.

Presentazioni simili


Presentazione sul tema: "INFORMATICA Algoritmi fondamentali. © Piero Demichelis 2 Riordinamento di un vettore Il problema del riordinamento di un vettore è frequente e talvolta."— Transcript della presentazione:

1 INFORMATICA Algoritmi fondamentali

2 © Piero Demichelis 2 Riordinamento di un vettore Il problema del riordinamento di un vettore è frequente e talvolta condiziona addirittura le prestazioni di un programma. La prima idea che viene in mente è quella di ricostruire il vettore in un altro vettore inserendo i dati uno dopo laltro nellordine richiesto (ascendente o discendente). Generalmente però i vettori sono così grandi da non poter essere duplicati in memoria: il riordinamento dunque deve essere effettuato allinterno del vettore stesso senza ausilio di altre strutture dati.

3 © Piero Demichelis 3 Riordinamento di un vettore Il problema di trovare un algoritmo efficiente dipende dal fatto che il numero di confronti che devono essere eseguiti tra gli elementi del vettore può essere così grande da rendere il programma inefficiente. Una prima idea per risolvere il problema potrebbe essere quella di cercare il massimo (o il minimo) dellintero vettore, portarlo in prima posizione scambiandolo con lelemento che attualmente la occupa, poi ripetere loperazione considerando tutti gli elementi tranne il primo, e così via fino alla penultina posizione. Questo algoritmo è noto col nome di selection sort.

4 © Piero Demichelis 4 Riordinamento di un vettore: esempio Realizzare un programma che legge da tastiera una sequenza di 10 numeri interi e li salva in un vettore. Successivamente li riordina dal più piccolo al più grande senza uso di altre strutture dati, e infine li visualizza. Analisi: ­dopo aver letto i 10 valori da tastiera (mediante un semplice ciclo for) dobbiamo trovare un algoritmo che ci permetta di riorganizzare il nostro vettore scambiando di posizione i vari elementi in modo da riordinarli;

5 © Piero Demichelis 5 Riordinamento con selection sort Utilizziamo come algoritmo di riordinamento quello che abbiamo appena enunciato e noto col nome di selection sort. Pseudocodice: ­Sia n il numero di elementi del vettore vett; ­con un indice i che va da 0 a n-1: /* definisce il vettore dentro cui cercare il minimo (inizia da i e finisce a n) */ inizializza min col valore di vett[i]; inizializza ind = i; con un indice j che va da i+1 a n: /* cerca il minimo del vettore */ ­se vett[j] < min: /* se lelemento attuale è < del minimo */ ·min = vett[j]; /* lo salva come nuovo minimo */ ·ind = j; /* memorizza lindice in cui si trova */ scambia lelemento di indice i con lelemento di indice j.

6 © Piero Demichelis 6 Riordinamento con selection sort #include #define lmax 10 /* Funzione riordina: riordina un vettore di interi lungo n */ void riordina (int vett[ ], int n) /* prototipo della funzione */ main() { int vett [lmax], ind, i; clrscr();

7 © Piero Demichelis 7 Riordinamento con selection sort ind = 0; printf ("Introduci i valori\n"); while (ind < lmax) /* legge gli elementi del vettore */ { printf ("\nElemento di indice %d: ", ind); scanf ("%d", &vett[ind]); ind++; } riordina (vett, ind); /* riordina il vettore */ printf ("\n Vettore riordinato \n"); /* visualizza il vettore riordinato */ for (i = 0; i < ind; i++) printf ("%d\n", vett[i]); }

8 © Piero Demichelis 8 Riordinamento con selection sort void riordina (int vett[ ], int n) /* funzione di riordino */ { int min, ind, i, j; for (i = 0; i < n-1; i++) /* definisce il vettore in cui cercare il min. */ { min = vett[i]; /* inizializzazioni per ogni nuovo sottovettore */ ind = i; for (j = i + 1; j < n; j++) /* cerca il minimo del sottovettore */ if (vett[j] < min) { min = vett[j]; ind = j; } vett[ind] = vett[i]; /* scambia il primo elemento del sottovettore */ vett[i] = min; /* con lelemento minimo appena trovato */ }

9 © Piero Demichelis 9 Riordinamento con bubble sort Lalgoritmo di riordinamento più interessante è però quello noto col nome di bubble sort. Si può dimostrare che questo è lalgoritmo di riordinamento che mediamente usa il minor numero di confronti fra gli elementi del vettore. Pseudocodice: ­Sia n il numero di elementi del vettore vett; ­inizializza una variabile logica (inordine) a FALSO; ­finché non ho finito (ovvero inordine è FALSO): ipotizza che vett sia ordinato (inordine = VERO) con un indice i che va dal primo al penultimo elemento: ­confronto: se vett[i] > vett[i+1] : ·scambia i due elementi tra loro; ·assegna a inordine il valore FALSO (fatto uno scambio).

10 © Piero Demichelis 10 Riordinamento con bubble sort #include #define NELEM 10 #define FALSO 0 #define VERO 1 /* Funzione bubble: riordina un vettore di interi lungo n */ void bubble (int vett[ ], int n); /* prototipo */

11 © Piero Demichelis 11 Riordinamento con bubble sort main( ) { int vett [NELEM], ind; printf ("Introduci i valori\n"); for (ind = 0; ind < NELEM; ind++) { /* riempie il vettore con nelem numeri interi */ printf ("\nElemento di indice %d: ", ind); scanf ("%d", &vett[ind]); } bubble (vett, NELEM); /* riordina il vettore */ printf ("\n Vettore riordinato \n"); /* visualizza il vettore riordinato */ for (ind = 0; ind < NELEM; ind++) printf ("%d\n", vett[ind]); }

12 © Piero Demichelis 12 Riordinamento con bubble sort void bubble (int vett[ ], int n) { int provv, i, inordine; inordine = FALSO; /* inizializza inordine a FALSO */ while (!inordine) /* Finché il vettore non è ordinato */ { inordine = VERO; /* ipotizza che sia ordinato, cioè di aver finito */ for (i = 0; i < (n - 1); i++) /* i va dal primo al penultimo elem. */ if (vett[i] > vett[i+1]) /* se quello che segue è più grande */ { provv = vett[i]; /* scambia i due elementi tra loro */ vett[i] = vett[i+1]; vett[i+1] = provv; inordine = FALSO; /* è stato fatto uno scambio! */ }

13 © Piero Demichelis 13 Riordinamento alfabetico Realizzare un programma che legge da tastiera una sequenza di nomi (10), li riordina in ordine alfabetico mediante l'algoritmo di bubble-sort e infine li visualizza. Analisi: ­il problema è identico al precedente ma occorre considerare il fatto che i nomi sono delle stringhe; ­bisogna pertanto modificare la funzione bubble nella definizione, quando esegue il confronto fra i due elementi del vettore e quando scambia fra di loro gli elementi.

14 © Piero Demichelis 14 Riordinamento alfabetico #include #define NELEM 10 #define LUNGMAX 50 #define FALSO 0 #define VERO 1 /* Funzione bubble: riordina un vettore di stringhe lungo n */ void bubble (char vett[ ][LUNGMAX], int n) /* prototipo */

15 © Piero Demichelis 15 Riordinamento alfabetico main( ) { char parole [NELEM][LUNGMAX]; int ind; printf ("Introduci le parole\n"); for (ind = 0; ind < NELEM; ind++) { /* Riempie il vettore con NELEM parole */ printf ("\nParola di indice %d: ", ind); scanf ("%s", parole[ind]); } bubble (parole, NELEM); /* Riordina il vettore */ printf ("\n Vettore riordinato \n"); /* Visualizza il vettore riordinato */ for (ind = 0; ind < ind; ind++) printf ("%s\n", parole[ind]); }

16 © Piero Demichelis 16 Riordinamento alfabetico void bubble(char vett[ ][LUNGMAX], int n) { int i, inordine; char provv[LUNGMAX]; inordine = FALSO; /* inizializza inordine a FALSO */ while (!inordine) /* Finché il vettore non è ordinato */ { inordine = VERO; /* ipotizza che sia ordinato, cioè di aver finito */ for (i = 0; i < (n - 1); i++) /* i va dal primo al penultimo elem. */ if (strcmp (vett[i], vett[i+1]) > 0) /* se quello che segue è > */ { strcpy (provv, vett[i]); /* scambia i due elementi tra loro */ strcpy (vett[i], vett[i+1]); strcpy (vett[i+1], provv); inordine = FALSO; } /* è stato fatto uno scambio! */ }

17 © Piero Demichelis 17 Ricerca dicotomica La ricerca di un elemento in un vettore può essere molto laboriosa in termini di tempo di esecuzione. Se la base dati è molto grande è opportuno minimizzare questo tempo riducendo il numero di confronti tramite un semplice algoritmo detto di ricerca dicotomica. Il vettore deve essere dapprima riordinato, poi si confronta lelemento posto a metà vettore (indice = n/2) con lelemento cercato. Si hanno 3 possibilità: a) é quello cercato; b) lelemento cercato è più grande; c) lelemento cercato è più piccolo. Se lelemento cercato è più grande si considera un nuovo vettore formato dalla sola seconda metà dellintero vettore e si ricomincia la ricerca col confronto tra elemento cercato e elemento posto a metà del nuovo vettore; e così via.

18 © Piero Demichelis 18 Ricerca dicotomica #include #define MAX_DATI 100 typedef enum {FALSO, VERO} boolean; /* prototipo delle funzioni di ricerca e di riordinamento */ boolean trovato (int vett[ ], int elemento, int *p_posiz, int n_dati); void bubble (int vett[ ], int n); main() { int num_dati, dato, indice, p_posiz, cercato; int vett [MAX_DATI];

19 © Piero Demichelis 19 Ricerca dicotomica indice = 0; printf ("\nIntroduci il vettore, premi +z per finire\n"); while (((scanf ("%d",&dato)) != EOF) && (indice < MAX_DATI)) { /* legge numeri fino a EOF oppure a MAX_DATI */ vett [indice] = dato; indice++; } num_dati = indice; /* in num_dati numero di dati letti */ bubble (vett, num_dati); /* riordina il vettore di interi */ printf (\nVettore riordinato:); /* visualizza il vettore riordinato */ for (indice = 0; indice < num_dati; indice++) printf (\nElemento di indice %d = %d, indice, vett [indice]);

20 © Piero Demichelis 20 Ricerca dicotomica /* richiede il dato da cercare */ printf ("\nQuale dato vuoi cercare? "); scanf ("%d", &cercato); /* cerca il dato con la funzione trovato che restituisce col suo nome un valore logico (vero o falso) a seconda che il dato sia presente o meno nel vettore e, se presente, lindice del dato nella variabile p_posiz */ if ( trovato (vett, cercato, &p_posiz, num_dati) ) printf ("\nDato presente in posizione %d", p_posiz); else printf ("\nDato non presente"); }

21 © Piero Demichelis 21 Ricerca dicotomica boolean trovato (int vett[ ], int dato, int *p_posiz, int n_dati) { int meta, limite_inf, limite_sup; boolean presente; limite_inf = 0; /* indice inferiore della porzione di vettore */ limite_sup = n_dati - 1; /* indice superiore della porzione di vettore */ presente = FALSO; while ((!presente) && (limite_inf <= limite_sup)) { meta = (limite_sup + limite_inf) / 2; /* confronto il dato cercato con lelemento di metà del vettore */ if (vett[meta] == dato) presente = VERO; /* è lui, finito! */

22 © Piero Demichelis 22 Ricerca dicotomica else { /* non è lui, procedo usando il metodo di bisezione */ if (vett[meta] > dato) limite_sup = meta - 1; else limite_inf = meta + 1; } *p_posiz = meta; return (presente); }

23 © Piero Demichelis 23 Riordinamento con bubble sort void bubble (int vett[ ], int n) { int provv, i; boolean inordine = FALSO; /* inizializza inordine a FALSO */ while (!inordine) /* Finché il vettore non è ordinato */ { inordine = VERO; /* ipotizza che sia ordinato, cioè di aver finito */ for (i = 0; i < (n - 1); i++) /* i va dal primo al penultimo elem. */ if (vett[i] > vett[i+1]) /* se quello che segue è più grande */ { provv = vett[i]; /* scambia i due elementi tra loro */ vett[i] = vett[i+1]; vett[i+1] = provv; inordine = FALSO; /* è stato fatto uno scambio! */ }


Scaricare ppt "INFORMATICA Algoritmi fondamentali. © Piero Demichelis 2 Riordinamento di un vettore Il problema del riordinamento di un vettore è frequente e talvolta."

Presentazioni simili


Annunci Google