Algoritmi Fondamentali - Sistemi di Elaborazione delle Informazioni

Appunti di Informatica
Algoritmi Fondamentali
Algoritmi di Ricerca di un valore in un Array
Flow-chart
Ricerca Seriale
Codifica in linguaggio C
int ricerca_seriale(int vet[], int n, int k)
{
int trovato=-1;
int i=0;
while (i<n && trovato==-1)
{
If (vet[i]==k) trovato=i;
i=i+1;
}
return trovato;
}
Flow-chart
Commenti
L’algoritmo è posto sotto forma di
funzione, ed è in grado di effettuare la
ricerca di un valore k in un array di
qualsiasi dimensione, in quanto il numero
degli elementi dell’array n, viene passato
come parametro alla funzione.
L’algoritmo opera confrontando il valore
cercato k con tutti gli elementi presenti
nell’array vet, fino a quando trova in
posizione i un elemento uguale al valore k,
in questo caso si conserva la posizione i
nella variabile trovato. Nel caso in cui
nessun confronto vet[i]==k del ciclo
risultasse vero, allora il valore della
variabile trovato resterebbe uguale al
valore iniziale, cioè pari a -1.
La funzione restituisce al programma
principale il valore della variabile trovato,
il cui valore può essere -1 per indicare che
k non è presente nell’array, oppure un
valore compreso tra 0 e n-1 per indicare la
posizione di k nell’array.
Ricerca Seriale con sentinella
Codifica in linguaggio C
int ricerca_sentinella(int vet[], int n, int k)
{
int i=0;
vet[n]=k;
while (vet[i]!=k)
i=i+1;
return i;
}
Commenti
L’algoritmo di ricerca seriale con
sentinella è una variante di quello
precedente. In questo caso, inseriamo di
proposito il valore k nell’array in
posizione n, cioè dopo gli n elementi
contenuti nell’array vet (che si trovano
nelle posizioni da 0 a n-1). Così facendo,
cominciamo il ciclo di confronti che
terminerà quando vet[i] sarà uguale a k,
cosa che deve accadere per forza. Al
termine del ciclo restituiamo il valore di i
al programma principale, il quale capirà
che il valore k è presente nell’array in
posizione i se i ha un valore compreso
tra 0 e n-1, mentre k non sarà presente
nell’array se i vale proprio n.
Flow-chart
Ricerca Sequenziale
Codifica in linguaggio C
int ricerca_sequenziale(int vet[], int n, int k)
{
int trovato=-1;
int i=0;
int continua=1;
while (i<n && continua==1)
{
if (k<=vet[i])
continua=0;
else
i=i+1;
}
if (k==vet[i]) trovato=i;
return trovato;
}
Flow-chart
Ricerca Binaria (o Dicotomica)
Codifica in linguaggio C
int ricerca_binaria(int vet[], int n, int k)
{
int pos;
int trovato=-1;
int i=0, j=n-1;
while (i<=j && trovato==-1)
{
pos=(i+j)/2;
if (vet[pos]==k) trovato=pos;
else
{
if (vet[pos]>k) j=pos-1;
else i=pos+1;
}
}
return trovato;
}
Commenti
L’algoritmo di ricerca sequenziale è
fatto per funzionare su un array
contenente gli elementi ordinati in
ordine
crescente.
L’algoritmo
consiste in un ciclo iterativo che
continua finche il valore cercato k è
maggiore dell’elemento i-esimo
dell’array
vet[i],
appena
la
condizione risulta falsa (cioè
k<=vet[i]) , il ciclo termina e con un
semplice controllo if si capisce se
l’uscita dal ciclo è stata determinata
per k=vet[i], quindi elemento
trovato, oppure per k<vet[i] che
significa elemento non trovato.
L’uscita dal ciclo iterativo sulla base
della
condizione
k<vet[i]
ci
garantisce che k non sia presente
nell’array, in quanto gli elementi
posizionati dopo i, sono maggiori di
vet[i] e quindi è impossibile che più
avanti nell’array ci sia il valore k,
dato che l’array è ordinato in ordine
crescente.
Commenti
L’algoritmo di ricerca binaria è fatto
per trovare un valore all’interno di
un array ordinato in ordine
crescente. L’algoritmo si basa sul
meccanismo di andare a controllare
ogni volta l’elemento in posizione
centrale dell’array con il valore
cercato k, se k risulta maggiore
dell’elemento centrale, allora la
ricerca di k deve continuare nella
metà inferiore dell’array, se k risulta
minore dell’elemento centrale, allora
la ricerca deve continuare nella metà
superiore dell’array, se k dovesse
risultare
uguale
all’elemento
centrale, allora vuol dire che k è
stato trovato. L’algoritmo continua a
ricercare k, con lo stesso sistema
appena descritto, sulle metà
dell’array scelte in base al fatto che k
potrebbe trovarsi in quella metà
dell’array,
ovviamente
il
ragionamento è basato sul fatto che i
valori contenuti nell’array sono
ordinati in ordine crescente.