Array - Ateneonline

Fondamenti di informatica
Oggetti e Java
Luca Cabibbo
Array
Capitolo 19
febbraio 2004
1
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Il problema degli studenti da promuovere
Si consideri il seguente “problema degli studenti da promuovere”
 i venti studenti di un corso hanno svolto una prova di profitto,
e ciascuno studente ha ricevuto una votazione in decimi
 il docente del corso ha deciso di promuovere gli studenti la cui
votazione è non inferiore ai due terzi del voto medio ottenuto
dagli studenti alla prova d’esame
 si vuole scrivere un’applicazione che legge il nome e la
votazione di ciascuno dei venti studenti e stampa l’elenco dei
nomi degli studenti da promuovere, con le rispettive votazioni
2
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Il problema degli studenti da promuovere
Inserisci i nomi e le votazioni dei venti studenti
Studente 1: Rossi 8.1
Studente 2: Verdi 3.2
Studente 3: Bianchi 5.2
Studente 4: Gialli 5.6
...
Studente 20: Neri 8.5
La media delle votazioni è 7.65
La soglia per la promozione è 5.12
Gli studenti promossi sono:
Rossi 8.1
Bianchi 5.2
Gialli 5.6
...
Neri 8.5
3
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Una prima soluzione al problema degli studenti
/* nomi degli studenti */
String nome1, nome2, ..., nome20;
/* votazioni ricevute dagli studenti */
double voto1, voto2, ..., voto20;
double sommaVoti;
// somma dei voti
double soglia;
// soglia per la promozione
... stampa un messaggio ...
... segue ...
questi puntini non sono corretti
4
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Una prima soluzione al problema degli studenti
/* leggi nomi e votazioni dei venti
/* leggi il nome e la votazione del
nome1 = Lettore.in.leggiString();
voto1 = Lettore.in.leggiDouble();
/* leggi il nome e la votazione del
nome2 = Lettore.in.leggiString();
voto2 = Lettore.in.leggiDouble();
...
/* leggi il nome e la votazione del
nome20 = Lettore.in.leggiString();
voto20 = Lettore.in.leggiDouble();
studenti */
primo studente */
secondo studente */
ventesimo studente */
/* calcola la soglia per la promozione */
sommaVoti = voto1 + voto2 + ... + voto20;
soglia = (2./3.) * (sommaVoti/20);
... segue ...
5
questi puntini non sono corretti
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Una prima soluzione al problema degli studenti
/* stampa l'elenco degli studenti da promuovere */
... stampa un messaggio ...
/* verifica se il primo studente è stato promosso */
if (voto1 >= soglia)
System.out.println(nome1 + " " + voto1);
/* verifica se il secondo studente è stato promosso */
if (voto2 >= soglia)
System.out.println(nome2 + " " + voto2);
...
/* verifica se il ventesimo studente è stato promosso */
if (voto20 >= soglia)
System.out.println(nome20 + " " + voto20);
questi puntini non sono corretti
6
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Caratteristiche del problema degli studenti
Due caratteristiche fondamentali – comuni a molti problemi
 vanno gestiti degli insiemi di variabili omogenee
 per i nomi e per i voti degli studenti
 in ciascun insieme di variabili omogenee, per ciascun
elemento devono essere effettuate le stesse operazioni
 ciascuna votazione deve essere letta e poi acceduta due o
tre volte
 ciascun nome deve essere letto e poi eventualmente
acceduto
Gli array sono uno strumento per gestire informazioni con queste
caratteristiche
7
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Array
Un array è una collezione finita di variabili di uno stesso tipo
(elementi), posto in corrispondenza biunivoca con un altro
insieme finito (indici)
 in un array, ciascun elemento è individuato dal nome
dell’array insieme all’indice associato all’elemento
monthName
indici per
l’array
monthName
8
gennaio
January
febbraio
February
marzo
March
aprile
April
novembre
November
dicembre
December
Array
l’array monthName
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Array in Java
In Java, un array è una sequenza finita di variabili di uno stesso
tipo, posto in corrispondenza biunivoca con un intervallo iniziale e
finito dei numeri naturali
 il numero di elementi di un array è la lunghezza (o
dimensione) dell’array
 l’indice di ciascun elemento in un array è un numero naturale
 il primo elemento ha indice 0
 in un array lungo N, l’ultimo elemento ha indice N–1
In Java, un array è un oggetto, a cui è possibile accedere
mediante un suo riferimento e l’operatore [ ]
9
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Un esempio di array in Java
L’array monthName, composto da dodici elementi String
0
January
1
February
2
March
3
April
10
November
11
December
monthName

10
l’espressione monthName[0] permette di accedere al primo
elemento dell’array, la stringa "January"
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Uso di array
In Java gli array sono oggetti istanza, e la loro gestione presenta
alcuni aspetti simili a quelli della gestione degli altri oggetti istanza
 se si vuole usare un array bisogna
 dichiarare una variabile per memorizzare il riferimento
all’array
 creare l’array
 accedere agli elementi dell’array mediante l’operatore [ ]
11
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Dichiarazione di variabili array e tipi array
Per usare un array i cui elementi sono di un tipo T bisogna
dichiarare una variabile di tipo T[ ]
String[] nomi;
double[] voti;
// nomi degli studenti
// votazioni ricevute dagli studenti
Tipi array
 se T è un tipo, l’espressione T[ ] denota un tipo riferimento,
chiamato tipo array di elementi di tipo T (array di T)
 le variabili di tipo array (o variabili array) sono dunque
variabili riferimento
12
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Creazione di array
Per creare un array composto da N elementi di tipo T si deve
usare l’espressione new T[N]
/* crea l'array per i nomi degli studenti */
nomi = new String[20];
/* crea l'array per i voti degli studenti */
voti = new double[20];
13
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Accesso a un array
L’accesso a un elemento di un array avviene scrivendo
 il riferimento all’array
 una espressione intera, che specifica l’indice dell’elemento da
accedere, racchiusa tra parentesi quadre [ e ]
 l’indice deve essere un indice valido per l’array
 ArrayIndexOutOfBoundsException
/* leggi nomi e votazioni degli studenti */
for (i=0; i<20; i++) {
/* leggi nome e votazione dell'i-esimo studente */
nomi[i] = Lettore.in.leggiString();
voti[i] = Lettore.in.leggiDouble();
}
/* calcola la somma dei voti */
sommaVoti = 0;
for (i=0; i<20; i++)
sommaVoti += voti[i];
14
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Il problema degli studenti da promuovere
final int NUMERO_STUDENTI = 20; // numero degli studenti
String[] nomi;
// nomi degli studenti
double[] voti;
// votazioni ricevute dagli studenti
int i;
// indice per la scansione
// degli array nomi e voti
double sommaVoti;
// somma dei voti
double soglia;
// soglia per la promozione
... stampa un messaggio ...
/* creazione degli array per gli studenti */
/* crea l'array per i nomi degli studenti */
nomi = new String[NUMERO_STUDENTI];
/* crea l'array per i voti degli studenti */
voti = new double[NUMERO_STUDENTI];
... segue ...
15
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Il problema degli studenti da promuovere
/* leggi nomi e votazioni degli studenti */
for (i=0; i<NUMERO_STUDENTI; i++) {
/* leggi nome e votazione dell'i-esimo studente */
nomi[i] = Lettore.in.leggiString();
voti[i] = Lettore.in.leggiDouble();
}
/* calcola la soglia per la promozione */
sommaVoti = 0;
for (i=0; i<NUMERO_STUDENTI; i++)
sommaVoti += voti[i];
soglia = (2./3.) * (sommaVoti/NUMERO_STUDENTI);
/* stampa l'elenco degli studenti da promuovere */
... stampa un messaggio ...
for (i=0; i<NUMERO_STUDENTI; i++) {
/* verifica se l'i-esimo studente è stato promosso */
if (voti[i] >= soglia)
System.out.println(nomi[i] + " " + voti[i]);
}
16
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Lunghezza di un array
La lunghezza (dimensione) di un array è il numero di elementi
dell’array
 la lunghezza di un array viene fissata al momento della sua
creazione, e non può essere più cambiata
 è possibile accedere alla lunghezza di un array mediante la
variabile length e l’espressione riferimento-array . length
Esempio
 crea un array di interi e azzera i suoi elementi
int[] a;
// un array di interi
int i;
// indice per la scansione di a
/* creazione dell'array a */
a = new int[...];
// va indicata la dimensione di a
/* azzera gli elementi dell'array a */
for (i=0; i<a.length; i++)
a[i] = 0;
17
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Array e metodi
I parametri formali di metodi e costruttori possono essere di tipo
array
 si noti che l’esecuzione di un metodo (o costruttore) può
modificare, come effetto collaterale, gli elementi di un array
che gli è stato passato come parametro
Anche il tipo di ritorno di un metodo può essere un tipo array
18
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Letterali array
Un letterale array è la denotazione di un array di cui sono anche
specificati i valori iniziali per gli elementi
String[] animali;
animali = new String[] { "leone", "tigre", "orso" };

questo frammento di codice è equivalente a
String[] animali;
animali = new String[3];
animali[0] = "leone";
animali[1] = "tigre";
animali[2] = "orso";
19
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Array e accesso posizionale
Gli array vanno normalmente elaborati elemento per elemento
 normalmente gli elementi di un array vengono acceduti in
modo posizionale, mediante l’ausilio di una o più variabili
indice
20
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Somma degli elementi di un array
/* Calcola la somma degli elementi dell’array a. */
public static int somma(int[] a) {
// pre: a!=null
int i;
// indice per la scansione di a
int somma;
// somma degli elementi di a
/* scandisce e somma gli elementi di a */
somma = 0;
for (i=0; i<a.length; i++)
somma += a[i];
return somma;
}
21
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Test del metodo int somma(int[] a)
/* Test del metodo int somma(int[] a). */
public static void testSomma() {
/* la somma degli elementi di un array vuoto è 0 */
System.out.println(somma(new int[] {}) + " (0)")
/* la somma degli elementi di un array composto
* da un solo elemento è uguale al valore
* dell'elemento */
System.out.println(somma(new int[] { 5 }) + " (5)")
/* somma degli elementi di un array con più elementi */
System.out.println(somma(new int[] { 1,2,3 }) + " (6)")
}
22
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Visualizzazione degli elementi di un array
Normalmente non è possibile visualizzare gli elementi di un array
con una singola istruzione semplice
/* Visualizza sullo schermo gli elementi dell'array a. */
public static void visualizza(int[] a) {
// pre: a!=null
int i;
// indice per la scansione di a
/* visualizza gli elementi dell'array a,
* separandoli da spazi */
for (i=0; i<a.length; i++)
System.out.print(a[i] + " ");
/* poi va a capo */
System.out.println();
}
23
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Calcolo del massimo elemento di un array
Scrivere un metodo di classe int massimo(int[] a) che calcola e
restituisce il valore del massimo elemento di un array di interi non
vuoto a
/* massimo in posizione intermedia */
System.out.println(
massimo( new int[] { 0, 5, 12, 7 } ) + " (12)");
/* massimo in prima posizione */
System.out.println(
massimo(new int[] { 3, 1, 2 }) + " (3)");
24
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Calcolo del massimo elemento di un array di interi
/* Calcola il valore dell'elemento di
* valore massimo dell'array di interi a. */
public static int massimo(int[] a) {
// pre: a!=null && a.length>0 (ovvero, a non vuoto)
int massimo;
// il massimo di a
int i;
// indice per la scansione di a
/* il primo elemento di a viene scelto
* come massimo provvisorio */
massimo = a[0];
// OK, a non vuoto
/* scandisce a alla ricerca del massimo */
for (i=1; i<a.length; i++) {
/* massimo è il massimo tra gli
* elementi di indice 0, ..., i-1
*/
if (a[i] > massimo)
massimo = a[i];
/* massimo è il massimo tra gli
* elementi di indice 0, ..., i
*/
}
return massimo;
}
25
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Verifica se un array è crescente
Scrivere un metodo boolean crescente(int[] a) che verifica se a
è ordinato in modo crescente
/* Verifica se l'array di interi a
* è ordinato in modo crescente. */
public static boolean crescente(int[] a) {
// pre: a!=null
boolean crescente;
// a è crescente
int i;
// indice per la scansione di a
/* verifica se a è ordinato in modo crescente */
crescente = true;
for (i=0; crescente && i<a.length-1; i++)
if (a[i] >= a[i+1])
crescente = false;
return crescente;
}

26
notare l’uso della variabile indice i
 variabili indice ed espressioni indice
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Coppia di elementi uguali
Scrivere un metodo boolean coppiaUguali(int[] a) che verifica
se a contiene almeno una coppia di elementi uguali
/* Verifica se a contiene una coppia di elementi uguali. */
public static boolean coppiaUguali(int[] a) {
// pre: a!=null
boolean cu;
// a contiene una coppia
// di elementi uguali
int i, j;
// indici per la scansione di a
/* cerca una coppia di elementi uguali esaminando
* tutte le coppie di elementi distinti */
cu = false;
for (i=0; i<a.length; i++)
for (j=i+1; j<a.length; j++)
if (a[i]==a[j])
cu = true;
return cu;
}
27
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Array paralleli
Un insieme di array paralleli è un insieme formato da due o più
array della stessa lunghezza, in cui gli elementi che occupano
una stessa posizione formano un gruppo correlato di dati
 un esempio di array paralleli è dato dagli array nomi e voti
nel problema degli studenti da promuovere
nomi
28
voti
0
Rossi
0
8.1
1
Verdi
1
3.2
2
Bianchi
2
5.2
3
Gialli
3
5.6
19
Neri
19
8.5
Array
dati sullo studente
Bianchi
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Clonazione di array
La clonazione è una operazione che ha lo scopo di creare un
oggetto uguale a un altro oggetto
 un clone di un array A è un array che contiene lo stesso
numero di elementi di A e i cui elementi sono uguali a quelli di
A di indice corrispondente
/* Crea una copia dell'array a. */
public static double[] clona(double[] a) {
// pre: a!=null
double[] c;
// clone di a
int i;
// indice per la scansione di a e c
/* crea c, della stessa lunghezza di a */
c = new double[a.length];
/* copia gli elementi di a in c */
for (i=0; i<a.length; i++)
c[i] = a[i];
/* restituisce il clone */
return c;
}
29
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Uguaglianza tra array
/* Verifica se gli array a e b sono tra loro uguali. */
public static boolean uguali(int[] a, int[] b) {
// pre: a!=null && b!=null
int i;
// indice per la scansione di a e b
boolean uguali;
// a e b sono uguali
/* verifica se a e b sono uguali */
if (a.length!=b.length)
// sono sicuramente diversi
uguali = false;
else { // sono uguali se lo sono elemento per elemento
/* scandisce a e b alla ricerca di una differenza */
uguali = true;
for (i=0; uguali && i<a.length; i++)
if (a[i]!=b[i])
// sono diversi
uguali = false;
}
return uguali;
}
30
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Elementi positivi di un array di interi
Si vuole risolvere il seguente problema
 dato un array A di interi, si vuole creare e calcolare un nuovo
array che contiene tutti e soli gli elementi positivi di A, nello
stesso ordine in cui occorrono in A


31
ad esempio, se A è il seguente array
2
-3
0
7
11
0
1
2
3
4
allora bisogna creare e restituire il seguente array
2
7
11
0
1
2
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Elementi positivi di un array di interi
Il problema dei positivi può essere risolto come segue
 calcola il numero P di elementi positivi presenti nell’array A
 crea un array POS di interi di lunghezza P
 trascrivi nell’array POS gli elementi positivi di A, nello stesso
ordine in cui occorrono in A
32
2
-3
0
7
11
0
1
2
3
4
2
7
11
0
1
2
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Elementi positivi di un array di interi
/* Calcola un nuovo array che contiene tutti e soli gli
* elementi di valore positivo di a,
* disposti nello stesso ordine in cui occorrono in a. */
public static int[] positivi(int[] a) {
// pre: a!=null
int p;
// numero degli elementi positivi di a
int[] pos;
// l'array dei positivi di a
int i;
// indice per la scansione di a
int j;
// indice per la scansione di pos
/* calcola il numero di elementi positivi di a */
p = 0;
for (i=0; i<a.length; i++)
if (a[i]>0)
p++;
... segue ...
33
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Elementi positivi di un array di interi
... segue ...
/* crea l'array per i positivi */
pos = new int[p];
/* trascrivi in pos gli elementi positivi di a,
* nello stesso ordine in cui occorrono in a */
j = 0;
// j è l'indice in pos in cui va trascritto
// il prossimo elemento positivo di a
/* scandisce gli elementi di a,
* trascrivendo i positivi in pos */
for (i=0; i<a.length; i++)
if (a[i]>0) {
/* a[i] va trascritto in pos[j] */
pos[j] = a[i];
j++;
}
return pos;
}
34
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Array e oggetti
Gli elementi di un array possono essere dei riferimento a oggetti
vs
v0
nome = Rossi
voto = 8.1
0 1 2 3
v1
nome = Verdi
voto = 3.2
19
v2
nome = Bianchi
voto = 5.2
v3
nome = Gialli
voto = 5.6
…
v19
nome = Neri
voto = 8.5
oggetto dati per lo
studente Bianchi
35
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
La classe Valutazione
/* Un oggetto Valutazione rappresenta il nome
* di uno studente e la votazione che ha ricevuto. */
class Valutazione {
/* Il nome dello studente. */
private String nome;
/* La votazione ricevuta dallo studente. */
private double voto;
/* Crea una nuova Valutazione, dati nome e votazione. */
public Valutazione(String nome, double voto) {
this.nome = nome;
this.voto = voto;
}
/* Restituisce il nome dello studente. */
public String getNome() {
return nome;
}
/* Restituisce il voto ottenuto dallo studente. */
public double getVoto() {
return voto;
}
}
36
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Il problema degli studenti
final int NUMERO_STUDENTI = 20; // numero degli studenti
Valutazione[] vs;
// valutazioni degli studenti
String nome;
// nome di uno studente
double voto;
// votazione ottenuta da uno studente
int i;
// indice per la scansione di vs
double sommaVoti;
// somma dei voti
double soglia;
// soglia per la promozione
/* crea l'array per le valutazioni degli studenti */
vs = new Valutazione[NUMERO_STUDENTI];
/* leggi nomi e votazioni dei cinque studenti */
... stampa un messaggio ...
for (i=0; i<NUMERO_STUDENTI; i++) {
/* leggi nome e votazione dell'i-esimo studente */
nome = Lettore.in.leggiString();
voto = Lettore.in.leggiDouble();
/* crea la valutazione per l'i-esimo studente */
vs[i] = new Valutazione(nome,voto);
}
37
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Il problema degli studenti
/* calcola la soglia per la promozione */
sommaVoti = 0;
for (i=0; i<NUMERO_STUDENTI; i++)
sommaVoti += vs[i].getVoto();
soglia = (2./3.) * (sommaVoti/NUMERO_STUDENTI);
/* stampa l'elenco degli studenti da promuovere */
... stampa un messaggio ...
for (i=0; i<NUMERO_STUDENTI; i++) {
/* verifica se l'i-esimo studente è stato promosso */
if (vs[i].getVoto() >= soglia)
System.out.println(vs[i].getNome() + " " +
vs[i].getVoto());
}
38
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Parametro del metodo main
/* Applicazione che visualizza gli argomenti
* della linea di comando. */
class Echo {
public static void main(String[] args) {
int i;
// indice per la scansione di args
System.out.print("Argomenti: ");
for (i=0; i<args.length; i++)
System.out.print("(" + args[i] + ") ");
System.out.println();
}
}
39
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Ricerca sequenziale
Il problema della ricerca in un array
 dato un array a di elementi di tipo T e un valore chiave di tipo
T
 verificare se l’array a contiene un elemento uguale a chiave
 se a contiene almeno un elemento uguale a chiave, allora
deve essere calcolato e restituito l’indice di uno degli
elementi di a tra quelli uguali a chiave
 altrimenti, deve essere restituito il valore -1
40
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Il problema della ricerca in un array
Nell’esecuzione di una operazione di ricerca in un array sono
possibili diverse situazioni



41
5
4
12
9
0
2
16
2
0
a
1
2
3
4
5
6
7
se la chiave è uguale a 16
 va restituito l’indice 6
se la chiave è uguale a 6
 va restituito il valore -1
se la chiave è uguale a 2
 può essere restituito indifferentemente 5 o 7
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Ricerca sequenziale
/* Verifica se l’array a contiene un elemento uguale a
* chiave, e restituisce la posizione della prima
* occorrenza di chiave in a, oppure -1. */
public static int ricercaSequenziale(int[] a, int chiave) {
// pre: a!=null
int posizione;
// posizione di chiave in a
int i;
// indice per la scansione di a
/* scandisce gli elementi di a, alla ricerca della
* prima occorrenza di chiave in a */
posizione = -1;
for (i=0; posizione==-1 && i<a.length; i++)
if (a[i]==chiave)
posizione = i;
return posizione;
}
42
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Ricerca binaria
Consideriamo il problema della ricerca in un array ordinato
 in particolare, ordinato in modo non decrescente
43
0
1
3
4
7
9
12
16
22
34
0
1
2
3
4
5
6
7
8
9
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Spazio di ricerca
Gli algoritmi di ricerca sono normalmente basati su una strategia
di gestione degli elementi della collezione, relativa a una
partizione degli elementi della collezione in due insiemi
 un insieme è composto dagli elementi che sono sicuramente
diversi dalla chiave di ricerca
 l’altro insieme (chiamato spazio di ricerca) è composto dagli
elementi che potrebbero essere uguali alla chiave di ricerca
Lo spazio di ricerca varia in modo dinamico durante l’esecuzione
di un algoritmo di ricerca
44
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Ricerca binaria
L’algoritmo di ricerca binaria per la ricerca in un array ordinato
 inizialmente lo spazio di ricerca è composto da tutti gli
elementi dell’array
 finché non è stato trovato un elemento dell’array uguale alla
chiave e comunque lo spazio di ricerca è non vuoto
 confronta la chiave con l’elemento centrale dello spazio di
ricerca
 se la chiave è uguale all’elemento centrale dello spazio di
ricerca, allora la ricerca termina con esito positivo
 se invece la chiave è maggiore dell’elemento centrale dello
spazio di ricerca, rimuovi dallo spazio di ricerca l’elemento
centrale e tutti quelli alla sua sinistra
 se invece la chiave è minore dell’elemento centrale dello
spazio di ricerca, rimuovi dallo spazio di ricerca l’elemento
centrale e tutti quelli alla sua destra
45
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Ricerca binaria – successo
7
0
1
3
4
7
s=0
9
12
16
22
34
c=5
d=10
7
0
1
s=0
3
4
7
c=2
9
12
16
22
34
12
16
22
34
d=5
7
0
1
3
4
s=3
46
Array
7
9
c=4 d=5
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Ricerca binaria – fallimento
18
0
1
3
4
7
s=0
9
12
16
22
34
c=5
d=10
18
0
1
3
4
7
9
12
16
s=6
22
34
c=8
d=10
18
0
0
47
1
1
3
3
4
4
Array
7
7
9
9
12
16
22
s=6
c=7 d=8
12
16
22
34
34
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
s=d=8
Copyright © 2004 – The McGraw-Hill Companies srl
Metodo per la ricerca binaria
/* Ricerca chiave nell'array a ordinato in modo
* non descrescente, restituendo l'indice di un
* elemento di a uguale a chiave (oppure -1). */
public static int ricercaBinaria(int[] a, int chiave) {
// pre: a!=null && a è ordinato in modo non decrescente
int posizione;
// posizione di un elemento di a
// uguale a chiave, se esiste
int sinistra;
// indice del primo elemento dello
// spazio di ricerca
int destra;
// indice del primo elemento oltre
// lo spazio di ricerca
int centro;
// indice dell'elemento centrale dello
// spazio di ricerca
48
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Metodo per la ricerca binaria
/* inizialmente lo spazio di ricerca comprende
* tutti gli elementi di a */
sinistra = 0;
destra = a.length;
/* cerca l'indice di un elemento di a uguale
* a chiave, se esiste, mediante la ricerca binaria */
posizione = -1;
while (posizione==-1 && sinistra<destra) {
centro = (sinistra+destra)/2;
if (a[centro]==chiave)
// trovato
posizione = centro;
else if (a[centro]>chiave) // continua a sinistra
destra = centro;
else
// continua a destra
sinistra = centro+1;
}
return posizione;
}
49
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Fusione di sequenze ordinate
La fusione di due sequenze ordinate è una operazione che
 date due sequenze a e b ordinate in modo non decrescente
 costruisce una nuova sequenza s che contiene tutti gli
elementi di a e b ed è ordinata in modo non decrescente
a
5
12
26
34
s
b
6
8
5
6
8
12
21
26
34
21
Strategia per la fusione di sequenze ordinate
 seleziona gli elementi di s — uno alla volta, in sequenza
 il prossimo elemento di s viene scelto tra l’elemento più
piccolo di a e quello più piccolo di b tra quelli che non sono
ancora stati inseriti in s
50
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Indici nella fusione di array
ia=1
a
5
12
26
34
s
b
6
8
5
6
8
is=3
21
ib=2
Gestione di un inserimento
ia=2
a
5
12
26
12
34
s
b
6
8
5
6
8
12
is=4
21
ib=2
51
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Indici nella fusione di array
A un certo punto, tutti gli elementi di uno dei due array saranno
stati inseriti in s
ia=2
a
5
12
26
34
s
b
6
8
5
6
8
12
21
is=5
21
ib=3
52
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Implementazione della fusione
/* Fonde gli array a e b ordinati in modo
* non decrescente in un nuovo array ordinato. */
public static int[] fusione(int[] a, int[] b) {
// pre: a!=null && b!=null &&
//
a e b ordinati in modo non decrescente
int[] s;
// risultato della fusione di a e b
int ia, ib, is;
// indici per a, b e s
/* inizializzazioni */
s = new int[a.length+b.length];
ia = 0;
ib = 0;
is = 0;
53
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Implementazione della fusione
/* prima fase della fusione: inserisci da a e b */
while (ia<a.length && ib<b.length) {
/* inserisci in s
* il più piccolo tra a[ia] e b[ib] */
if (a[ia]<b[ib]) {
s[is] = a[ia];
ia++;
} else {
s[is] = b[ib];
ib++;
}
is++;
}
/* ora ia==a.length || ib==b.length */
54
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl
Implementazione della fusione
/* seconda fase della fusione: inserisci da a o b */
/* inserisci da a */
while (ia<a.length) {
s[is] = a[ia];
ia++;
is++;
}
/* inserisci da b */
while (ib<b.length) {
s[is] = b[ib];
ib++;
is++;
}
/* ora la fusione è stata completata */
return s;
}
55
Array
Luca Cabibbo – Fondamenti di informatica: Oggetti e Java
Copyright © 2004 – The McGraw-Hill Companies srl