ecco la classe Lista:
codice:
package liste.puntatori.circolari;
import liste.ListaA;
import liste.Posizione;
/**
* Lista con doppi puntatori circolare
* @author Prete Cosimo Damiano, Galiandro Rosita
*/
public class Lista<T> extends ListaA<T>{
private NodoPuntatore lista;
/**
* Costruttore (la sentinella punta a se stessa)
*/
public Lista(){
lista=new NodoPuntatore();
lista.setPrecedente(lista);
lista.setSuccessivo(lista);
}
/**
* Controlla se la lista è vuota o meno
* @return true se la lista è vuota, false altrimenti
*/
@Override
public boolean listaVuota() {
return lista.getPrecedente()==lista && lista.getSuccessivo()==lista;
}
/**
* Permette di conoscere un elemento della lista data la sua posizione
* @param posizione la posizione dell'elemento cercato (dev'essere di tipo NodoPuntatore)
* @return l'informazione del nodo se la posizione è valida, null altrimenti
*/
@Override
public T leggiLista(Posizione posizione) {
if(istanzaPosizione(posizione)){
return (T)((NodoPuntatore)posizione).getInfo();
}
return null;
}
/**
* Inserisce il dato elem alla posizione posizione eventualmente sovrascrivendo il precedente
* @param elem l'elemento da inserire
* @param posizione la posizione in cui inserire l'elemento (dev'essere di tipo NodoPuntatore)
*/
@Override
public void scriviLista(T elem, Posizione posizione) {
if(istanzaPosizione(posizione)){
((NodoPuntatore)posizione).setInfo(elem);
size++;
}
}
/**
* Ritorna la prima posizione della lista
* @return la prima posizione della lista, cioè il nodo successivo alla lista stessa
*/
@Override
public Posizione primoLista() {
return lista.getSuccessivo();
}
/**
* Controlla che si sia raggiunta la fine della lista
* @param posizione la posizione per cui fare il controllo (dev'essere di tipo NodoPuntatore)
* @return true se si è arrivati alla fine, false altrimenti
*/
@Override
public boolean fineLista(Posizione posizione) {
if(istanzaPosizione(posizione)){
return posizione.equals(lista);
}
return false;
}
/**
* Permette di conoscere la posizione successiva data una certa posizione
* @param posizione la posizione per cui calcolare la successiva (dev'essere di tipo NodoPuntatore)
* @return la nuova posizione, o la stessa d'ingresso se non valida
*/
@Override
public Posizione succLista(Posizione posizione) {
return istanzaPosizione(posizione)?((NodoPuntatore)posizione).getSuccessivo():posizione;
}
/**
* Permette di conoscere la posizione precedente data una certa posizione
* @param posizione la posizione per cui calcolare la precedente (dev'essere di tipo NodoPuntatore)
* @return la nuova posizione, o la stessa d'ingresso se non valida
*/
@Override
public Posizione predLista(Posizione posizione) {
return istanzaPosizione(posizione)?((NodoPuntatore)posizione).getPrecedente():posizione;
}
/**
* Inserisce l'elemento elem alla posizione posizione della lista, eventualmente ricombinando i collegamenti con gli altri nodi
* @param elem l'elemento da inserire
* @param posizione la posizione in cui inserire l'elemento (dev'essere di tipo NodoPuntatore)
*/
@Override
public void insLista(T elem, Posizione posizione) {
if(istanzaPosizione(posizione)){
NodoPuntatore p=(NodoPuntatore)posizione;
NodoPuntatore tmp=new NodoPuntatore(elem);
tmp.setPrecedente(p.getPrecedente());
tmp.setSuccessivo(p);
p.getPrecedente().setSuccessivo(tmp);
p.setPrecedente(tmp);
size++;
}
}
/**
* Cancella l'elemento della lista in una data posizione
* @param posizione la posizione dell'elemento da cancellare (dev'essere di tipo NodoPuntatore)
*/
@Override
public void cancLista(Posizione posizione) {
if(istanzaPosizione(posizione)){
NodoPuntatore p=(NodoPuntatore)posizione;
p.getSuccessivo().setPrecedente(p.getPrecedente());
p.getPrecedente().setSuccessivo(p.getSuccessivo());
size--;
}
}
/**
* Controlla che la posizione sia un'instanza della classe NodoPosizione
* @param posizione la posizione da controllare
* @return true se posizione è di classe NodoPuntatore, false altrimenti
*/
@Override
protected boolean istanzaPosizione(Posizione posizione) {
return posizione instanceof NodoPuntatore;
}
}
e la classe NodoPuntatore:
codice:
package liste.puntatori.circolari;
import liste.Nodo;
import liste.Posizione;
/**
* Classe usata per gestire l'informazione nella lista con doppi puntatori
* @author Prete Cosimo Damiano, Galiandro Rosita
*/
public class NodoPuntatore<T> extends Nodo<T> implements Posizione{
private NodoPuntatore prec, succ;
/**
* Costruttore vuoto
*/
public NodoPuntatore(){}
/**
* Costruttore
* @param dato il dato da memorizzare nel nodo
*/
public NodoPuntatore(T dato){
super(dato);
}
/**
* Costruttore
* @param d il dato da memorizzare nel nodo
* @param p il nodo precedente
* @param s il nodo successivo
*/
public NodoPuntatore(T d, NodoPuntatore p, NodoPuntatore s){
this(p, s);
setInfo(d);
}
/**
* Costruttore
* @param p la posizione precedente
* @param s la posizione successiva
*/
public NodoPuntatore(NodoPuntatore p, NodoPuntatore s){
setPrecedente(p);
setSuccessivo(s);
}
/**
* Imposta un nuovo successivo al nodo
* @param s il nodo con cui rimpiazzare il nodo successivo
*/
public void setSuccessivo(NodoPuntatore s){
succ=s;
}
/**
* Imposta un nuovo precedente al nodo
* @param p il nodo con cui rimpiazzare il nodo precedente
*/
public void setPrecedente(NodoPuntatore p){
prec=p;
}
/**
* Permette di conoscere il nodo successivo
* @return il nodo successivo
*/
public NodoPuntatore getSuccessivo(){
return succ;
}
/**
* Permette di conoscere il nodo precedente
* @return il nodo precedente
*/
public NodoPuntatore getPrecedente(){
return prec;
}
}
Come dicevo in qualche messaggio precedente, i metodi che non fanno esattamente il loro lavoro sono l'insLista e il cancLista per i problemi suddetti.
Questi sono i corrispettivi metodi in C++:
codice:
template<_class_T_>_void_circLista<_T_>::insLista(tipoelem_a,_Lista::posizione_&p){
__Lista::posizione_temp;
__temp_=_new_Cella;
__temp_>setElemento(a);
__temp_>setPrec(p_>getPrec());
__temp_>setSucc(p);
__(p_>getPrec())_>setSucc(temp);
__p_>setPrec(temp);
__p=temp;
}
codice:
template<_class_T_>_void_circLista<_T_>::cancLista(Lista::posizione_&p){
__Lista::posizione_temp;
__temp=p;
__(p_>getSucc())_>setPrec(p_>getPrec());
__(p_>getPrec())_>setSucc(p_>getSucc());
__p=p_>getSucc();
__delete(temp);
}
Spero ora possiate aiutarmi ^^
Rispondi quotando
