java - pilas - Implementación de pila para nodos que contienen objetos

pilas y colas en java ejemplos

Question

Tengo un LinkedList de Nodes que contienen objetos enteros.

LinkedList listOfInts = new LinkedList();

Y añado los Objects ;

list.add(new Integer(8));
list.add(new Integer(5));
list.add(new Integer(3));
list.add(new Integer(4));

con la siguiente clase de Node :

class Node {
private Object data;
private Node next;
public Node(Object data)
{
this.data = data;
this.next = next;
}
public Object getData()
{
return data;
}
public Node getNext()
{
return next;
}
public void setNext(Node next)
{
this.next = next;
}
}

Si hago algo como tal;

Node p = listOfInts.pop()

Y luego imprime los datos,

System.out.println(p.getData());

Obtengo la respuesta correcta: 8.

Pero si quiero insertar este número en una nueva LinkedList ;

LinkedList newStack = new LinkedList();
newStack.push(p);

Impulsa toda la lista de elementos, no solo el primer punto de datos, 8.

 [8,5,3,4];

Mi pregunta es por qué sucede esto? Dado que este es un problema tan básico, supongo que tiene que ver con mis métodos push() y pop() , pero como los escribí de manera similar a los que he visto en los libros de texto, no sé qué les pasa. ¿Alguien podría ayudarme a entender?

public Node pop()
{
Node item = peek(); //save item to return
if(!isEmpty())
{
first = first.getNext(); //delete first node
}
size--;
return item; //return first saved item
}
public void push(Node item)
{
Node next = item.getNext();
next = first;
first = item;
size++;
}
public Node peek()
{
if (isEmpty())
{
System.out.println("Error: No element");
}
return first;
}

EDITAR: hizo lo sugerido con la devolución de objetos en lugar de Nodes , y el código es más o menos el mismo excepto para el método push() . Por lo tanto, cuando intento agregar otro objeto a la misma LinkedList , reemplaza la anterior en lugar de agregarla a la lista.

 //push node on top of the stack
public void push(Object item)
{
Node newNode = new Node(item);
Node next = newNode.getNext();
next = first;
first = newNode;
size++;
}//push

Answer 1

Su implementación devuelve el objeto Node cuando se llama a pop , pero el Node todavía tiene una referencia a la posición "siguiente" dentro de la pila original.

Cuando crea una nueva pila y empuja el elemento reventado, el objeto Node original se encuentra junto a la atracción, con su next referencia original.

listOfInts -----> { 5 } -> { 3 } -> { 4 }
^
newStack -> { 8 } -+

Es por eso que toda la lista aparece en la nueva pila.

La solución no es exponer el objeto Node en absoluto. En lugar de aceptar un Node en push , acepte el elemento de datos y cree su propio Node . En lugar de devolver un Node en un Node y peek , extraiga el elemento de datos del Node y devuélvalo. De esta forma, no se arriesga inadvertidamente a filtrar la referencia al siguiente Node en el nodo deseado.