Interfacce per il riutilizzo del codice

Transcript

1 Interfacce per il riutilizzo del Nelle SoluzioniLab3 c è una classe di nome Operasunumeri con la quale si esegue il calcolo della somma, del massimo e del numero di dati inseriti. public class Operasunumeri{ private double s; private double max; private int cont; /* costruttore: inizializza la somma a zero, il massimo con l'estremo inferiore, il contatore dei numeri a zero */ public Operasunumeri(){ s = 0; max = - Double.MAX_VALUE; cont = 0; //fine costruttore /* metodo aggiungi : aggiunge un valore alla volta aggiornando il valore della somma, del massimo e del contatore dei valori inseriti */ public void aggiungi(double x){ s = s + x; if(max < x) max = x; cont++; //fine aggiungi /* metodo somma : restituisce la somma dei valori inseriti */ public double somma(){ return s; /* metodo massimo : restituisce il massimo dei valori inseriti */ public double massimo(){ return max; /**metodo quanti : restituisce il numero di valori inseriti */ public int quanti(){ return cont; //fine classe Operasunumeri Consideriamo la classe BankAccount e supponiamo di avere un certo numero di conti bancari (una banca) e di voler calcolare quanti soldi ci sono in totale nella banca (somma). 1

2 Supponiamo anche di voler sapere quanti sono i conti gestiti dalla banca (contatore) e quale è il conto bancario che ha il saldo maggiore (massimo). Avendo a disposizione la classe Operasunumeri, possiamo riscriverla adattandola agli oggetti di tipo BankAccount. Dovremo fare qualche modifica. public class OperasuBankAccount{ private double s; private BankAccount max; private int cont; //usiamo il costruttore di default: //numeri = 0, riferimenti = null /* Il massimo che cerchiamo è il conto corrente che possiede il saldo maggiore */ public void aggiungi (BankAccount x){ s = s + x.getbalance(); if(cont==0 max.getbalance()< x.getbalance()) max = x; //quando cont = 0 si inizializza max //con il primo conto cont++; public BankAccount massimo(){ return max;... // altri metodi: quanti, somma... //fine OperasuBankAccount In maniera analoga potremo dover risolvere un altro problema in cui si vuole trovare quale oggetto, in un elenco di oggetti, ha il valore massimo in uno dei suoi dati. Esempio. Dati dei numeri complessi trovare quello il cui modulo è maggiore; dato un borsellino contenente delle monete vogliamo sapere quale è la somma totale e quale è la moneta con il valore più elevato. Dovremo scrivere una classe OperasuMonete? Vediamo di risolvere il problema in altro modo. Dato un insieme di oggetti possiamo stabilire cosa si intende per misura di quell oggetto; vogliamo poi risolvere il problema di trovare l oggetto che ha la misura più grande. Esempio. Dato un insieme di Pile vogliamo trovare la Pila che contiene più elementi. Abbiamo bisogno di definire una proprietà astratta: essere misurabile. 2

3 Abbiamo visto che in Java per definire una proprietà astratta si usa una interfaccia nella quale si dichiarano le firme dei metodi che rappresentano la proprietà. Le classi che realizzano l interfaccia dovranno costruire il per tutti i metodi dell interfaccia. Definiamo pertanto l interfaccia Misurabile per definire la proprietà di: avere una misura public interface Misurabile{ //metodo che rappresenta una misura double estraimisura(); //Object altridati(); Possiamo aggiungere un metodo altridati per poter rappresentare altre informazioni sugli oggetti misurabili: ad esempio il nome del correntista il cui conto bancario è il massimo. Vogliamo non aver più bisogno di scrivere la classe OperasuBankAccount e classi analoghe per risolvere problemi analoghi. Per prima cosa dovremo dichiarare che BankAccount realizza l interfaccia Misurabile e stabilire cosa intendiamo per misura di un conto bancario. Stabiliamo che la misura in BA è il valore del suo saldo. public class BankAccount implements Misurabile{... public double estraimisura(){ return balance; public Object altridati(){ return nome; //fine BankAccount Però dobbiamo ancora fare della modifiche sulla classe che esegue la somma e trova il massimo, in modo da poterla riutilizzare nella soluzione di problemi analoghi. La classe OperasuBankAccount eseguiva le operazioni per il calcolo della somma, del numero di elementi inseriti e trovava l elemento max: il conto bancario con il saldo maggiore. Un altra classe avrebbe trovato come max la moneta con il valore più grande, oppure la Pila con il maggior numero di elementi. Pensiamo allora di costruire una classe per gestire questi oggetti misurabili. Costruiamo una classe OperasuOggetti per oggetti le cui classi realizzano l interfaccia Misurabile: 3

4 public class OperasuOggetti{ private double s; private Misurabile max; private int cont;...//costruttore public void aggiungi(misurabile x){ s = s + x.estraimisura(); if(cont==0 max.estraimisura()< x.estraimisura()) max = x; cont++; //fine aggiungi public Misurabile massimo(){ return max;...//metodi quanti, somma //fine OperasuOggetti Questa classe potrà essere utilizzata dagli oggetti la cui classe che realizza Misurabile. Questo è un esempio di polimorfismo. Il metodo estraimisura è polimorfo. Con l invocazione del metodo x.estraimisura() otteniamo diversi comportamenti. La classe BankAccount realizza estraimisura restituendo il saldo; un altra classe realizerà estraimisura restituendo un valore double con il significato di misura in quella classe. In realtà x non ha un suo tipo di dato: x è di tipo interfaccia. Sarà l interprete Java che, durante l esecuzione, vede quale riferimento è memorizzato in x ed attiva il metodo della classe corrispondente. Con l interfaccia Misurabile abbiamo trasferito agli oggetti una caratteristica dei numeri: avere un valore; con i numeri possiamo eseguire somme, trovare un massimo, rappresentare una misura. Possiamo anche ordinare oggetti? Prima di tutto ci dobbiamo chiedere se ha senso confrontare oggetti. Lo abbiamo appena fatto cercando il massimo, quindi i confronti possono avere significato. Esempio. Vogliamo mettere in ordine i conti bancari in modo che seguano un ordine dal saldo minimo al saldo massimo (crescente). Volgiamo mettere in fila dei numeri complessi in modo che siano secondo l ordine crescente del loro modulo (reale). Cosa significa per oggetti il dire: l oggetto1 è minore (maggiore o uguale) dell oggetto2? Abbiamo già visto con le stringhe che non possiamo confrontare i riferimenti. Dobbiamo pensare ad una proprietà: essere confrontabile. Esempio. Per la classe Complex può essere il modulo: è un valore reale, esiste un ordine. 4

5 Nella classe BankAccount potrebbe essere il saldo, un numero reale, e pensare un ordine dal più povero al più ricco; oppure potrebbe essere il numero di conto, numero intero: dal cliente che per primo ha aperto un conto all ultimo che lo ha attivato. Per la classe Studente potrebbe essere la matricola, numero intero, oppure il nome, è una stringa e sappiamo che le stringhe hanno un ordine. Nel pacchetto java.lang c è un interfaccia che rappresenta la proprietà astratta essere confrontabile : l interfaccia Comparable (Par. 13.8). public interface Comparable{ int compareto(object other); Il metodo compareto restituisce un valore intero; la classe String realizza Comparable: s1.compareto(s2) con s1, s2 di tipo String. Interfaccia Comparable Siano a e b due oggetti di una classe che realizza Comparable, si ha: < 0 a precede b a.compareto(b) = 0 a è uguale a b > 0 a segue b Cosa significano i termini precede, segue, uguale, dipende dalle scelte che facciamo. Esempio. Consideriamo la classe Studente i campi nome e matricola; stabiliamo un confronto in base alla matricola. Interfaccia Comparable public int compareto(object altrostud) {Studente altro = (Studente)altrostud; int valore; if(this.matricola < altro.matricola) valore = -1; else if(matricola > altro.matricola) valore = 1; else valore = 0; return valore; Interfaccia Comparable Abbiamo dovuto fare il cast Studente altro = (Studente)altrostud; perché altrostud non possiede il campo matricola, dato che è Object. Possiamo fare altro.matricola perché siamo nella classe Studente. Vediamo la classe BankAccount che implementa due interfacce. Interfaccia Comparable public class BankAccount implements Misurabile, Comparable{... //estraimisura, altridati public int compareto(object other){ BankAccount ab = (BankAccount)other; if(this.balance < ab.balance) return -1; if(this.balance > ab.balance) return 1; return 0; //non strutturato, ma possibile 5

6 Interfaccia Comparable Possiamo anche confrontare stringhe, ad esempio ordinare gli studenti per nome (purché diversi): public int compareto(object altrostud) { Studente altro = (Studente)altrostud; return nome.compareto(altro.nome); dove nome è this.nome e compareto è quello delle stringhe. Interfaccia Comparable Ora che sappiamo cosa significa confrontare oggetti, possiamo metterli in ordine: public static void ordlineare ( BankAccount a[]){ BankAccount sc; //ciclo su i //ciclo su k if(a[i].compareto(a[k]) > 0) //scambio Interfaccia Comparable Se dobbiamo ordinare elementi di tipo Complex o Studente dobbiamo riscrivere l ordinamento. Possiamo fare meglio? All ordinamento basta avere degli oggetti che siano confrontabili, la cui classe realizzi Comparable. In maniera analoga a quanto fatto con Misurabile, andiamo a definire una variabile di tipo Comparable e scriviamo un ordinamento per oggetti qualunque. Interfaccia Comparable public static void ordlineare( Comparable a[]){ //ordinamento per oggetti confrontabili Comparable sc; for(int i=0; i<a.length-1; i++) for(int k=i+1; k<a.length; k++) if(a[i].compareto(a[k])> 0){ sc = a[i]; a[i] = a[k]; a[k] = sc; //fine if Sovrascrivere il metodo equals Sovrascrivere il metodo equals Consideriamo un array di numeri, ci interessa sapere se ci sono oppure no degli elementi ripetuti nella sequenza; esempio a = (1, 3, 2, 7, 3, 4) il 3 è ripetuto a = (1, 2, 4, 7, -5, 0) sono tutti diversi avremo un algoritmo del tipo: algoritmo boolean distinti (array a) def. variabili diverso logico i, k intero 6

7 Sovrascrivere il metodo equals diverso vero i 0 mentre i < a.length -1 e diverso eseguire per k = i+1 fino a a.length-1 eseguire se a[i] == a[k] allora diverso falso //fineif //fineper i i+1 //finementre restituire diverso // fine algoritmo Sovrascrivere il metodo equals Possiamo fare una cosa simile con gli oggetti? La superclasse Object possiede un metodo per verificare se due oggetti sono uguali: public boolean equals(object ob){ return (this == ob); Il confronto this==ob restituisce vero o falso. Il confronto precedente è fatto tra riferimenti, quindi per gestire oggetti uguali andiamo a sovrascrivere il metodo equals: lo abbiamo visto con la classe String. Sovrascrivere il metodo equals public class BankAccount{... //saldo, numeroconto, nome public boolean equals(object ob){ BankAccount ab = (BankAccount)ob; if(this.balance == ob.balance) return true; else return false; //fine equals //fine BA Sovrascrivere il metodo equals In BA potevamo scegliere di usare compareto invece di equals: a.compareto(b) == 0 corrisponde a a.equals(b) vero non per tutti gli oggetti può aver senso cercare l ordine, mentre l uguaglianza è una caratteristica degli oggetti. Esercizio. Costruire un metodo per verificare se in un array di oggetti ci sono elementi ripetuti. Lista concatenata Struttura di dati lista concatenata Consideriamo una nuova modalità di memorizzare i dati in cui l accesso non avviene più tramite un indice, che individua la posizione del dato nella struttura, ma tramite un indirizzo di memoria. Per poter costruire una sequenza di informazioni è necessario che ogni dato della struttura memorizzi l indirizzo di memoria dell elemento successivo. Si costruisce pertanto una struttura di dati collegata, chiamata lista concatenata o catena. 7

8 Lista concatenata Ogni nodo (anello) di una lista concatenata oltre all informazione memorizza il riferimento dell elemento successivo: avremo bisogno di un nodo con le caratteristiche del record per poter rappresentare due (o più) campi di tipo diverso: dato: info riferimento: next Lista concatenata Il nodo sarà composto da : l informazione: un elemento di tipo base o un oggetto, tutto ciò che possiamo memorizzare in un array; il riferimento sarà un riferimento ad un nodo: un riferimento ad un elemento dello stesso tipo del nodo. Si intuisce che le definizione del nodo sarà un po particolare: dobbiamo definire il tipo del nodo, ma al suo interno dobbiamo usare quel tipo (il nodo ha un campo riferimento). Lista concatenata Le informazioni memorizzate non sono più necessariamente contigue in memoria, come nell array. Lista concatenata Supponiamo di voler costruire una struttura di dati lista concatenata per rappresentare una sequenza di interi. Sintassi per definire il nodo: class ElemIntero{ int info; //dato ElemIntero next; //riferimento Lista concatenata Come possiamo gestire l accesso per la classe ElemIntero? 1) classe public, elementi private: si devono costruire i metodi per accesso e modifica dei campi; 2) controllo di pacchetto (nessuna specifica) sia per la classe che per i campi: l accesso ai campi è tramite il nome; 3) classe interna privata e nessuna specifica sui campi; adottiamo questa scelta. Lista concatenata public class TDAListaConc{... //metodi per gestire il TDA... private class ElemIntero{ int info; ElemIntero next; //fine classe ElemIntero 8

9 Lista concatenata Quale vantaggio e quale sicurezza comporta questa scelta? Essendo privata la classe non è visibile dall esterno: quindi si rispettano per i suoi campi le direttive dell incapsulamento. Essendo interna e non specificando l accesso i suoi campi sono visibili internamente alla classe che realizza il TDA e si possono utilizzare senza dover scrivere, in ElemIntero, i metodi di accesso e di modifica. Confronto tra array e lista concatenata Confronto tra array e lista concatenata Prima di vedere i metodi per costruire una Pila con una lista concatenata, mettiamo a confronto le due strutture di dati: accesso elemento successivo inserimento e cancellazione dimensione spazio di memoria Accesso: lista concatenata L accesso è sequenziale: per accedere ad un dato si deve scorrere la lista facendo una scansione lineare. Di fatto si esegue una ricerca nella struttura esaminando i nodi fino a trovare il valore cercato. Non si può ritornare indietro: si può solo vedere in avanti. Sia a di tipo ElemIntero, cerchiamo se a.info è uguale ad un valore x, iniziando dal primo elemento della struttura fino all ultimo elemento della struttura. Accesso: lista concatenata L accesso è: a.info Accesso: array L accesso è diretto: per accedere ad un dato si utilizza l indice dell array inizio La struttura è accessibile da un riferimento inizio che vede il primo nodo. Si può anche gestire la struttura con un primo elemento privo di informazione: nodo vuoto. x x Se v è il nome dell array, v[i] rappresenta l accesso all i-esimo elemento: nel nostro esempio x coincide con v[3]. Con l accesso diretto non c è un ordine da rispettare: v[3], v[0], v[5], : si può tornare indietro. 9

10 Successivo: lista concatenata Ogni nodo, tranne l ultimo, contiene nel campo next la referenza (indirizzo di memoria) al nodo successivo. Se a è di tipo ElemIntero e a vede un nodo della lista, per passare al nodo successivo si memorizza in a il riferimento al nodo successivo: a = a.next; //riferimento a.next Successivo: array Dato un elemento nella posizione i, v[i], il successivo (se i v.length-1) si trova nella posizione i+1; per passare al successivo si fa i+1, quindi v[++i] oppure i = i+1; uso v[i] a Inserimento e cancellazione: lista concatenata Per inserire un nuovo nodo bisogna: 1) costruire il nuovo nodo 2) agganciarlo nella posizione voluta con assegnazioni sui riferimenti 1) costruzione del nuovo nodo: ElemIntero nuovo = new ElemIntero(); nuovo.info = x; 2) per poterlo agganciare bisogna sapere dove. Inserimento e cancellazione: lista concatenata Bisogna trovare una posizione nella lista, dopo la quale effettuare l inserimento del nuovo nodo: questa posizione si ottiene facendo la scansione lineare alla ricerca di un valore z (un campo info) che dovrà essere presente nella lista. z x Inserimento e cancellazione: lista concatenata Per cancellare un nodo bisogna assegnare ad un riferimento next il valore del riferimento successivo: a.next = a.next.next; Inserimento e cancellazione: array Per inserire un nuovo dato nella i-esima posizione si deve: 1) aumentare la lunghezza dell array, se l array è pieno: costruire un nuovo array w 2) copiare i valori fino alla posizione i nel nuovo array, inserire il nuovo elemento, copiare i rimanenti valori 2 bis) se non serve la posizione intermedia, si può aggiungere alla fine. 10

11 Inserimento e cancellazione: array Per cancellare un dato dalla i-esima posizione si deve: 1) ricopiare gli elementi a partire dalla posizione i+1 sul precedente 1 bis) se l elemento da togliere è unico e non interessa l ordine, si può copiare l ultimo sull i-esimo posto. Dimensione: lista concatenata La dimensione non è fissata: non c è un limite sulla dimensione massima, l unico limite è lo spazio di memoria: non bisogna mai ridimensionare una lista concatenata. Si può gestire male la memoria e occuparla tutta: se viene esaurita la memoria disponibile la JVM interrompe l esecuzione segnalando: OutOfMemoryError Dimensione: array L array è a dimensione fissa. Possiamo risolvere il problema con la tecnica del raddoppio e riassegnando il riferimento della nuova area di memoria. Anche in questo caso il limite è lo spazio di memoria complessivo. Spazio di memoria: lista concatenata La lista concatenata occupa più spazio: ogni nodo è composto da due campi: l informazione il riferimento Se anche l informazione è un oggetto, il nodo è composto da due riferimenti, uno dei quali vede l elemento successivo e l altro l oggetto. Spazio di memoria: array L array occupa meno spazio: c è solo l informazione che deve essere memorizzata Conclusione. L array richiede spostamento di dati (O(n)) nel caso di inserimento e cancellazione, che per la lista sono O(1); possiede invece accesso diretto, che è O(1), mentre la lista accesso sequenziale, che è O(n). Pertanto il tipo di problema suggerirà quale struttura di dati sia più idonea: molti accessi e poche modifiche oppure pochi accessi e molte modifiche. Lista concatenata Se la lista concatenata non ha una dimensione massima dobbiamo però individuarne la fine: un valore di riferimento dal quale non si acceda ad alcun nodo. Tale valore è null. inizio 11

12 Pila su lista concatenata Vogliamo ora realizzare il TDA Pila di interi su una lista concatenata: dovremo realizzare gli assiomi: verifica se la Pila è vuota guarda la testa inserisci in testa estrai la testa Pila su lista concatenata Dobbiamo avere un riferimento al primo nodo per poter accedere alla struttura di dati: ElemIntero primo; Dobbiamo rappresentare la situazione: Pila vuota. Se la Pila è vuota, non c è alcun elemento nella Pila, quindi primo non contiene nulla : primo = null; Pila su lista concatenata Dobbiamo inserire in testa: 1) costruiamo un elemento: ElemIntero nuovo = new ElemIntero(); nuovo.info = valore; 2) agganciamo nuovo in testa: nuovo deve diventare la nuova testa: nuovo.next = primo; //aggancio alla Pila primo = nuovo; //nuovo diventa la testa Pila su lista concatenata Queste assegnazioni valgono anche quando si inserisce il primo elemento, partendo da lista vuota: nuovo.next = primo; //aggancio alla Pila primo = nuovo; //nuovo diventa la testa Quando la lista è vuota, primo = null; quindi la prima assegnazione memorizza null nel campo nuovo.next: il nuovo elemento è l ultimo. La seconda assegnazione lo fa diventare il primo elemento della lista. Pila su lista concatenata Dobbiamo estrarre la testa: se la Pila non è vuota: primo = primo.next; se la Pila è vuota: lanciamo l eccezione EmptyStackException Se nella Pila c è un solo elemento, con l istruzione precedente si vuota la Pila: infatti, primo.next=null (uno solo è l ultimo), pertanto primo diventa null e quindi la Pila è vuota. Pila su lista concatenata Dobbiamo guardare la testa: se la Pila non è vuota: primo.info; se la Pila è vuota: lanciamo l eccezione EmptyStackException Vediamo pertanto la classe che realizza una Pila di interi su una lista concatenata. 12

13 Pila su lista concatenata public class PilaListaConc { // Pila di interi realizzata con // lista concatenata private ElemIntero primo = null; public boolean vuota() {// isempty() if(primo == null) return true; else return false; Pila su lista concatenata public void inserisci (int elem) { // push ElemIntero nuovo = new ElemIntero(); nuovo.next= primo; nuovo.info=elem; primo = nuovo; Pila su lista concatenata public void estrai() {// pop if (!vuota() ) primo = primo.next; else throw new EmptyStackException(); public int testa () {// top if (!vuota() ) return primo.info; else throw new EmptyStackException(); Pila su lista concatenata /** Classe interna: la classe e' privata ma le sue variabili d'istanza sono visibili ai metodi della classe PilaListaConc */ private class ElemIntero { int info; ElemIntero next; //fine PilaListaConc Prestazioni della Pila sulle due strutture di dati lista concatenata array 1) isempty: if( ) O(1) O(1) 2) pop: primo=primo.next O(1) O(1) sp 3) top: restituisce un valore O(1) O(1) 4) push: nuovo +2 assegnazioni raddoppio se l array è pieno O(1) O(1) in media Strutture di dati per numeri e oggetti 13

14 Strutture di dati per numeri e oggetti Come abbiamo portato agli oggetti le proprietà dei numeri (Misurabile, Comparable) così utilizziamo le strutture di dati per memorizzare sia numeri che oggetti: array di numeri e array di oggetti, lista concatenata di numeri e lista concatenata di oggetti. In realtà dovremmo dire: array e lista concatenata di riferimenti a oggetti. Infatti la struttura di dati gestisce i riferimenti per le operazioni di inserimento, cancellazione, ecc. Array numeri oggetti Numeri e oggetti campi Lista concatenata numeri oggetti Numeri e oggetti Strutture di dati per numeri e oggetti Quando vogliamo capire come funziona una struttura di dati o cosa fa un TDA, ci basta trattare numeri. Per utilizzare gli oggetti aggiungeremo al TDA e alla struttura di dati le caratteristiche dell oggetto. Esempio. Abbiamo visto un array per memorizzare informazioni di tipo Stud, che riguardavano gli studenti. Per accedere al campo matricola dell i-esimo studente corso23[i].matricola(). Strutture di dati per numeri e oggetti Se vogliamo costruire una lista concatenata per informazioni di tipo Stud dovremo definire il nodo: class ElemStud{ Stud info; ElemStud next; e per accedere al campo matricola da un riferimento a che vede il nodo: a.info.matricola() 14

15 Una Coda è un TDA ad accesso limitato. Si può accedere al primo elemento della Coda, detto testa e all ultimo elemento detto coda. Le sue funzioni sono: verifica se la coda è vuota: isempty guarda la testa: front inserisci in coda: enqueue estrai la testa: dequeue In una Coda gli oggetti possono essere inseriti ed estratti secondo un comportamento definito FIFO: First In First Out il primo inserito è il primo a uscire Il nome ricorda una fila in attesa : viene estratto l elemento che si trova in coda da più tempo, testa. Gli assiomi assomigliano a quelli della Pila: verifica se la Coda è vuota: isempty guarda la testa: top, front estrai un elemento (la testa): pop, dequeue inserisci un elemento: push (testa), enqueue (coda) Solo l inserimento è diverso: nella Pila si inserisce in testa, nella Coda alla fine. La Coda si può realizzare su array riempito solo in parte oppure su lista concatenata. Realizziamo la Coda su array. Nella Pila si estraeva e si inseriva da un unica parte: l estremo destro dell array sp-- sp++ Nella Coda decidiamo di: inserire a destra e di estrarre a sinistra. Costruiamo l array: int v[] = new int[6]; int qp; //queue pointer: prima posizione libera qp = 0; //Coda vuota; Per accedere alla testa: restituire v[0] Per inserire un elemento in coda: v[qp] = valore; qp++; Se la Coda è piena si effettua il raddoppio. Per togliere la testa ed avere la nuova testa nella prima posizione (qp=0) si devono ricopiare all indietro gli elementi: qp--; for(int i = 0; i<qp; i++) v[i] = v[i+1]; 15

16 Questa realizzazione, efficiente per la Pila, è poco efficiente per la Coda. Nella Pila tutte le operazioni sono O(1), tranne inserisci che è O(1) in media. Nella Coda le operazioni sono O(1), tranne inserisci che è O(1) in media (raddoppio) e togli che è O(n): infatti per mantenere la struttura compatta, si devono sempre spostare tutti gli elementi. Per realizzare una Coda più efficiente usiamo due indici. Un indice vede il primo elemento, l altro indice vede l ultimo. L ultimo rappresenta la prima posizione libera in cui inserire un nuovo elemento (inserimento in coda); il primo è la testa. L array è riempito nella parte centrale. primo ultimo Abbiamo quindi: int primo, ultimo; primo = 0; //testa ultimo = 0; //prima posizione libera Coda vuota: primo == ultimo la prima posizione libera è la testa della coda accedere alla testa (se non è vuota): restituire v[primo] togliere la testa (se non è vuota): primo ++; inserire un elemento, in coda: v[ultimo] = valore; ultimo++; e se l array è pieno si raddoppia In tale modo tutte le operazioni sono O(1) tranne inserisci che è O(1) in media: la realizzazione con due indici è più efficiente. Rimane un problema. Supponiamo che l array abbia 10 componenti (i=0,1, 2,..., 9), si inizia con coda vuota: primo=0 e ultimo=0. Eseguiamo 10 operazioni di inserimento: ultimo=10, che rappresenta Coda piena e per un prossimo inserimento si dovrà eseguire il raddoppio. Eseguiamo 10 operazioni di estrazione: primo=ultimo, che rappresenta Coda vuota. Ora vogliamo inserire un nuovo dato: poiché ultimo = 10 si effettua il raddoppio, anche se la Coda è vuota: in tale modo lo spazio va perduto e se continuiamo in questo modo, occupiamo spazio per rappresentare Code vuote. Si risolve il problema con la tecnica dell array circolare: se c è posto prima non si effettua il raddoppio. 16

17 Quando ultimo==v.length invece del raddoppio ritorna al valore iniziale, in tale modo si recupera lo spazio lasciato libero dall eliminazione degli elementi, facendo il giro : ultimo primo Aritmetica modulo m. Siano a ed m due numeri naturali, indichiamo con a mod m il resto della divisione a/m Se m = 10 abbiamo: per a < m a mod m = a per a m ritroviamo come resti i valori compresi tra 0 e 9 Esempio. 1/10 resto 1 quoziente 0 3/10 resto 3 9/10 resto 9 10/10 resto 0 quoziente 1 24/10 resto 4 quoziente 2 Dobbiamo trovare un modo per calcolare l incremento di primo e di ultimo per fare il giro. Per costruire il successivo (dobbiamo gestire primo++ e ultimo++) costruiamo un metodo per calcolare il resto della divisione del successivo con la dimensione dell array (modulo la dimensione dell array): int incremento(int n){ return((n+1)%v.length); Invece di: primo++ incremento(primo) ultimo++ incremento(ultimo) Rimane ancora un problema. Per raddoppiare non si dovrà più vedere se ultimo==v.length ma se incremento(ultimo)==primo così consideriamo anche il caso in cui possiamo avere fatto tutto il giro (ultimo<primo). Rimane (giustamente) un posto libero prima di fare il raddoppio. Ma cosa succede nel raddoppio se avevamo fatto il giro? L array si raddoppia a destra, e la Coda è nella prima metà e non è ben memorizzata; dobbiamo quindi ricopiare la prima parte dalla testa fino al valore di ultimo (escluso) nella seconda metà: 17

18 public void inserisci(int elem) { /**enqueue: inserimento in coda: in media O(1)*/ if (incremento (ultimo) == primo){ //Coda piena: raddoppio int[] tmp = new int[2*vett.length]; for (int i = 0; i < vett.length; i++) tmp[i] = vett[i]; vett = tmp; if (ultimo < primo) {/** se gli ultimi elementi inseriti sono all inizio dell array e i primi verso la fine */ /**dopo il ridimensionamento la coda "funziona" male; si sposta nella seconda meta dell'array la parte che si trova all'inizio */ for (int i = 0; i < ultimo; i++) vett[vett.length/2 + i]=vett[i]; ultimo = ultimo + vett.length/2; //fine if //fine if vett[ultimo] = elem; ultimo = incremento(ultimo); 18