ADT Lista

Liste concatenate
Implementazione della coda con liste concatenate
head (front della coda)
tail (rear della coda)
Ø
e
y
a
x
v
il front della coda è memorizzato nel primo nodo (head) della lista
il rear della coda è memorizzato nell’ultimo nodo (tail) della lista
Strutture Dati
ADT Coda
Implementazione con liste concatenate
public class NodeQueue<E> implements Queue<E>{
protected Node<E> head, tail; // the head and tail nodes
protected int size;
/** Creates an empty queue. */
public NodeQueue() {
head = null;
tail = null;
size = 0;
}
public int size() {
return size;
}
//# Return the current queue size
public boolean isEmpty() { //# Returns true iff queue is empty
if ( (head==null) && (tail==null) )
return true;
return false;
}
...
Strutture Dati
ADT Coda
Implementazione con liste concatenate
...
public void enqueue(E elem) {
Node<E> node = new Node<E>();
node.setElement(elem);
node.setNext(null); // node will be new tail node
if (size == 0)
head = node; // special case of a previously empty queue
else
tail.setNext(node); // add node at the tail of the list
tail = node; // update the reference to the tail node
size++;
}
public E front()
//# Return the first queue element
throws EmptyQueueException {
if (size == 0)
throw new EmptyQueueException("Queue is empty.");
return head.getElement();
}
...
Strutture Dati
ADT Coda
Implementazione con liste concatenate
...
public E dequeue() throws EmptyQueueException {
if (size == 0)
throw new EmptyQueueException("Queue is empty.");
E tmp = head.getElement();
head = head.getNext();
size--;
if (size == 0)
tail = null; // the queue is now empty
return tmp;
}
}
Strutture Dati
La lista di nodi (Node List)
Il concetto di posizione
La lista di nodi (node list) è un contenitore di oggetti che:
memorizza ciascun elemento in una posizione
mantiene le posizioni degli oggetti in un ordinamento lineare
il concetto di posizione formalizza l'idea di posto di un elemento
La posizione non è altro che il nome che permette di riferirsi
all'elemento ad essa associato
Strutture Dati
La lista di nodi (Node List)
Il concetto di posizione
Attenzione: la posizione è associata sempre allo stesso elemento
posizione L
Strutture Dati
La lista di nodi (Node List)
Il concetto di posizione
Attenzione: la posizione è associata sempre allo stesso elemento
posizione L
non cambia mai, neanche in seguito a inserimenti
Strutture Dati
La lista di nodi (Node List)
Il concetto di posizione
Attenzione: la posizione è associata sempre allo stesso elemento
posizione L
non cambia mai, neanche in seguito a inserimenti o cancellazioni
Strutture Dati
La lista di nodi (Node List)
Il concetto di posizione
Attenzione: la posizione è associata sempre allo stesso elemento
posizione L
Morale: continueremo a riferirci allo stesso elemento con la stessa posizione
Strutture Dati
La lista di nodi (Node List)
La posizione come tipo astratto di dati
La posizione definisce essa stessa un tipo astratto di dati che supporta il
seguente unico metodo:
element(): Restituisce l'elemento in questa posizione
Strutture Dati
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
Strutture Dati
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
Strutture Dati
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
Strutture Dati
Il tipo astratto di dati Node List
L'interfaccia Position
package position;
public interface Position<E> {
E element();
}
Strutture Dati
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);
...
}
Strutture Dati
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;
}
Strutture Dati
Il tipo astratto di dati Node List
Implementazione basata su liste dopp. concatenate
header
Liste doppiam.
concatenate
NODI
trailer
ADT Lista
POSIZIONI
I nodi della lista doppiamente concatenata implementano le posizioni dell'ADT node list
Strutture Dati
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; }
}
Strutture Dati
Il tipo astratto di dati Node List
Implementazione di addAfter
Algorithm addAfter(p,e):
posizione p
header
trailer
A
Strutture Dati
B
C
Il tipo astratto di dati Node List
Implementazione di addAfter
Algorithm addAfter(p,e):
Crea un nuovo nodo v
posizione p
header
trailer
A
Strutture Dati
B
C
Il tipo astratto di dati Node List
Implementazione di addAfter
Algorithm addAfter(p,e):
Crea un nuovo nodo v
v.setElement(e)
posizione p
header
trailer
A
B
e
Strutture Dati
C
Il tipo astratto di dati Node List
Implementazione di addAfter
Algorithm addAfter(p,e):
Crea un nuovo nodo v
v.setElement(e)
v.setPrev(p)
posizione p
header
trailer
A
B
e
Strutture Dati
C
Il tipo astratto di dati Node List
Implementazione di addAfter
Algorithm addAfter(p,e):
Crea un nuovo nodo v
v.setElement(e)
v.setPrev(p)
v.setNext(p.getNext())
posizione p
header
trailer
A
B
e
Strutture Dati
C
Il tipo astratto di dati Node List
Implementazione di addAfter
Algorithm addAfter(p,e):
Crea un nuovo nodo v
v.setElement(e)
v.setPrev(p)
v.setNext(p.getNext())
(p.getNext()).setPrev(v)
posizione p
header
trailer
A
B
e
Strutture Dati
C
Il tipo astratto di dati Node List
Implementazione di addAfter
Algorithm addAfter(p,e):
Crea un nuovo nodo v
v.setElement(e)
v.setPrev(p)
v.setNext(p.getNext())
(p.getNext()).setPrev(v)
p.setNext(v)
posizione p
header
trailer
A
B
e
Strutture Dati
C
Il tipo astratto di dati Node List
Implementazione di remove
Algorithm remove(p):
posizione
p.getPrev()
posizione p
posizione
p.getNext()
header
trailer
A
Strutture Dati
B
C
D
Il tipo astratto di dati Node List
Implementazione di remove
Algorithm remove(p):
temp := p.element
(p.getPrev()).setNext(p.getNext())
posizione
p.getPrev()
posizione p
posizione
p.getNext()
header
trailer
A
Strutture Dati
B
C
D
Il tipo astratto di dati Node List
Implementazione di remove
Algorithm remove(p):
temp := p.element
(p.getPrev()).setNext(p.getNext())
(p.getNext()).setPrev(p.getPrev())
posizione
p.getPrev()
posizione p
posizione
p.getNext()
header
trailer
A
Strutture Dati
B
C
D
Il tipo astratto di dati Node List
Implementazione di remove
Algorithm remove(p):
temp := p.element
(p.getPrev()).setNext(p.getNext())
(p.getNext()).setPrev(p.getPrev())
p.setPrev( null )
posizione
p.getPrev()
posizione p
posizione
p.getNext()
header
trailer
A
Strutture Dati
Ø
B
C
D
Il tipo astratto di dati Node List
Implementazione di remove
Algorithm remove(p):
temp := p.element
(p.getPrev()).setNext(p.getNext())
(p.getNext()).setPrev(p.getPrev())
p.setPrev( null )
p.setNext( null )
posizione
p.getPrev()
posizione p
posizione
p.getNext()
header
trailer
A
Strutture Dati
Ø
B
Ø
C
D
Il tipo astratto di dati Node List
Implementazione di remove
Algorithm remove(p):
temp := p.element
(p.getPrev()).setNext(p.getNext())
(p.getNext()).setPrev(p.getPrev())
p.setPrev( null )
p.setNext( null )
return temp
posizione
p.getPrev()
posizione p
posizione
p.getNext()
header
trailer
A
Strutture Dati
Ø
B
Ø
C
D
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);
}
...
}
Strutture Dati
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();
}
...
}
Strutture Dati
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");
}
}
...
}
Strutture Dati
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;
}
...
}
Strutture Dati
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);
}
...
}
Strutture Dati
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;
}
...
}
Strutture Dati