Liste Concatenate 28 Marzo 2006

Avviso Martedi’ 4 Aprile: Verifica di LIP Per iscriversi (obbligatorio) inviare un e- mail entro venerdi’ 31 Marzo a Portare l’account e un dischetto

E’ una delle strutture dati fondamentali in tutti i linguaggi di programmazione di alto livello Una Lista Concatenata serve per rappresentare sequenze di elementi (di dimensione variabile) [ ] Le operazioni permettono di aggiungere elementi all’inizio o alle fine, e di scorrere la lista

Tipo di dato ricorsivo Definizione ricorsiva: una lista concatenata e’ vuota o e’ un nodo che contiene un valore e un puntatore al resto della lista

Esempio Lista non vuota: val next Primo elemento 1164 Lista vuota

IntList Vediamo per esempio una possibile specifica nel caso di valori di tipo Integer Definiamo un tipo di dato astratto modificabile

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

Specifica di IntList public void addEl (Integer x) throws NullPointerException {//MODIFIES:this // EFFECTS: se x e’ null solleva NullPointerException, altrimenti 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 int size () { // EFFECTS: ritorna il numero di elementi di this} public String toString (){// EFFECTS: standard } }

Nota Il metodo rest restituisce il resto della lista (la lista ottenuta rimuovendo il primo elemento) Usando first e rest si puo’ scorrere la lista (metodo di ricerca) public static boolean cerca (Intlist l,Integer x) throws NullPointerException { // EFFECTS: se l o x sono null solleva NullPointerException, altrimenti restituisce true se x occorre nella lista l, false se non occorre}

Scritto guardando solo la specifica (ricorsivo) public static boolean cerca (Intlist l,Integer x) throws NullPointerException { if (x==null|| l==null) throw new NullPointerException(“Lista.cerca”); //caso base if (l.size()==0) {return false;} //caso ricorsivo {Integer el=l.first(); if (el.equals(x)) {return true;} return cerca(l.rest(),x);} }

Esempio l=[1,6,3] x=6 Confronta x con l.first()=1 Chiama la procedura con l’=l.rest()= [6,3] ed x=6 Confronta x con l’.first()=6 La chiamata ricorsiva restituisce true (il metodo chiamante restituisce true)

Come si implementa? Ci sono vari modi (a LIP altre soluzioni) Dobbiamo scegliere delle variabili d’istanza che permettano di rappresentare sia la lista vuota che quella non vuota Deve essere possibile distinguere i due casi in modo chiaro private boolean vuota; //indica se e’ vuota private Integer val; //contiene il valore private IntList next; //puntatore al resto

Rappresentazione Lista val next vuota Lista vuota: any true Lista non vuota: any true 154 false 24 false

Nota Il flag vuota serve per indicare la lista vuota Nell’implementazione che facciamo quando vuota e’ falso garantiamo che il puntatore al resto della lista non sia null Semplifica l’implementazione dei metodi (non sono necessari test per vedere che il puntatore sia definito)

Implementazione 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; Nota: rappresentazione privata

Costruttori public IntList () { // EFFECTS: inizializza this alla lista vuota vuota=true;} public IntList (Integer x) { // EFFECTS: inizializza this alla lista che contiene esattamente x if (x==null) throw new NullPointerException(“IntList.IntList”); vuota=false; val=x; next=new IntList();} Notate che nel secondo costruttore next viene inizializzato alla lista vuota (sta sempre al termine) !

Costruttori val next vuota Lista vuota: any true Lista con un elemento: any true 24 false

Inserimento public void addEl (Integer x) { //MODIFIES:this // EFFECTS: aggiunge x all’inizio di this if (x==null) throw new NullPointerException(“IntList.IntList”); {if (vuota) {val=x;next=new IntList();vuota=false;} else {IntList n = new IntList(val); n.next = this.next; //copia di this this.val =x; this.vuota=false; this.next=n;} }} 4 Mettiamo l’elemento in testa, 4 creando un nuovo nodo che contiene x ed ha come resto della lista this

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 if (vuota) return 0; return 1 + next.size(); } Metodo Ricorsivo!!!!!!!!!

ToString() public String toString (){ String s=“”; if (vuota) {return s;} return val.intValue() + next.toString(); } 4 Metodo Ricorsivo !

Esercizio Definire una variante StringList Contiene Stringhe Ha un metodo per aggiungere all’inizio ed alla fine Omettiamo (dalla specifica) l’eccezione NullPointerException che deve essere sollevata da tutti i metodi che inseriscono stringhe per controllare che non siano null.

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

Specifica di StringList public void FaddEl (String x) { //MODIFIES:this // EFFECTS: aggiunge x all’inizio di this } public void LaddEl (String x) { //MODIFIES:this // EFFECTS: aggiunge x alla fine di this } public String first () throws EmptyException{ // EFFECTS: se this è vuoto solleva EmptyException, altrimenti // ritorna il primo elemento di this} public StringList rest () throws EmptyException{ // EFFECTS: se this è vuoto solleva EmptyException, altrimenti // ritorna la lista ottenuta da this togliendo il primo elemento}

Specifica di StringList public int size () { // EFFECTS: ritorna il numero di elementi di this} public String toString (){// EFFECTS: standard } } public void remove (String x) { //MODIFIES:this // EFFECTS: rimuove tutte le occorrenze di x da this } }

Rappresentazione Privata private boolean vuota; //indica se e’ vuota private String val; //contiene il valore private StringList next; //puntatore al resto

Seconda Parte Implementare la seguente specifica Classe che definisce due procedure statiche per fare reverse o calcolare il valore minimo che compare nella lista

Specifica public class IntListProc { // OVERVIEW: fornisce metodi statici per manipolare //liste di stringhe public static String min(StringList l) throws EmptyException {// REQUIRES: l non e’ null //EFFECTS: se l e’ vuota solleva EmptyException, altrimenti restituisce il minimo elemento di l} public static StringList reverse (StringList l) {// REQUIRES: l non e’ null //EFFECTS: restituisce una lista che e’ l’inverso di l} }

Specifica public static StringList append (StringList x, StringList y) {// REQUIRES: x ed y non null //EFFECTS: restituisce una lista che e’ la concatenazione di x ed y. Esempio: x=[3,7] ed y=[9,1] ===> [3,7,9,1] }

Come si ordinano le stringhe? public int compareTo (Object x) throws ClassCastException, NullPointerException{ // EFFECTS: se x è null, lancia NullPointerException; // se this e x non sono confrontabili, solleva ClassCastException; // altrimenti, se this è minore di x ritorna -1; // se this = x ritorna 0; se this è maggiore di x, ritorna 1 } Metodo ereditato da una superclasse Comparable (lo vederemo in seguito)

Metodi Statici Devono operare su StringList tramite l’interfaccia pubblica Non hanno visibilita’ delle variabili d’istanza val e next Lucidi successivi (una possibile impl.)

public class StringList { private String val; private StringList next; private boolean vuota; public StringList () { vuota=true } public StringList (String x) throws NullPointerException{ if (x==null) throw new NullPointerException(“”); val=x;vuota=false;next=new StringList(); }

Costruttori val next vuota Lista vuota: any true Lista con un elemento: any true 24 false

Aggiungere in testa public void FaddEl (String x) { if (x==null) throw new NullPointerException(“IntList.IntList”); if (vuota) {val=x;next=new StringList(); vuota=false;} else { StringList n = new StringList(val); n.next = this.next; //copia di this this.val =x; this.vuota=false; this.next=n;}} }

Aggiungere in fondo public void LaddEl (String x) { //MODIFIES:this // EFFECTS: aggiunge x alla fine di this if (vuota) {vuota=false; val=x; next=new StringList(); } else next.LaddEl(x); } Metodo ricorsivo: caso base e’ la lista vuota !

Metodi public String 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 StringList 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;}

Metodi public void remove (String x) { // EFFECTS:rimuove tutte le occorrenze di x da this if (vuota) {return;} if (!val.equals(x)){next.remove(x);} else {if (next.vuota) {this.vuota=true} else {this.val=next.val; this.next=next.next; this.remove(x);} }}

Metodi Ricorsivi public String toString (){ if (vuota) {return “”;} return val + next.toString();} public int size (){ if (vuota) return 0 else return 1+ next.size(); }

Metodi Statici Devono operare su StringList tramite l’interfaccia pubblica Non hanno visibilita’ delle variabili d’istanza val e next

Metodi Statici public class IntListProc { public static String min(StringList l) throws EmptyException{ if (l.size()==0) throw new EmptyException(“”); {String result=l.first(); try{String next=min(l.rest())} catch (EmptyException e) {return result;} if (next.compareTo(result) <0) {result=next;} return result;} } Nota: l.first() e l.rest() di sicuro non sollevano eccezioni in quanto vengono invocati solo se la lista non e’ vuota!!!!

Metodi Statici public static StringList reverse(StringList l) {// REQUIRES: l non e’ null //EFFECTS: restituisce una lista che e’ l’inverso di this if (l.size()==0) return new StringList(); else {StringList next=reverse(l.rest()); return next.LaddEl(l.first()); }