algoritmi di ricerca e ordinamento - prof.accarino di ricerca e... · la metà tra 0 e 7 è 3,5:...

Appunti Di Informatica Prof. Accarino 1

Algoritmi di Ricerca

e Ordinamento

Prof. Francesco Accarino

IIS Altiero Spinelli Sesto San Giovanni


Algoritmi classici

2

In ambito informatico alcuni problemi si presentano con elevata frequenza in più ambiti e sono stati ampiamente studiati Ricerca di un elemento in un vettore

Ricerca del minimo e del massimo

Ordinamento

Gli algoritmi impiegabili in questi casi sono numerosi. I più noti, di seguito presentati, vengono spesso impiegati anche come termini di paragone per valutare le prestazioni di nuove soluzione proposte


Algoritmi di ricerca

Il problema della ricerca di un elemento in un

vettore si presenta frequentemente:

Occorre verificare se l’elemento appartiene al vettore

Ad un elemento (o alla sua posizione) sono associate

informazioni supplementari

Esistono due algoritmi “standard” per la

risoluzione di questo problema

3


Ricerca sequenziale

L’idea di fondo è semplice: Si scorre l’intero

vettore dalla prima posizione e si confronta ogni

elemento con quello ricercato

4

0


Ricerca sequenziale

5

0

1


Ricerca sequenziale

6

2

3


Ricerca sequenziale

L’algoritmo di ricerca sequenziale funziona senza

richiedere particolari ipotesi sull’ordinamento dei dati

Mediamente occorre scandire metà vettore per trovare

l’elemento cercato (se c’è) infatti è possibile trovare

l’elemento al primo tentativo o dopo N tentativi quindi in

media: N+1 (casi favorevoli 1, N fratto i casi possibili) 2

se non c’è, occorre fare tutti gli N tentativi

Si dice che il tempo di esecuzione cresce linearmente al

variare di N

7


Flowchart e Codifica in C

8

#include “stdio.h”

#include “conio.h”

#define NumMax 20

Void Main(){

Int vet[NumMax],i,N;

Printf(“inserisci il numero da cercare”);

Scanf(“%d”,&N);

Char Trovato=0;

i=0;

While(Trovato==0&&i<NumMax){

If(vet[i]==N

Trovato=1;

i++;

}

If(Trovato==1)

Printf(“trovato il numero %d”,N);

Else

Printf(“non trovato il numero %d”,N);

}


Ricerca binaria

Se il vettore è ordinato, allora è possibile utilizzare

approcci più efficienti rispetto alla ricerca sequenziale

La ricerca binaria prevede l’osservazione dell’elemento

al centro del vettore e dei due estremi.

Se uno di questi è l’elemento cercato termina, altrimenti

scarta tutta una metà del vettore a seconda che

l’elemento centrale sia maggiore o minore di quello

cercato

Il processo si ripete fino a trovare l’elemento cercato o a

scartarli tutti

9


Ricerca binaria

L’approccio è lo stesso adottato per cercare una parola

nel dizionario o un nome nella rubrica telefonica

Es. cerco il numero di Rossi Mario

Apro circa a metà, sulla lettera N

Vado avanti di diverse pagine

Arrivo alla lettera S

Torno indietro a Ra…

Vado avanti di poco, arrivando a Rov..

Ci sono quasi, torno indietro di una pagina

etc…

10


Ricerca binaria

Rispetto all’algoritmo sequenziale, la ricerca

binaria usa due ulteriori indici per individuare

gli estremi della porzione del vettore non

ancora esclusa

11

16


Ricerca binaria

L’indice iniziale è sempre a metà tra gli indici

degli estremi

L’elemento cercato (10) è minore di 18, per

cui si esclude la seconda metà del vettore

12

8 16


Ricerca binaria

La metà tra 0 e 7 è 3,5: poiché gli indici devono

essere interi, si sceglie tra 3 e 4

Questa volta l’elemento centrale è precedente a

quello cercato, per cui si prosegue nella ricerca

escludendo la metà di sinistra

13

3 7


Ricerca binaria

Come nel caso precedente, si tronca il valore

dell’indice all’intero inferiore

L’elemento cercato, viene quindi trovato. La risposta

fornita dall’algoritmo è 5, cioè la posizione

corrispondente al valore cercato

14

5 7


Ricerca binaria

L’algoritmo di ricerca binaria dimezza la

dimensione dello spazio di ricerca ad ogni passo

Il tempo necessario all’esecuzione dell’algoritmo

è dunque proporzionale al logaritmo di N

Visto che logN cresce più lentamente di N, la

ricerca binaria è più efficiente di quella

sequenziale (ma richiede l’ipotesi

supplementare di ordinamento dei dati)

Nel caso peggiore l’algoritmo termina quando la

dimensione dello spazio di ricerca diventa 1

15



16



#define NumMax 20

Void Main(){

Int vet[NumMax],i,N,Inizio,Fine,Medio;

Printf(“inserisci il numero da cercare”);

Scanf(“%d”,&N);

Char Trovato=0;

Inizio=0;

Do{

Medio=(Fine+Inizio)/2;

If(vet[Inizio]==N||Vet[Medio]==N||Vet[Fine]==N)

Trovato=1;

else

}

If(Vet[medio<=N)

Fine=Medio+1;

Else

Inizio=Medio-1;

}while(Inizio<=Fine&&Trovato==0);

If(Trovato==1)

Printf(“trovato il numero %d”,N);

Else

Printf(“non trovato il numero %d”,N);

}

}


Ricerca del minimo

Un secondo problema riguarda la ricerca del

valore minimo (o massimo) all’interno di un

vettore non ordinato

Naturalmente il problema è banale se il vettore è

ordinato!

Dato che i problemi di ricerca del minimo e di

ricerca del massimo sono del tutto analoghi, di

seguito si farà riferimento esclusivamente alla

ricerca del minimo

17


Ricerca del minimo

Per risolvere il problema vengono utilizzate

due variabili di supporto, contenenti:

il valore minimo trovato sinora

la posizione (indice) di tale valore

L’algoritmo scorre l’intero vettore e confronta

ciascun elemento col minimo contenuto nella

variabile di supporto

Se l’elemento nel vettore è inferiore a quello nella

variabile di appoggio, allora sostituisce la variabile

di supporto con l’elemento considerato

18


Ricerca del minimo

Si inizializzano le variabili di supporto con la

posizione e il valore del primo elemento

In questo modo il minimo temporaneo è non

inferiore al minimo del vettore

19

0

0


Ricerca del minimo

20

0

1

0

1


Ricerca del minimo

21

2

3

1

1


Ricerca del minimo

22

4

5

1

5


Ricerca del minimo

23

6

7

5

5


Ricerca del minimo

Al termine dell’algoritmo le variabili di

supporto contengono il valore e la posizione

del minimo

Se fossero presenti più minimi uguali sarebbe

possibile decidere quale tenere in considerazione

Data la lunghezza N del vettore, è necessario

effettuare N confronti

Il tempo necessario al completamento

dell’esecuzione è proporzionale alla dimensione

del vettore

24



25



#define NumMax 20

Void Main(){

Int vet[NumMax],i,min,pos;

min=vet[0];

pos=0;

for(i=0; i<NumMax;i++)

if(vet[NumMax<min){

min=vet[i];

pos=i;

}

printf(“il minimo è %d e si trova in posizione %d”, min, pos);

}


Ordinamento per sostituzioneI passi da seguire sono i seguenti :1) Posizionamento sul primo elemento dell’array2) Confronto dell’elemento con tutti gli elementi successivi e scambio ogni

volta che se ne trova un più piccolo3) Posizionamento sul secondo elemento dell’array4) Confronto dell’elemento con tutti gli elementi successivi e scambio ogni

volta che se ne trova un più piccolo5) Posizionamento sul terzo elemento dell’array6) Confronto dell’elemento con tutti gli elementi successivi e scambio ogni

volta che se ne trova un più piccolo7) Tale procedimento viene ripetuto N-1 volte

Osservazione : Per implementare l’Algoritmo abbiamo bisogno di 2 indici : Uno che tiene conto della posizione in cui si trova l’elemento considerato

( primo, secondo, terzo, … ) Uno che permette di scorrere la parte successiva dell’array per effetuare i

confronti e gli eventuali scambi

26


Ordinamento per sostituzione

27

7 5

5 2



5 4

4 3

8 7

57

5 4



8 7

7 5

8 7



Per implementare l’Algoritmo si devono usare 2 indici :

Uno (I) che tiene conto della posizione in cui si trova l’elemento da ordinare (primo, secondo, terzo, … )

Uno (J) che permette di scorrere l’array per effettuare il confronto ed eventualmente lo scambio

11 8

I

J



void Ordina(void){

Int I,J,C;

I=0;

while(I<Dim-1)

{

J=I+1;

while(J<Dim)

{

if(V[I]>V[J])

{

C=V[I];

V[I]=V[J];

V[J]=C;

}

J=J+1

}

I=I+1;

}

}


Bubble-sort (ordinamento a bolle)

L’ordinamento a bolle è un algoritmo semplice basato sul metodo degli

scambi.

Si fanno “salire” gli elementi più piccoli verso l’inizio del vettore

scambiandoli con quelli adiacenti.

Si procede confrontando gli elementi a coppie e ogni qualvolta si trova una

coppia non ordinata si scambiano di posto i due elementi.

Dato il vettore A[n], si opera confrontando A[1] con A[2] e se A[1] è maggiore

di A[2], si effettua uno scambio tra i due; vengono poi confrontati A[2] con

A[3], A[3] con A[4], …A[n-1] con A[n] scambiando di posto quegli elementi

che non formano coppie ordinate.


BubbleSort(A,n,scambio,temp)

i:=1

repeat

scambio:= 0

for j=i+1 to n do

if (A[j] < A[j-1]) then

temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

endif

endfor

until scambio=0

end

Esempio: Sia A il vettore da ordinare

A 1511 5 1 15 7 19

temp

5

5 11

j-1=1

j=3

11

j=2

7

Scambio=0

scambio:= 0scambio:= 0

temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

Scambio=1j-1=2

temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

1

5 111temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

111

j=4

j-1=3

j=5

j-1=4

temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

7

15157temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

1

51

j=2

j-1=1

j=4

j-1=3

117

7

Scambio=0

Vettore Ordinato!

1915temp:=A[j]

A[j]:=A[j-1]

A[j-1]:=temp

scambio:=1

La condizione

è falsa



void Ordina(void){

Int I, Temp;

Char scambio

Do{

I=0;

Scambio=0;

Do{

If(Vet[I]>Vet[I+1])

{

Temp=Vet[I];

Vet[I]=Vet[I+1];

Vet[I+1]=Vet[I];

scambio=1;

}

I=I+1;

}while(i<N-1);

N=N-1;

}while(scambio==1&&N>0);

}


Ordinamento per inserzione

Un esempio di ordinamento per inserzione si applica quando si gioca a carte.

Per ordinare le carte, in ordine crescente o decrescente, si estrae una carta, scalando quelle rimanenti, ed inserendo la carta estratta nel posto corretto.

Il procedimento si ripete finché tutte le carte sono nella sequenza corretta.

Il metodo di ordinamento ad inserzione trae lo spunto dall'idea che un vettore ordinato si ottiene inserendo le sue componenti una per una "al posto giusto".

Flow Chart e codifica in C


void Ordina(void){

Int I,J,P;

I=1

While(I<Dim)

{

P=Vet[i];

J=I-1;

while(J>0&&Vet[J]>P)

{

Vet[J+1]=Vet[J];

J=J-1;

}

Vet[J+1=P;

I=I+1

}

}

Ordinamento per Selezione


I passi da seguire sono i seguenti :1) Posizionamento sul primo elemento dell’array2) Ricerca dell’elemento più piccolo e scambio con il primo elemento

dell’array3) Posizionamento sul secondo elemento dell’array4) Ricerca dell’elemento più piccolo tra gli N-1 elementi rimasti e scambio con

il secondo elemento dell’array5) Posizionamento sul terzo elemento dell’array6) Ricerca dell’elemento più piccolo tra gli N-2 elementi rimasti e scambio con

il terzo elemento dell’array7) Tale procedimento viene ripetuto N-1 volte

Osservazione : Per implementare l’Algoritmo abbiamo bisogno di 2 indici : Uno che tiene conto della posizione in cui si trova l’elemento da ordinare

( primo, secondo, terzo, … ) Uno che permette di scorrere l’array alla ricerca del valore maggiore

Per implementare l’Algoritmo si devono usare

2 indici :

Uno (I) che tiene conto della posizione in cui si

trova l’elemento da ordinare (primo, secondo,

terzo, … )

Uno (J) che permette di scorrere l’array alla

ricerca del valore minore


I J

Flow Chart e Codifica in C


void Ordina(void){

Int I,J,Pmin,Min;

I=0

While(I<Dim-1)

{

Min=Vet[I];

Pmin=I;

J=I+1;

while(J<Dim)

{

if(Vet[j]<Min){

Min=Vet[J];

Pmin=J;

}

J=J+1;

}

if(Pmin>I){

Vet[Pmin]=Vet[I];

Vet[I]=Min;

}

I=I+1;

}

}

algoritmi di ricerca e ordinamento - prof.accarino di ricerca e... · la metà tra 0 e 7 è 3,5:...

Documents