Ho un problema con un esercizio in Java.
Questo è il testo.
Scrivere un metodo statico che riceve una pila di oggetti e ne inverte l'ordine.
Il metodo non deve usare array o altre strutture dati, ma soltanto pile.
Si noti che il metodo non deve restituire una nuova pila, ma deve modificare il contenuto della pila ricevuta come parametro esplicito.
Per collaudare il corretto funzionamento del metodo, scrivere un programma che
* legge dallo standard input un insieme (di dimensione non predeterminata) di numeri interi, in formato libero (cioè anche più numeri su una stessa riga, separati da spazi), inserendoli in una pila
* invoca il metodo appena progettato
* visualizza sullo standard output i numeri dell'insieme, uno per riga, estraendoli dalla pila
La realizzazione più semplice prevede l'utilizzo di due pile come spazio di memorizzazione temporaneo.
Queste sono le classi fornite.
public interface Container
{ boolean isEmpty();
int size();
}
public interface Stack extends Container
{ void push(Object obj);
Object pop();
Object top();
}
public class ArrayStack implements Stack
{ protected Object[] v;
protected int vSize;
public ArrayStack()
{ v = new Object[100];
vSize = 0;
}
public int size()
{ return vSize;
}
public boolean isEmpty()
{ return (vSize == 0);
}
public void push(Object obj)
{ if (vSize == v.length)
v = resize(v, 2*vSize);
v[vSize++] = obj;
}
public Object top()
{ if (isEmpty())
throw new EmptyStackException();
return v[vSize - 1];
}
public Object pop()
{ Object obj = top();
v[--vSize] = null;
return obj;
}
private Object[] resize(Object[] oldArray, int newLength)
{ Object[] newArray = new Object[newLength];
System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
return newArray;
}
}
Queste invece sono quelle che ho progettato io.
public class ReverseStackUsingTwoStacks
{
public static void reverse(ArrayStack objStack)
{
ArrayStack temp=new ArrayStack();
ArrayStack temp2=new ArrayStack();
while(!objStack.isEmpty())
{
temp.push(objStack.pop());
}
while(!temp.isEmpty())
{
temp2.push(temp.pop());
}
while(!temp2.isEmpty())
{
objStack.push(temp2.pop());
}
}
}
import java.util.Scanner;
public class ReverseStackUsingTwoStacksTester
{
public static void main(String[] args)
{
Scanner console=new Scanner(System.in);
ArrayStack a=new ArrayStack();
System.out.println("Inserisci una pila di numeri interi:");
while(console.hasNextInt())
{
a.push(new Integer(console.nextInt()));
}
ReverseStackUsingTwoStacks.reverse(a);
while(!a.isEmpty())
{
System.out.println((Integer) a.pop());
}
}
}
L'output che ricevo è uguale all'input, come se non invertisse l'ordine dei dati.
Mettendo però, qualche riga di codice per visualizzare l'output in ReverseStackUsingTwoStacks ottengo il risultato desiderato
Spero non sia troppo confuso e che possiate aiutarmi.
Rispondi quotando
