Salve ragazzi, sto impazzendo da giorni e giorni con un esercizio ma non riesco a venirne a capo.
Ecco il testo:
codice:Si fornisca un'efficiente implementazione dell'interfaccia StackSet140910<E>, come mostrata nella pagina successiva. La classe rappresenta un insieme ordinato i cui elementi sono semplici stack (classe MStack<E>). Ogni stack dell'insieme è rappresentato dal suo elemento che si trova in cima allo stack. Ogni stack potrà contenere al massimo 50 elementi. L'insieme dovrà essere rappresentato attraverso una lista concatenata e gli stack dell'insieme dovranno essere ordinati in base al loro elemento rappresentante. Uno stack che non contiene alcun elemento dovrà apparire nella lista prima di qualsiasi altro stack (considerarlo come l'elemento più piccolo dell'insieme) La gestione delle eccezioni all'interno delle classi è facoltativa. Realizzare in seguito, mediante il metodo main() della classe, un programma Java che prenda in input un file di testo contenente una sequenza di numeri interi e restituisca in output un file di testo contenente le specifiche della struttura ottenuta dopo l'inserimento di tali numeri a partire da uno StackSet140910 contenente 3 stack vuoti. Il file di input contiene una sequenza di numeri interi, uno per riga. File di output Il file di output dovrà contenere la lista degli elementi contenuti nei tre stack dell'insieme (uno stack per riga), iniziando dagli elementi che si trovano in cima alla struttura. Interfaccia StackSet140910 import java.util.*; public interface StackSet140910<E> extends Iterable<E> { public int stacks (); // ritorna il numero di stack (di tipo MStack<E>) dell'insieme public int items (); // ritorna il numero di elementi (E) dell'insieme public MStack<E> getMin (); /** ritorna il primo stack vuoto dell'insieme. Se non esistono stack vuoti nell'insieme ritorna lo stack con il più piccolo valore in testa */ public E pop (); // effettua il pop sul primo stack dell'insieme public void push (E elem); // effettua il push di un elemento sul primo stack dell'insieme public void addStack (); // aggiunge un nuovo stack vuoto all'insieme public Iterator<E> iterator(); // ritorna un iteratore di tutti gli elementi (di tipo E) // contenuti negli stack dell'insieme }
Ecco invece il mio codice:
codice:import java.io.*; import java.util.*; public class LinkedList<E extends Comparable> { protected NodoL<E> header, trailer; private int size; public LinkedList() { header=new NodoL<E>(null,null,null); trailer=new NodoL<E>(null,header,null); size=0; } public int size() { return size; } public boolean isEmpty() { return (size==0); } //ritorna il primo elemento public NodoL<E> first() { if(isEmpty()) return null; else return header.getNext(); } //ritorna l'ultimo elemento public NodoL<E> last() { if(isEmpty()) return null; else return trailer.getPrev(); } //aggiungo all'inizio public void addFirst(E element) { NodoL<E> newNodo=new NodoL<E>(element,header,header.getNext()); header.getNext().setPrev(newNodo);//quello che era il successore di header, adesso avrà come predecessore il nuovo nodo header.setNext(newNodo);//imposto il successore di header size++; } //aggiungo alla fine public void addLast(E element) { NodoL<E>newNodo= new NodoL<E>(element,trailer.getPrev(),trailer); trailer.getPrev().setPrev(newNodo);//quello che era il predecessore di trailer, adesso è il predecessore del nuovo nodo trailer.setPrev(newNodo);//imposto il nuovo predecessore di trailer size++; } //se aggiungo in un qualsiasi punto public void add(NodoL<E> node, E element) { NodoL<E> newNodo=new NodoL<E>(element,node.getPrev(),node.getNext()); node.getPrev().setNext(newNodo);//il predecessore del vecchio nodo, avrà come successore il nuovo nodo node.setPrev(newNodo); size++; } //trovo il minimo public E minimo() { NodoL<E>aux=header.getNext(); NodoL<E>min=aux; while(aux!=null) { if(aux.getElement().compareTo(min.getElement())<0) aux=min; aux=aux.getNext(); } return min.getElement(); } //cancello un nodo public void remove(NodoL<E> node) { NodoL<E> prev=node.getPrev(); NodoL<E>next=node.getNext(); prev.setNext(next); next.setPrev(prev); node.setPrev(null); node.setNext(null); size--; } public String toString() { String str=""; NodoL<E>aux=first(); while(aux!=trailer) { str+=aux.getElement()+" "; aux=aux.getNext(); } return str; } } class NodoL<E> { private E element; private NodoL<E>prev; private NodoL<E> next; public NodoL(E element, NodoL<E> prev, NodoL<E> next) { this.element=element; this.next=next; this.prev=prev; } public E getElement() { return element; } public void setElement(E element) { this.element=element; } public NodoL<E> getPrev() { return prev; } public void setPrev(NodoL<E> prev) { this.prev=prev; } public NodoL<E> getNext() { return next; } public void setNext(NodoL<E> next) { this.next=next; } }
codice:import java.io.*; import java.util.*; public class MStack<E> { protected int capacità;//effettiva capacità dell'array public static final int maxCapacità=50;//numero massimo di elementi che può contenere private E[]set;//array per implementare lo stack private int top;//indice dell'elemento in cima allo stack public MStack() { this(maxCapacità);//capacità di default } public MStack(int cap) { capacità=cap; set=(E[]) new Object[capacità]; top=0; } public boolean isEmpty() { return(top==0); } public int size() { return(top+1); } //cancello dalla cima public E pop() throws EmptyStackException { if(isEmpty()) throw new EmptyStackException("stack vuoto"); else return set[--top]; } //aggiungo in cime public void push(E element) throws FullStackException { if(size()==capacità) throw new FullStackException("stack pieno"); else set[top++]=element; } public E getTop() throws EmptyStackException { if(isEmpty()) throw new EmptyStackException("stack vuoto"); else return set[top]; } }Come devo sistemare questi metodi?non capisco proprio :-(codice:import java.io.*; import java.util.*; public class mioStack<E extends Comparable> implements StackSet140910<E> { private int stacks; private int items; LinkedList<E> lista; public mioStack() { stacks=0; items=0; lista=new LinkedList<E>(); } //ritorna il numero di elementi(di tipo MStack<E>) dell'insieme public int stacks() { return stacks; } //ritorna il numero di elementi di tipo E dell'insieme public int items() { return items; } //ritorna il primo stack vuoto dell'insieme.se non esistono stack vuoti nell'insieme //ritorna lo stack con il più piccolo valore in testa public MStack<E> getMin() { MStack<E> ms=(MStack<E>)lista.first();//QUI MI DA ERRORE if(ms.isEmpty())//se è vuoto... return ms;//lo restituisce...altrimenti faccio un confronto per trovare il minore else return lista.minimo();//QUI MI DA UN ALTRO ERRORE } //effettua il pop sul primo stack dell'insieme public E pop() { E element=lista.first();//QUI MI DA ERRORE lista.remove(element); stacks--; return element; } public void push(E element) { lista.addFirst(element); items++; } }
Rispondi quotando
Capito alla perfezione dove sbagliavo.
erchè il successore del parametro "node" non viene mai coinvolto nell'operazione?
è 4 anni che programmo con gli oggetti, mi mancano due materie per la laurea in informatica ma mi sono bloccata con questa materia e non riesco ad andare avanti
