Liste di Interi Esercitazione

IntList Lista di interi Una lista è una disposizione ordinata di elementi ( non in modo crescente-descrescente, ma per ordine di inserimento) Vediamo la specifica

Specifica di IntList public class IntList { // OVERVIEW: un IntList è una lista modificabile // di Integers. // Elemento tipico [x1,...,xn] public IntList () { // EFFECTS: inizializza this alla lista vuota } public IntList (Integer x) { // EFFECTS: inizializza this alla lista che // contiene esattamente x }

Specifica di IntList public void addEl (Integer x) { // EFFECTS: aggiunge x all’inizio di this } public Integer first () throws EmptyException{ // EFFECTS: se this è vuoto solleva EmptyException, altrimenti // ritorna il primo elemento di this} public IntList rest () throws EmptyException{ // EFFECTS: se this è vuoto solleva // EmptyException, altrimenti // ritorna la lista ottenuta da this togliendo // il primo elemento}

Specifica di IntList public IntList rest () throws EmptyException{ // EFFECTS: se this è vuoto solleva // EmptyException, altrimenti // ritorna la lista ottenuta da this togliendo // il primo elemento} public int size () { // EFFECTS: ritorna il numero di elementi di // this} public Iterator elements () { // EFFECTS: ritorna un generatore che produrrà // tutti gli elementi di this (come Integers) // nell’ordine che hanno in this }

Specifica di IntList public boolean equals (IntList o) { // EFFECTS: metodo overridden, verifica se o e // this rappresentano la stessa lista public boolean repOk (){// EFFECTS:standard} public String toString (){// EFFECTS: standard } } Dobbiamo riscrivere il metodo equals (di Object), dato che il tipo di dato e’ modificabile vogliamo vedere se hanno gli stessi elementi (altrimenti verificherebbe solo il puntatore)

Implementazione E` modificabile Bisogna mantenere l’ordinamento Vector? Facciamo invece vedere una implementazione ricorsiva: lista concatenata E` una delle strutture dati fondamentali in Informatica, essenziale per esempio in linguaggi che non hanno come primitivo un tipo di dimensione variabile quale Vector

Lista concatenata o è vuota o contiene un valore (di tipo Integer in questo caso) e un puntatore al resto della lista Nota: si può implementare in modo ricorsivo simile all’ albero binario (più semplice)

Rappresentazione public class IntList { // OVERVIEW: un IntList è una lista non modificabile di Integers. // Elemento tipico [x1,...,xn] private boolean vuota; private Integer val; private IntList next; private int sz; Nota: la variabile sz mantiene il numero di elementi della lista, non è necessaria ma rende l’implementazione piu’ efficiente (va pero’ tenuta aggiornata)

Esercizio Scrivere l’invariante di rappresentazione e la funzione di astrazione (riflettendo le scelte di progetto) Implementare i metodi

Invariante (ricorsiva) I(c) = c.vuota oppure (c.next != null e I(c.next) e c.sz= 1 + c.next.size() ) O e’vuota (non c’è nessuna condizione) Oppure il next deve essere definito Il valore di sz deve essere uguale al numero di elementi del next +1

 (c) = se c.vuota allora [], altrimenti  (c) = [c.val] +  (c.next)  Mappa gli oggetti concreti, implementati con una lista concatenata, nella corrispondente lista, del tipo [x1,..., xn] 4 La funzione di astrazione ricorsiva riflette il fatto che l’ordinamento implementato è di fatto quello astratto, il primo elemento è quello contenuto in val, poi seguono gli elementi del next Funzione di astrazione

Costruttori public IntList () { // EFFECTS: inizializza this alla lista vuota vuota=true;sz=0;} public IntList (Integer x) { // EFFECTS: inizializza this alla lista che // contiene esattamente x vuota=false; val=x; next=new IntList();sz=1;}

Inserimento public void addEl (Integer x) { // EFFECTS: aggiunge x all’inizio di this IntList n = new IntList(x); n.next = this; n.sz = this.sz + 1; this =n; } 4 Mettiamo l’elemento in testa, creando una lista che contiene x  Corretto:  (c_pre) =L  (c) =[c.val] +  (c.next)=[x]+L

First e rest public Integer first () throws EmptyException{ // EFFECTS: se this è vuoto solleva EmptyException // altrimenti ritorna il primo elemento di this if (vuota) throw new EmptyException(“IntList.first”); return val;} public IntList rest () throws EmptyException{ // EFFECTS: se this è vuoto solleva EmptyException, // altrimenti ritorna la lista ottenuta da this // togliendo il primo elemento if (vuota) throw new EmptyException(“IntList.first”); return next;}

Size public int size () { // EFFECTS: ritorna il numero di elementi di this return sz;} 4 Corretto: l’invariante assicura che sz contenga proprio il numero di elementi della lista Più efficiente: altrimenti dovrei usare un metodo ricorsivo per calcolarli

Equals public boolean equals (IntList o) { // EFFECTS: metodo overridden, verifica se o e this rappresentano la stessa lista if (vuota && o.vuota) {return true;} if (val != o.val) {return false;} return this.next.equals(o.next);}  Deve verificare che  (this) =  (o) 4 Si sfrutta il fatto che, come garantito dall’invariante, se non vale 4 vuota, allora next è definito (al limite è la lista vuota)

Commenti Notate che come anche garantito dall’invariante, quando la lista non è vuota, next è definito (non null) Questo garantisce che le chiamate ricorsive (p.e. equals) non sollevino eccezioni Inoltre l’uso di vuota semplifica la definizione del caso base dell’induzione (lista vuota)

Iteratore public Iterator elements () { // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) nell’ordine che // hanno in this return new IntListGen(this); } Restituisce un generatore, istanza di un sottotipo di Iterator IntlistGen è una classe interna di IntList privata e statica (indipendente dagli oggetti)

Generatore Dobbiamo generare tutti gli elementi della lista dal primo all’ultimo Generatore: deve essere ricorsivo Per iterare su l: prima generiamo l.val Poi, chiamiamo il generatore di next

Implementazione Usiamo una variabile figlio di tipo IntList per memorizzare il generatore del next Usiamo una variabile corrente per sapere quando dobbiamo ancora generare val o quando dobbiamo chiamare il generatore di next

public class IntList { private static class IntListGen implements Iterator { private boolean corrente; private IntListGen figlio; // sottogeneratore del resto della lista private IntList me; // la lista da generare  si noti l’uso di me per memorizzare la lista su cui iteriamo

Metodi public IntListGen(IntList o) { // REQUIRES: o != null me=o; if (o.sz >0) {corrente = true; figlio = new IntListGen(o.next);}} public boolean hasNext () { if (me.vuota) {return false; } if (corrente) {return true;} return figlio.hasnext(); }

Metodi public Object next() throws NoSuchElementException{ if (me.vuota) throw NoSuchElementException(“IntList.elements”); if (corrente) {return me.val; corrente=false;} return figlio.next(); }