Ritorna alla home



LA RICERCA

Per trovare un elemento in un insieme vengono utilizzati gli algoritmi di ricerca. Questi algoritmi si dividono in due grandi categorie: ricerca a trasformazione di chiave e ricerca a confronto di chiave.




RICERCA A TRASFORMAZIONE DI CHIAVE

Questo tipo di ricerca utilizza una particolare funzione: la funzione HASH che trasforma la chiave in un indirizzo.
Esistono vari algoritmi HASH:





RICERCA A CONFRONTO DI CHIAVE

Questo tipo di ricerca si basa sul confronto della chiave k (elemento da trovare) con gli altri elementi dell'insieme.
Tra le varie ricerche a confronto di chiave abbiamo :


----Ritorna----

RICERCA LINEARE
Strategia risolutiva

L'algoritmo di ricerca lineare e' uno degli algoritmi di ricerca piu' semplici. Si confronta la chiave di ricerca k con ciascuna chiave dell'elenco. Se k risultera' uguale ad almeno una chiave presente nell'elenco la ricerca e' con successo (restituisce la prima poszione in cui e' stata trovata la chiave di ricerca). Se al termine di tutti i confronti la chiave di ricerca non e' stata trovata la ricerca e' senza successo (restituisce -1).

Flow-chart
Di seguito viene illustrato il flow chart della Ricerca Lineare :
Ritorna alla home

Complessita' computazionale
La complessita' computazionale dell'algoritmo di ricerca lineare e' la seguente :
  • Nel caso migliore, verra' effettuato un solo confronto (la chiave occupa la prima posizione);

  • Nel caso peggiore, verranno effettuati dimlog confronti (ricerca senza successo oppure chiave nell'ultima posizione);
  • Nel caso medio, il numero di confronti da effettuare è uguale al rapporto tra la somma di tutti i possibili confronti (1+2+3+...N) e il numero di elementi dell'insieme (N).
    Ricordando che la somma dei primi N numeri naturali e' data dalla formula N(1+N)/2 (il primo numero piu' l'ultimo per il numero degli elementi diviso due) si ha:
    (1+2+3+...N) = N(1+N)/2
    La media e': (1+2+3+...N)/N = N(1+N)/2N = (1+N)/2


Codifica in C++
Di seguito e' riportata la codifica in linguaggio C++ dell'algoritmo di ricerca lineare :

int RicercaLineare(int vetpar[10],int dimlogpar,int kpar)
{
int i=0,trovato=-1;
while(i<dimlogpar && trovato== -1)
{
if(vetpar[i]==kpar) trovato=i;
else i++;
}
return trovato;
}

----Ritorna----
RICERCA LINEARE IN UN INSIEME ORDINATO
Strategia risolutiva

L'algoritmo di ricerca lineare in un insieme ordinato e' una variante dell'algoritmo di ricerca lineare in un insieme non ordinato. Si confronta la chiave di ricerca k con ciascuna chiave dell'elenco. Se k risultera' uguale ad almeno una chiave presente nell'elenco la ricerca e' con successo (restituisce la prima poszione in cui e' stata trovata la chiave di ricerca). Nel mentre la chiave di ricerca k e' maggiore o uguale alla chiave presa in considerazione per il confronto e non sono stati effettuati tutti i confronti possibili, prosegui con la chiave successiva. Al termine del ciclo se la chiave di ricerca k e' uguale alla chiave presa in considerazione la ricerca e' con successo altrimenti e' senza successo.

Flow-chart
Di seguito viene illustrato il flow chart della ricerca lineare in un insieme ordinato :
Ritorna alla home

Complessita' computazionale
La complessita' computazionale dell'algoritmo della ricerca lineare in un insieme ordinato e' la seguente :
  • Nel caso migliore, verra' effettuato un solo confronto (la chiave occupa la prima posizione);

  • Nel caso peggiore, la chiave di ricerca k occupa l'ultima posizione;

  • Nel caso medio, verra' effettuato lo stesso numero di confronti dell'algoritmo di ricerca lineare in un insieme non ordinato.

Nota: l'algoritmo di ricerca lineare in un insieme ordinato è vantaggioso rispetto a quello di ricerca lineare in un insieme non ordinato nel caso in cui la ricerca è senza successo e il ciclo di confronti termina prima di giungere all'ultima posizione, perchè la chiave di ricerca k è minore della chiave presa in considerazione.

Codifica in C++
Di seguito e riportata la codifica in linguaggio C++ dell'algoritmo di ricerca lineare in un insieme ordinato :

int RicercaLineareOrdinato(int vetpar[10],int dimlogpar,int kpar)
{
int i=0,trovato=-1;
while(i<dimlogpar && kpar>=vetpar[i])
{
i++;
}
if(vetpar[i-1]==kpar) trovato=i;
return trovato;
}

----Ritorna----
RICERCA BINARIA
Strategia risolutiva

L'algoritmo di ricerca binaria opera su un insieme ordinato di elementi. Si confronta la chiave di ricerca k con la chiave che occupa la posizione centrale dell'insieme che chiameremo chiave centrale:

  • se la chiave di ricerca k e' uguale alla chiave centrale la ricerca e' con successo;
  • se la chiave di ricerca k e' minore della chiave centrale viene effettuato lo stesso procedimento sul sottoinsieme che contiene gli elementi minori di quello centrale;
  • se la chiave di ricerca k e' maggiore della chiave centrale viene effettuato lo stesso procedimento sull'altro sottoinsieme che contiene gli elementi maggiori di quello centrale.
L'algoritmo termina quando la posizione dell'ultimo elemento del sottoinsieme (sup) e' minore della posizione del primo elemento del sottoinsieme (inf).

Flow-chart
Di seguito viene illustrato il flow chart della Ricerca Binaria :
Ritorna alla home


Complessita' computazionale
L'algoritmo di ricerca binaria e' il piu' veloce tra quelli che si basano sul confronto di chiave.
La complessita' computazionale dell'algoritmo di ricerca binaria e' la seguente :
  • Nel caso migliore, verra' effettuato un solo confronto (chiave di ricerca k uguale alla prima chiave centrale);

  • Nel caso peggiore, (ricerca senza successo) per valutare il numero di confronti da effettuare si esprime la dimensione logica come potenza di 2 cioè dimlog = 2h-1; verranno, dunque, effettuati 'h' confronti;

  • Nel caso medio, verra' eseguito un numero di confronti minore di 'h'.

Codifica in C++
Di seguito e riportata la codifica in linguaggio C++ dell'algoritmo di ricerca binaria :

int RicercaBinaria(int vetpar[10],int dimlogpar,int kpar)
{
int inf=0,sup=dimlogpar-1,centro,trovato=0;
while(inf<=sup && trovato==0)
{
centro=int((inf+sup)/2);
if(vetpar[centro]==kpar)
trovato=1;
else
{
if(vetpar[centro]<kpar)
inf=centro+1;
else
sup=centro-1;
}
}
return(trovato);
}

----Ritorna----