Sei sulla pagina 1di 2

Const righe=tot

const colonne = tot


var i,dim,val,z,j : integer;
vet ; array[1..max] of integer;
trovato : boolean
matrice : array[1..righe,1..colonne] of integer

RICERCA DICOTOMICA
#viene eseguita su uno o più array con elementi ordinati, e diversi
procedura ricerca( val vet[], val dim, val valore) #i parametri sono passati per valore. Il parametro
“valore” indica il valore cercato nell'array
“vet[]”. L'array vet[] deve entrare ordinato nella
procedura, quindi se usate questa procedura
prima dovete ordinarlo, in caso non lo sia.

INIZIO
i<--0
j<--dim #dim è la dimensione dell'array
trovato<--false
esegui mentre (trovato=false ) or (i<=j)
z<--(i+j)/2
se vet[z]=valore or vet[z]=vet[i] or vet[z]=vet[j] allora :
trovato<--true
i<--j
altrimenti se valore<vet[z] #controlla se il valore cercato è quello medio, in caso
j<--z-1 contrario controlla se è minore, e in tal caso la ricerca riguarda
altrimenti se valore>vet[z] i valori dall'inizio dell'array alla casella prima di quella a
i=z+1 metà(che ricordo essere z), in caso contrario (valore maggiore
fine se di quello centrale) la ricerca riguarda la parte di array che va dalla
fine mentre casella dopo a quella centrale fino alla fine, e cosi via finchè non trova
FINE quello giusto.

#vet[z] è l'elemento dell'array vet di posto Z ricercato.

CARICAMENTO MATRICE

procedura carica(ref matrice[i,j], val righe, val colonne)


INIZIO
i<--0
j<--0
per i=1 to righe:
per j=1 to colonne:
scrivi('inserire elemento',j,'riga',i)
leggi matrice[i,j]
fine per
fine per
FINE

ORDINAMENTO ARRAY
procedura ordina(ref vet val dim )
INIZIO
per i=1 to dim-1 #d è la dimensione dell'array
per j=i+1 to dim
se vet[i]>vet[j] allora :
scambia(vet[i],vet[j]) #ho messo direttamente la procedura, altrimenti veniva più lungo
fine se
fine per
fine per
FINE
Se si vuole ordinarlo in modo contrario( dal maggiore al minore quindi) a quello descritto dal
programma qui sopra, basta mettere < al posto di >.
RICERCA SEQUENZIALE :
questa è più facile della dicotomica : se avete un array con elementi che si ripetono al suo interno,
dovete usare questa, se invece l'array è ordinato e non ci sono elementi che si ripetono, usate la
dicotomica. Ad ogni modo, qui basta prendere l'array, con un ciclo bisogna iterare all'interno
dell'array, e imporre la condizione sulla quale si fa la ricerca. Esempio: ricerchiamo gli elementi di
un array che sono pari.

Procedura ricerca(val vettore[],ref pari[],dim)

INIZIO
i<--1
c<---1
per i=1 to dim
se vettore[i] mod 2 = 0 allora :
pari[c]<--vettore[i]
c<--c+1
fine se
fine per
FINE

Si utilizzano due contatori, i e c. Il contatore i viene utilizzato per iterare all'interno del vettore
“vettore[]”, mentre il c ri riferisce all'altro vettore, “pari[]”. Questo poiché se un elemento dell'array
“vettore[]” è dispari, allora quel posto non viene contato nell'array pari[]... es se vettore[1] è pari,
allora quel valore sarà spostato su pari. Se poi vettore[2] è dispari, usando lo stesso contatore, il
valore non viene copiato sull'array pari[], ma la casella di posto due di quest'ultimo rimane vuota, e
quindi avremmo dei buchi corrispondenti ai valori dispari. Esempio.
Vettore[1]=2
vettore[2]=5
vettore[3]=4

con lo stesso contatore, i : con 2 contatori diversi, i e c:


pari[1]=2 pari[1]=2
pari[2]=null pari[2]=4
pari[3]=4