Il tipo astratto di dati Node List

Transcript

1 Il tipo astratto di dati Node List Tipo di dati e operazioni Tipi di dati: oggetti arbitrari (come al solito) Operazioni: Metodi generici: - integer size() - boolean isempty() Metodi di accesso: - Position first(): Restituisce la posizione del primo elemento della lista - Position last(): Restituisce la posizione dell ultimo elemento della lista - Position prev(position p): Restituisce la posizione dell elemento che precede l elemento in posizione p - Position next(position p): Restituisce la posizione dell elemento che segue l elemento in posizione p

2 Il tipo astratto di dati Node List Tipo di dati e operazioni Metodi di aggiornamento: - E set(position p, E e): Rimpiazza l'elemento in posizione p con e, restituendo l'elemento che prima era in posizione p - addbefore (Position p, E e): Inserisce l elemento e nella posizione che precede la posizione p - addafter(position p, E e): Inserisce l elemento e nella posizione che segue la posizione p - addfirst(e e): Inserisce l elemento e come primo elemento - addlast(e e): Inserisce l'elemento e come ultimo elemento - E remove(position p): Rimuove e restituisce l elemento in posizione p

3 Il tipo astratto di dati Node List Eccezioni InvalidPositionException Viene lanciata quando viene specificata come argomento una posizione non valida (ad esempio la posizione è null oppure è inesistente) BoundaryViolationException Viene lanciata quando si tenta di accedere ad una posizione al di fuori della lista (ad esempio si chiama il metodo next sull'ultima posizione della lista) EmptyListException Viene lanciata quando si invocano i metodi first() o last() su una lista vuota

4 Il tipo astratto di dati Node List L'interfaccia Position package position; public interface Position<E> { E element();

5 Il tipo astratto di dati Node List L'interfaccia PositionList public interface PositionList<E> {... public int size(); public boolean isempty(); public Position<E> first() throws EmptyListException; public Position<E> last() throws EmptyListException; public Position<E> next(position<e> p) throws InvalidPositionException, BoundaryViolationException; public Position<E> prev(position<e> p) throws InvalidPositionException, BoundaryViolationException; public void addfirst(e e); public void addlast(e e);

6 Il tipo astratto di dati Node List L'interfaccia PositionList public interface PositionList<E> {... public void addafter(position<e> p, E e) throws InvalidPositionException; public void addbefore(position<e> p, E e) throws InvalidPositionException; public E remove(position<e> p) throws InvalidPositionException; public E set(position<e> p, E e) throws InvalidPositionException;

7 Il tipo astratto di dati Node List Implementazione basata su liste dopp. concatenate header trailer Liste doppiam. concatenate NODI ADT Lista POSIZIONI I nodi della lista doppiamente concatenata implementano le posizioni dell'adt node list

8 Il tipo astratto di dati Node List Implementazione dell'interfaccia Position public class DNode<E> implements Position<E> { private DNode<E> prev, next; private E element; public DNode(DNode<E> newprev, DNode<E> newnext, E elem) { prev = newprev; next = newnext; element = elem; public E element() { if ((prev == null) && (next == null)) throw new InvalidPositionException("La posizione non e` in una lista!"); return element; public DNode<E> getnext() { return next; public DNode<E> getprev() { return prev; public void setnext(dnode<e> newnext) { next = newnext; public void setprev(dnode<e> newprev) { prev = newprev; public void setelement(e newelement) { element = newelement;

9 Il tipo astratto di dati Node List Implementazione dell'interfaccia PositionList import position.*; public class NodePositionList<E> implements PositionList<E> {... protected int numelts; // Numero di elementi nella lista protected DNode<E> header, trailer; // Nodi sentinella public NodePositionList() { numelts = 0; header = new DNode<E>(null, null, null); trailer = new DNode<E>(header, null, null); header.setnext(trailer);

10 Il tipo astratto di dati Node List Implementazione dell'interfaccia PositionList public class NodePositionList<E> implements PositionList<E> {... public int size() { return numelts; public boolean isempty() { return (numelts == 0); public Position<E> first() throws EmptyListException { if (isempty()) throw new EmptyListException("La lista e` vuota"); return header.getnext(); public Position<E> last() throws EmptyListException { if (isempty()) throw new EmptyListException("La lista e` vuota"); return trailer.getprev();...

11 Il tipo astratto di dati Node List Implementazione dell'interfaccia PositionList public class NodePositionList<E> implements PositionList<E> {... protected DNode<E> checkposition(position<e> p) throws InvalidPositionException { if (p == null) throw new InvalidPositionException ("Null passato come posizione"); if (p == header) throw new InvalidPositionException ("header non e` una posizione valida di una lista"); if (p == trailer) throw new InvalidPositionException ("trailer non e` una posizione valida di una lista"); try { DNode<E> temp = (DNode<E>) p; if ((temp.getprev() == null) (temp.getnext() == null)) throw new InvalidPositionException ("La posizione non fa parte di una lista"); return temp; catch (ClassCastException e) { throw new InvalidPositionException ("Il tipo della posizione non e` valido per questa lista");...

12 Il tipo astratto di dati Node List Implementazione dell'interfaccia PositionList public class NodePositionList<E> implements PositionList<E> {... public Position<E> prev(position<e> p) throws InvalidPositionException, BoundaryViolationException { DNode<E> v = checkposition(p); DNode<E> prev = v.getprev(); if (prev == header) throw new BoundaryViolationException ("non posso retrocedere oltre l'inizio della lista"); return prev;... public Position<E> next(position<e> p) throws InvalidPositionException, BoundaryViolationException { DNode<E> v = checkposition(p); DNode<E> next = v.getnext(); if (next == trailer) throw new BoundaryViolationException ("non posso avanzare oltre la fine della lista"); return next;

13 Il tipo astratto di dati Node List Implementazione dell'interfaccia PositionList public class NodePositionList<E> implements PositionList<E> {... public void addafter(position<e> p, E element) throws InvalidPositionException { DNode<E> v = checkposition(p); numelts++; DNode<E> newnode = new DNode<E>(v, v.getnext(), element); v.getnext().setprev(newnode); v.setnext(newnode);... public void addfirst(e element) { numelts++; DNode<E> newnode = new DNode<E>(header, header.getnext(), element); header.getnext().setprev(newnode); header.setnext(newnode);

14 Il tipo astratto di dati Node List Implementazione dell'interfaccia PositionList public class NodePositionList<E> implements PositionList<E> { public E remove(position<e> p) throws InvalidPositionException { DNode<E> v = checkposition(p); numelts--; DNode<E> vprev = v.getprev(); DNode<E> vnext = v.getnext(); vprev.setnext(vnext); vnext.setprev(vprev); E velem = v.element(); // scollega la posizione dalla lista rendendola invalida v.setnext(null); v.setprev(null); return velem;

15 Esercizio Merge sort L'algoritmo merge sort è un algoritmo di ordinamento che ordina una sequenza di elementi ricorsivamente nel modo seguente: 1. divide la sequenza in due sequenze non ordinate, ciascuna avente taglia circa la metà della sequenza originale; 2. ordina separatamente ciascuna delle due sequenze; 3. fonde le due sequenze ordinate in un'unica sequenza ordinata. Dare un'implementazione del merge sort usando l'adt Lista. Si assuma che gli elementi da ordinare siano di tipo Integer.

16 Soluzione Merge sort public static void mergesort(positionlist<integer> L){ int n = L.size(); if (n < 2) return; PositionList<Integer> L1 = new NodePositionList<Integer>(); PositionList<Integer> L2 = new NodePositionList<Integer>(); for (int i = 0; i < n/2; i++) L1.addLast(L.remove(L.first())); for (int i = n/2; i < n; i++) L2.addLast(L.remove(L.first())); mergesort(l1); mergesort(l2); merge(l1,l2,l);

17 Soluzione Merge sort public static void merge(positionlist<integer> L1, PositionList<Integer> L2, PositionList<Integer> L){ while (!L1.isEmpty() &&!L2.isEmpty()) if (L1.first().element() <= L2.first().element()) L.addLast(L1.remove(L1.first())); else L.addLast(L2.remove(L2.first())); while(!l1.isempty()) // sposta i rimanenti elementi di L1 L.addLast(L1.remove(L1.first())); while(!l2.isempty()) // sposta i rimanenti elementi di L2 L.addLast(L2.remove(L2.first()));

18 Iteratore A cosa serve Una operazione molto frequente sugli ADT array list e lista di nodi è quella di scandire la collezione di elementi un elemento alla volta Esempi: - cercare uno specifico elemento - visualizzare ordinatamente gli elementi della collezione - determinare il numero di occorrenze di un dato elemento - sommare tutti gli elementi di una collezione

19 Iteratore A cosa serve Un iteratore è un software design pattern che permette la scansione di un qualsiasi ADT che astrae una collezione ordinata di elementi Un iteratore può essere visto come una estensione del concetto di posizione (position): - l'adt position incapsula il concetto di posto - un iteratore incapsula il concetto di posto e di posto successivo

20 Iteratore Esempio Data una collezione ordinata di oggetti (array list, node list) A B C D

21 Iteratore Esempio Data una collezione ordinata di oggetti (array list, node list) A B C D un iteratore è un nuovo ADT che ci permette di scandire la collezione

22 Iteratore Esempio Data una collezione ordinata di oggetti (array list, node list) A B C D ADT iteratore A un iteratore è un nuovo ADT che ci permette di scandire la collezione

23 Iteratore Esempio Data una collezione ordinata di oggetti (array list, node list) A B C D ADT iteratore B un iteratore è un nuovo ADT che ci permette di scandire la collezione

24 Iteratore Esempio Data una collezione ordinata di oggetti (array list, node list) A B C D ADT iteratore C un iteratore è un nuovo ADT che ci permette di scandire la collezione

25 Iteratore Esempio Data una collezione ordinata di oggetti (array list, node list) A B C D ADT iteratore D un iteratore è un nuovo ADT che ci permette di scandire la collezione

26 Iteratore Definizione del tipo astratto di dati Un iteratore può essere definito come un ADT che supporta i seguenti due metodi: - public boolean hasnext(): determina se ci sono altri elementi nell'iteratore - public E next(): restituisce l'elemento successivo in un iteratore

27 Iteratore Definizione del tipo astratto di dati Un iteratore può essere definito come un ADT che supporta i seguenti due metodi: - public boolean hasnext(): determina se ci sono altri elementi nell'iteratore - public E next(): restituisce l'elemento successivo in un iteratore eccezione: NoSuchElementException quando next() viene invocato su una collezione vuota o sull'ultimo elemento della collezione

28 Iteratore Definizione del tipo astratto di dati Un iteratore può essere definito come un ADT che supporta i seguenti due metodi: - public boolean hasnext(): determina se ci sono altri elementi nell'iteratore - public E next(): restituisce l'elemento successivo in un iteratore eccezione: NoSuchElementException quando next() viene invocato su una collezione vuota o sull'ultimo elemento della collezione java fornisce un iteratore con l'interfaccia java.util.iterator

29 Iteratore Implementazione un iteratore viene solitamente associato ad uno degli ADT ad accesso sequenziale (array list, lista di nodi) un iteratore permette di accedere a tutti gli oggetti della collezione nell'ordine lineare stabilito il primo elemento di un iteratore si ottiene dalla prima chiamata del metodo next() (assumendo che l'iteratore contenga almeno un elemento) un iteratore deve essere indipendente dal modo con cui è organizzata la collezione di oggetti a cui è associato

30 Iteratore Implementazione Vogliamo un meccanismo uniforme per scandire una struttura dati ad accesso sequenziale: dobbiamo fare in modo che tutti i tipi astratti di dati ad accesso sequenziale supportino il seguente metodo: Iterator<E> iterator(): restituisce un iteratore degli elementi della collezione

31 Iteratore Implementazione Vogliamo un meccanismo uniforme per scandire una struttura dati ad accesso sequenziale: dobbiamo fare in modo che tutti i tipi astratti di dati ad accesso sequenziale supportino il seguente metodo: Iterator<E> iterator(): restituisce un iteratore degli elementi della collezione in Java 5 questo metodo è fornito dall'interfaccia java.lang.iterable

32 Iteratore Implementazione La nostra implementazione deve consentire di tener traccia del punto della collezione indicato dal cursore dell'iteratore creare un nuovo iteratore consiste semplicemente nel creare un oggetto iteratore che rappresenta un cursore posto prima del primo elemento della collezione usando la prima volta il metodo next(), si sposta il cursore sul primo elemento della collezione successive invocazioni del metodo next() ci permetteranno di scandire tutti gli elementi della collezione il metodo hasnext() ci permette di capire quando abbiamo finito di scandire tutta la collezione (va usato prima di invocare next())

33 Iteratore (lista di nodi) Modifica dell'interfaccia PositionList<E> Aggiungiamo il metodo iterator() all'interfaccia PositionList<E>: public interface PositionList<E> {...

34 Iteratore (lista di nodi) Modifica dell'interfaccia PositionList<E> Aggiungiamo il metodo iterator() all'interfaccia PositionList<E>: import java.util.iterator; public interface PositionList<E> extends Iterable<E>{... public Iterator<E> iterator(); Nelle prossime diapositive vediamo come implementare questo metodo

35 Iteratore (lista di nodi) La classe ElementIterator<E> import java.util.iterator; import position.*; public class ElementIterator<E> implements Iterator<E>{ protected PositionList<E> list; // la lista su cui implem. l'iteratore protected Position<E> cursor; // indica la successiva posizione public ElementIterator(PositionList<E> L) { list = L; cursor = (list.isempty())? null : list.first(); public boolean hasnext() { return (cursor!= null); public E next() throws NoSuchElementException { if (cursor == null) throw new NoSuchElementException("No next element"); E toreturn = cursor.element(); cursor = (cursor == list.last())? null : list.next(cursor); return toreturn; public void remove() {

36 Iteratore (lista di nodi) Il metodo iterator() nella classe NodePositionList Aggiungiamo l'implementazione del metodo iterator() (che usa la classe ElementIterator<E>) alla classe NodePositionList<E> che implementa l'interfaccia PositionList<E>: public class NodePositionList<E> implements PositionList<E> {... public Iterator<E> iterator() {return new ElementIterator<E>(this);

37 Merge sort Scansione della lista con un iteratore public static void main(string[] args) { PositionList<Integer> L1 = new NodePositionList<Integer>(); L1.addLast(7); L1.addLast(5); L1.addLast(2); L1.addLast(4); L1.addLast(1); L1.addLast(8); mergesort(l1); Iterator<Integer> I = L1.iterator(); while (I.hasNext()) System.out.print(I.next()+" ");

38 Esercizio di test Scrivere un metodo public static void remove (PositionList<Integer> L, Integer i) che rimuova da una lista L di interi tutte le occorrenze dell'intero i.

39 Iteratore sulle posizioni Per gli ADT con Position Negli ADT che supportano la nozione di position (come la lista di nodi) possiamo fare una scansione delle posizioni oltre che degli elementi?

40 Iteratore sulle posizioni Per gli ADT con Position Negli ADT che supportano la nozione di position (come la lista di nodi) possiamo fare una scansione delle posizioni oltre che degli elementi? Possiamo fornire anche il metodo: positions(): restituisce un oggetto Iterable contenente le posizioni della collezione come suoi elementi

41 Iteratore sulle posizioni Per gli ADT con Position Aggiungiamo il metodo positions() all'interfaccia PositionList<E>: import java.util.iterator; public interface PositionList<E> extends Iterable<E>{... public Iterator<E> iterator(); public Iterable<Position<E>> positions();

42 Iteratore sulle posizioni (nodelist) Implementazione del metodo positions() public class NodePositionList<E> implements PositionList<E> {... public Iterable<Position<E>> positions() {// crea una lista di posizioni PositionList<Position<E>> P = new NodePositionList<Position<E>>(); if (!isempty()) { Position<E> p = first(); while (true) { P.addLast(p); // aggiunge la posizione p come ultimo elemento di P if (p == last()) break; p = next(p); return P; // restituisce P come oggetto Iterable public Iterator<E> iterator() {return new ElementIterator<E>(this);

43 Iteratore sulle posizioni (nodelist) Implementazione del metodo positions() Cosa fa il metodo positions()? Il metodo positions() se invocato su una lista L crea una nuova lista P contenente le posizioni di L La lista P viene restituita come un oggetto Iterable<Position<E>> Ciò ci permette di invocare il metodo iterator() su P per ottenere facilmente un iteratore sulle posizioni della lista originale L

44 Ritorniamo al nostro esercizio Uso del metodo positions() Scrivere un metodo public static void remove (PositionList<Integer> L, Integer i) che rimuova da una lista L di interi tutte le occorrenze dell'intero i.

45 Ritorniamo al nostro esercizio Soluzione public static void remove(positionlist<integer> L, Integer i){ Iterable<Position<Integer>> It = L.positions(); Iterator<Position<Integer>> I = It.iterator(); while (I.hasNext()){ Position<Integer> p = I.next(); if (p.element().equals(i)) L.remove(p); public static void main(string[] args) { PositionList<Integer> L1 = new NodePositionList<Integer>();... remove(l1,1); Iterator<Integer> I = L1.iterator(); while (I.hasNext()) System.out.print(I.next()+" ");

46 For-each-loop for(iterator<type> iter = expression.iterator(); iter.hasnext();){ Type name = iter.next(); loop_statement for(type name : expression){ loop_statement

47 For-each-loop for(iterator<type> iter = expression.iterator(); iter.hasnext();){ Type name = iter.next(); loop_statement for(iterator<position<e>> iter = positions.iterator(); iter.hasnext();){ Position<E> pos = iter.next(); System.out.println(pos.element()); for(type name : expression){ loop_statement

48 For-each-loop for(iterator<type> iter = expression.iterator(); iter.hasnext();){ Type name = iter.next(); loop_statement for(iterator<position<e>> iter = positions.iterator(); iter.hasnext();){ Position<E> pos = iter.next(); System.out.println(pos.element()); for (Position<E> pos: positions) System.out.println(pos.element()); for(type name : expression){ loop_statement

49 For-each-loop Attenzione: per poter usare il for-each-loop è necessario utilizzare le interfacce java.lang.iterable e java.util.iterator

50 Ritorniamo al nostro esercizio Uso del metodo positions() e del for-each-loop Scrivere un metodo public static void remove (PositionList<Integer> L, Integer i) che rimuova da una lista L di interi tutte le occorrenze dell'intero i.

51 Ritorniamo al nostro esercizio Soluzione con il for-each-loop public static void remove(positionlist<integer> L, Integer i){ for (Position<Integer> p : L.positions()) if (p.element().equals(i)) L.remove(p); public static void main(string[] args) { PositionList<Integer> L1 = new NodePositionList<Integer>();... remove(l1,1); for (Integer i : L1) System.out.print(i+" ");