删除/撤销双向链表中的唯一节点

Question

My code undos the added elements one by one starting with the latest add. It does everything correctly unless there is only one node left in a list and my code does not undo/remove it from the list. For example:

[A, B, C, D, E] //call undo()
[A, B, C, D] //call undo()
[A, B, C] //call undo()
[A, B] //call undo()
[A] //call undo() and it throws Exception here <------------------
Exception in thread "main" java.lang.NullPointerException

If I undo [A] it should return empty list [] . NOTE: I HAVE TO USE A DUMMY NODE called beginMarker and endMarker which have a value of null , so the last element looks like this:

beginMarker <-> "A" <-> endMarker

For the last element, the code checks if the size equals to 1 and it's true and proceeds further but does not empty out the list. Any help would be appreciated!

 public void add(x){
         .........
         undoStack.push(newNode);
    }
    public void undo(){
            if(undoStack.isEmpty()){
                throw new RuntimeException("Undo history is empty");
            }
            else{
                Node<T> object = undoStack.topAndPop();

                redoStack.push(object);
                if(this.size() == 1){
                    beginMarker = object.next;
                    beginMarker.next = null;
                    //beginMarker.next = null;
                }

                if(object.prev == beginMarker){
                    beginMarker.next = object.next.prev;
                    object.next.prev = beginMarker;
                }

                else if(object.next == null){
                    object.prev.next = null;
                }
                else{
                    object.next.prev = object.prev;
                    object.prev.next = object.next;
                }





                theSize--;
                modCount--;
                countUndone++;
}

Class SimpleStack

public class SimpleStack<AnyType>{

  // Tracks the top node of stack.
  private Node<AnyType> topOfStack;

  // Construct the stack.
  public SimpleStack( ) {
    topOfStack = null;
  }

  // Test if the stack is logically empty.
  // @return true if empty, false otherwise.
  public boolean isEmpty( ) {
    return topOfStack == null;
  }

  // Make the stack logically empty.
  public void clear( ) {
    topOfStack = null;
  }

  // Insert a new item into the stack.
  // @param x the item to insert.
  public void push( AnyType x ) {
    topOfStack = new Node<AnyType>( x, topOfStack );
  }

  // Remove the most recently inserted item from the stack.
  // @throws UnderflowException if the stack is empty.
  public void pop( ) {
    if( isEmpty( ) )
      throw new RuntimeException( "SimpleStack pop" );
    topOfStack = topOfStack.next;
  }

  // Get the most recently inserted item in the stack.
  // Does not alter the stack.
  // @return the most recently inserted item in the stack.
  // @throws UnderflowException if the stack is empty.
  public AnyType getTop( ) {
    if( isEmpty( ) )
      throw new RuntimeException( "SimpleStack empty in getTop" );
    return topOfStack.data;
  }

  // Return and remove the most recently inserted item
  // from the stack.
  // @return the most recently inserted item in the stack.
  // @throws UnderflowException if the stack is empty.
  public AnyType topAndPop( ) {
    if( isEmpty( ) )
      throw new RuntimeException( "SimpleStack empty in topAndPop" );

    AnyType topItem = topOfStack.data;
    topOfStack = topOfStack.next;
    return topItem;
  }

  // A singly linked Node which contains data and a link to another
  public class Node<T>{
    public T data;
    public Node<T> next;

    public Node(T d, Node<T> n ){
      this.data = d;
      this.next = n;
    }
  }

}

Answer 1

I would not be surprised the NPE occurs here :

if(object.prev == beginMarker){
    beginMarker.next = object.next.prev; 
    //                             ^^^^ 
    //                             is it here ? object.next is null in your case
    object.next.prev = beginMarker;
}

It should fix it to simply write

if(object.prev == beginMarker && object.next != null) {
    beginMarker.next = object.next.prev;
    object.next.prev = beginMarker;
}

However, you don't really have to particularize the case size() == 1 . A simpler implementation would be (assuming you add a pointer to the end of the list) :

public void undo() {
    if (undoStack.isEmpty()) {
        throw new NoSuchElementException("Undo history is empty");
    } else {
        Node<T> object = undoStack.topAndPop();
        redoStack.push(object);

        object.prev.next = object.next;
        object.next.prev = object.prev;

        theSize--;
        modCount--;
        countUndone++;
    }
}

This should work since using an endMarker will prevent you from having any null node in the list.