title: How to delete the current node in a singly linked list?
body: <p>I am trying to finish a program and I'm caught at a spot. My deleteCurrentNode method only partially works. For some reason when I try to traverse the linked list to find the currentNode it never finds it. Can someone provide me with a tip of how to get it to work?</p>
  
  <p>The method itself checks 4 conditions: </p>
  
  <ol>
  <li>If the list is empty. </li>
  <li>If currentNode is null. </li>
  <li>If the currentNode is the first node in the list. </li>
  <li>If currentNode is somewhere in the list.</li>
  </ol>
  
  <p>The other conditions work (to my knowledge). 4 is where the issue is. </p>
  
  <pre><code>public class LinkedList 
  {
  private Node currentNode;
  private Node firstNode;
  private int nodeCount;
  
  public static void main(String[] args)
   {
   LinkedList test;
   String dataTest;
   test = new LinkedList();
   dataTest = "abcdefghijklmnopqrstuvwxyz";
   for(int i=0; i&lt; dataTest.length(); i++) { test.insert(new String(new char[] { dataTest.charAt(i) }));  }
   System.out.println("[1] "+ test);
  
    for(int i=0; i&lt; dataTest.length(); i++) { test.deleteCurrentNode(); }
    System.out.println("[2] "+test);
  
    for(int i=0; i&lt; dataTest.length(); i++)
    {
    test.insertBeforeCurrentNode(new String(new char[] { dataTest.charAt(i) }));
     if(i%2 == 0) { test.first(); } else { test.last(); }
    }
  
    System.out.println("[3] "+test);
  
    for(int i=0; i&lt; dataTest.length(); i++) { test.last(); test.deleteCurrentNode(); }
        System.out.println("[4] "+test);
  
  
        for(int i=0; i&lt; dataTest.length(); i++) { test.insert(new String(new char[] { dataTest.charAt(i) })); test.last(); }
        System.out.println("[5] "+test);
  
      while(!test.isEmpty()) { test.deleteFirstNode(); }
      System.out.println("[6] "+test);
  
     for(int i=0; i&lt; dataTest.length(); i++) { test.insert(new String(new char[] { dataTest.charAt(i) })); test.last(); }
    System.out.println("[7] "+test);
  
     while(!test.isEmpty()) { test.deleteFirstNode(false); }
     System.out.println("[8] "+test);
  
     for(int i=0; i&lt; dataTest.length(); i++) { test.insertBeforeCurrentNode(new String(new char[] { dataTest.charAt(i) })); test.first(); }
     System.out.println("[9] "+test);
   }
  
  public LinkedList()
  {
      setListPtr(null);
      setCurrent(null);
      nodeCount = 0;
  }
  
  public boolean atEnd()
  {
      //checkCurrent();
      return getCurrent().getNext() == null;      
  }
  
  public boolean isEmpty()
  {
      return getListPtr() == null;
  }
  
  public void first()
  {
      setCurrent(getListPtr());
  }
  
  public void next()
  {
      checkCurrent();
      if (atEnd()) {throw new InvalidPositionInListException("You are at the end of the list. There is no next node. next().");}
      setCurrent(this.currentNode.getNext());
  }
  
  public void last()
  {
      if (isEmpty()) {throw new ListEmptyException("The list is currently empty! last()");}
  
      while (!atEnd())
      {
          setCurrent(getCurrent().getNext());
      }
  
  }
  
  public Object getData()
  {
      return getCurrent().getData();
  }
  
  public void insertBeforeCurrentNode(Object bcNode) //beforeCurrentNode
  {
      Node current;
      Node hold;
      boolean done;
      hold = allocateNode();
      hold.setData(bcNode);
      current = getListPtr();
      done = false;
      if (isEmpty())
      {
          setListPtr(hold);
          setCurrent(hold);       
      }
  
      else if (getCurrent() == getListPtr())
      {
      //  System.out.println("hi" + hold);
          hold.setNext(getCurrent());
          setListPtr(hold);
      }
  
      else if (!isEmpty() &amp;&amp; getCurrent() != getListPtr())
      {
          while (!done &amp;&amp; current.getNext() != null)
          {
              //System.out.println("in else if " + hold);
              if (current.getNext() == getCurrent())
              {
                  //previous.setNext(hold);
                  //System.out.println("hi"+ "yo" + " " + getListPtr());
                  hold.setNext(current.getNext());
                  current.setNext(hold);
                  done = true; 
              }
  
              //previous = current;
              current = current.getNext();
          }
  
      }
      //System.out.println("current " + getCurrent());
      //System.out.println("pointer " + getListPtr());
  
  }
  
  public void insertAfterCurrentNode(Object acNode) //afterCurrentNode
  {
      Node hold;
      hold = allocateNode();
      hold.setData(acNode);
      if (isEmpty())
      {
          setListPtr(hold);
          setCurrent(hold);
          //System.out.println(hold + " hi");
      }
  
      else 
      {
          //System.out.println(hold + " hia");
          hold.setNext(getCurrent().getNext());
          getCurrent().setNext(hold);
      }
  }
  
  public void insert(Object iNode)
  {
      insertAfterCurrentNode(iNode);
  }
  
  public Object deleteCurrentNode()
  {
      //System.out.println("in delete current");
      Object nData;
      Node previous;
  
      if (isEmpty()) {throw new ListEmptyException("The list is currently empty! last()");} //if list is empty throw exception
  
      checkCurrent(); //check if currentNode is null, method throws exception if it is.
  
      nData = getCurrent().getData();
  
      if (getCurrent() == getListPtr())
      {
          setListPtr(getCurrent().getNext());
          setCurrent(getCurrent().getNext());
          nodeCount = nodeCount -1;
      }
  
      else 
      {
          previous = getListPtr();
          while (previous.getNext() != getCurrent())
          {
              previous = previous.getNext();
              //System.out.println("test"+ previous);
          }
  
  
          if (getCurrent().getNext() != null)
          {
              previous.setNext(null);
          }
  
          previous.setNext(getCurrent().getNext());       }
  
      return nData;
  }
  
  public Object deleteFirstNode(boolean toDelete)
  {
      if (toDelete)
      {
          setListPtr(null);
      }
      return getListPtr();
  }
  
  public Object deleteFirstNode()
  {
      Object deleteFirst;
      deleteFirst = deleteFirstNode(true);
      return deleteFirst;
  }
  
  public int size()
  {
      return this.nodeCount;
  }
  
  public String toString()
  {
      String nodeString;
      Node sNode;
      sNode = getListPtr();
      //System.out.println(nodeCount);
      nodeString = ("List contains " + nodeCount + " nodes");
      while (sNode != null)
      {
          nodeString = nodeString + " " +sNode.getData();
          sNode = sNode.getNext();
      }   
      return nodeString;
  }
  
  private Node allocateNode()
  {
      Node newNode;
      newNode = new Node();
      nodeCount = nodeCount + 1;
      return newNode;
  }
  
  private void deAllocateNode(Node dNode)
  {
      dNode.setData(null);
  }
  
  private Node getListPtr()
  {
      return this.firstNode;
  }
  
  private void setListPtr(Node pNode)
  {
       this.firstNode = pNode;
  }
  
  private Node getCurrent()
  {
      return this.currentNode;
  }
  
  private void setCurrent(Node cNode)
  {
      this.currentNode = cNode;
  }
  
  private void checkCurrent()
  {
      if (getCurrent() == null) {throw new InvalidPositionInListException("Current node is null and is set to an invalid position within the list! checkCurrent()");}
  }
  
  /**NODE CLASS ----------------------------------------------*/
  
      private class Node 
      {
          private Node next; //serves as a reference to the next node 
          private Object data;
  
          public Node()
          {
              this.next = null;
              this.data = null;
          }
  
  
          public Object getData()
          {
              return this.data;
          }
  
          public void setData(Object obj)
          {
              this.data = obj;
          }
  
          public Node getNext()
          {
              return this.next;
          }
  
          public void setNext(Node nextNode)
          {
              this.next = nextNode;
          }
  
          public String toString()
          {
              String nodeString;
              Node sNode;
              sNode = getListPtr();
              //System.out.println(nodeCount);
              nodeString = ("List contains " + nodeCount + " nodes");
              while (sNode != null)
              {
                  nodeString = nodeString + " " +sNode.getData();
                  sNode = sNode.getNext();
              }   
              return nodeString;
          }
      }
  
  
   }
  </code></pre>
  
  <p>[4] should read the same as [2] (List contains 0 nodes.) </p>
  
  <p>Note: Cannot use any more variables/methods/etc that I already have. And I cannot use head nodes.</p>