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.