Università di Roma Tor Vergata L16-1. Ricerca: esaminare una collezione di dati, cercando un particolare valore. nome e cognome

Transcript

1 Università di Roma Tor Vergata L16-1 Ricerca: esaminare una collezione di dati, cercando un particolare valore (per: ) reperire informazione modificarla stamparla cancellarla esempio: archivio studenti const int NUMSTUD = ; struct studente {int matricola, string nome}; studente archivio[numstud ]; numero matricola nome e cognome "Mario Rossi" "nna Bianchi" NUMSTUD NUMSTUD-1

2 Università di Roma Tor Vergata L16-2 problema di ricerca: data una matricola (valore), determinare l indice della posizione in cui si trova (se c è) 1a soluzione: ricerca lineare (o completa ) algoritmo: confronta 1 elem. con valore se uguali STOP, altrimenti confronta 2 elem. con valore se uguali STOP, altrimenti fino (al più) ad esaurimento elementi dichiarazione funzione: array in cui dimensione cercare array Ø Ø void RicLineare(studente [], int n, int valore, bool& trovato, int& indice); valore da vero se trovato indice elemento cercare falso altrimenti trovato,se presente

3 Università di Roma Tor Vergata L16-3 esempio di chiamata (stampa il nome dello studente con una certa matricola): int i, nummatricola; bool ok; ; cin >> nummatricola; ; RicLineare(archivio, NUMSTUD, nummatricola, ok, i); if (ok) cout << archivio[i].nome; else cout << "matricola inesistente"; definizione della funzione: void RicLineare(studente [], int n, int valore, bool& trovato, int& indice); {int cont; cont = 0; Æ inizializzazione trovato = false; while (cont<n &&!trovato) if ([cont].matricola!= valore) cont = cont+1; else trovato = true; indice = cont; Æ il valore di indice è significativo } solo se trovato

4 Università di Roma Tor Vergata L16-4 vantaggio ricerca lineare: applicabile a qualsiasi array (anche non ordinato) svantaggio: molto lenta se n è grande caso peggiore: n confronti caso migliore: 1 confronto caso medio: 1+2+º+n n = n+1 2 confronti fl mediamente il tempo di ricerca è proporzionale a n (O(n): dell ordine di n)

5 Università di Roma Tor Vergata L16-5 2a soluzione: ricerca binaria richiede che l array sia ordinato (rispetto al valore cercato) algoritmo: se (elemento di mezzo == valore cercato) allora STOP se (elemento di mezzo > valore cercato) allora prosegui ricerca nella prima metà dell array se (elemento di mezzo < valore cercato) allora prosegui ricerca nella seconda metà dell array esempio: ricerca del valore 60 (in un array ordinato!!) :

6 Università di Roma Tor Vergata L tentativo (si considera tutto l array) : 0 20 Æ primo == mezzo==(primo+ultimo)/2==(0+7)/2== (confronto fallito!) Æ ultimo ==7 2 tentativo (si considera la seconda metà, perchè [3]<60) : Æ primo ==mezzo+1==3+1== mezzo==(primo+ultimo)/2==(4+7)/2== (trovato!!) 7 80 Æ ultimo ==7 nota: solo 2 confronti (con la ricerca lineare ne sarebbero stati necessari 6)

7 Università di Roma Tor Vergata L16-7 in generale: num. medio confronti con ricerca lineare: O(n) num. medio confronti con ricerca binaria O(log n) T (tempo medio) ric. lineare ric. binaria n (dim. array) esempio: se un confronto richiede 1 msec n = (10 5 ): T(ric.lineare) ª 50 msec T(ric.binaria) ª 17 msec n = (10 7 ): T(ric.lineare) ª 5 sec T(ric.binaria) ª 27 msec definizione della funzione (i parametri hanno lo stesso significato della funzione Riclineare):

8 Università di Roma Tor Vergata L16-8 void RicBinaria(studente [], int n, int valore, bool& trovato, int& indice); {int primo, ultimo, mezzo; trovato = false; Æ inizializzazione primo = 0; ultimo = n-1; while (primo<=ultimo &&!trovato) {mezzo = (primo+ultimo)/2; if ([mezzo].matricola>valore) Æ si ricerca nellaprima metà ultimo = mezzo-1; else if ([mezzo].matricola <valore) Æ si ricerca nella seconda metà primo = mezzo+1; else trovato = true; } indice = mezzo; il valore di indice è significativo } solo se trovato questa è una versione non ricorsiva (nella dispensa, anche versione ricorsiva)

9 Università di Roma Tor Vergata L16-9 ordinamento: dato un array, come disporre i suoi elementi in ordine? (crescente o decrescente) fi n-1 = selection sort (o anche bubble sort): algoritmo: esegui n-1 passi ad ogni passo, prendi la parte non ordinata dell array, e sposta nella sua 1a posizione il più piccolo elemento di quella parte (scambiando con il valore corrente) ripeti, riducendo di una posizione la parte non ordinata

10 Università di Roma Tor Vergata L16-10 esempio (in grigio la parte non ordinata): passo 1: 0 32 primo fi 56 fi 3-16 più piccolo passo 2: primo fi 56 fi 32 più piccolo passo 3: primo fi 43 fi più piccolo 56

11 Università di Roma Tor Vergata L16-11 passo 4: fi primo più piccolo 115 in totale 4 = 5-1 passi ciclo di ordinamento: for (inizio=0; inizio<(n-1); inizio++) { determina l indice del più piccolo elemento in [inizio..n-1] Scambia([inizio], [piu_picc]); } determinazione indice del più piccolo elemento: piu_picc = inizio; for (i=inizio+1; i<n; i++) if ([i]<[piu_picc]) piu_picc = i; intestazione funzione: void SelectionSort(int [], int n) {int inizio, piu_picc, i; ciclo di ordinamento } numero di operazioni fatte da SelectionSort:

12 Università di Roma Tor Vergata L passo 2 passo (n-1) passo (n-1) + (n-2) ª n 2 Æ O(n 2 ) Ø Ø Ø numero confronti nel for interno (ricerca più piccolo) algoritmi di ricerca più efficienti (vedi libro di testo): O(n log(n) ) esempio: se un confronto richiede 1 msec per ordinare un array di n= elementi : T(SelectionSort) ª (10 5 ) 2 msec ª (10 4 ) sec ª 2.8 ore T(n log(n) ) ª 10 5 log(10 5 )msec ª (17 5 )msec ª 1.7 sec per ordinare un array di n= elementi : T(SelectionSort) ª (10 7 ) 2 msec ª (10 8 ) sec ª 3.17 anni T(n log(n) ) ª 10 7 log(10 7 )msec ª 270 sec ª 4.5 min