title: SLinkedList and Node in Java
body: <p>To start with, yes, this is for an assignment in class, but my lack of understanding on how it operates is higher than I want it to be.</p>
  
  <p>We were given 3 classes, they are the following:</p>
  
  <p>SLinkedList.java</p>
  
  <pre><code>package chapter3.linkedList;
  
  public class SLinkedList&lt;V&gt; {
      // instance variables.  Add the tail reference.
      protected Node&lt;V&gt; head, tail;
      protected long size;
  
      // methods, empty list constructor first
      public SLinkedList () {
          head = null;
          tail = null;
          size = 0;
      }  // end constructor of a SLinkedList
  
      // method to add nodes to the list.  Storage space for the node
      // is already allocated in the calling method
      public void addFirst (Node&lt;V&gt; node) {
          // set the tail only if this is the very first node
          if (tail == null)
              tail = node;
          node.setNext (head);    // make next of the new node refer to the head
          head = node;            // give head a new value
  
          // change our size
          size++;
      }  // end method addFirst
  
      // addAfter - add new node after current node, checking to see if we are at the tail
      public void addAfter (Node&lt;V&gt;currentNode, Node&lt;V&gt;newNode) {
          if (currentNode == tail)
              tail = newNode;
          newNode.setNext (currentNode.getNext ());
          currentNode.setNext (newNode);
  
          // change our size
          size++;
      }  // end method addAfter
  
      // addLast - add new node after the tail node.  Adapted from Code Fragment 3.15, p. 118.
      // Mike Qualls
      public void addLast (Node&lt;V&gt; node) {
          node.setNext (null);
          tail.setNext (node);
          tail = node;
          size++;     
      }  // end method addLast
  
      // methods to remove nodes from the list.  (Unfortunately, with a single linked list
      // there is no way to remove last.  Need a previous reference to do that.  (See
      // Double Linked Lists and the code below.)
      public Node&lt;V&gt; removeFirst () {
          if (head == null)
              System.err.println("Error:  Attempt to remove from an empty list");
  
          // save the one to return
          Node&lt;V&gt; temp = head;
  
          // do reference manipulation
          head = head.getNext ();
          temp.setNext(null);
          size--;
  
          return temp;
  
      }  // end method removeFirst
  
      // remove the node at the end of the list.  tail refers to this node, but
      // since the list is single linked, there is no way to refer to the node
      // before the tail node.  Need to traverse the list.
      public Node&lt;V&gt; removeLast () {
          // // declare local variables/objects
          Node&lt;V&gt; nodeBefore;
          Node&lt;V&gt; nodeToRemove;
  
          // make sure we have something to remove
          if (size == 0)
              System.err.println("Error:  Attempt to remove fron an empty list");
  
          // traverse through the list, getting a reference to the node before
          // the trailer.  Since there is no previous reference.
          nodeBefore = getFirst ();
  
          // potential error  ??  See an analysis and drawing that indicates the number of iterations
          // 9/21/10.  size - 2 to account for the head and tail nodes.  We want to refer to the one before the
          // tail.
          for (int count = 0; count &lt; size - 2; count++)
              nodeBefore = nodeBefore.getNext ();
  
          // save the last node
          nodeToRemove = tail;
  
          // now, do the pointer manipulation
          nodeBefore.setNext (null);
          tail = nodeBefore;
          size--;
  
          return nodeToRemove;
  
      }  // end method removeLast
  
      // method remove.  Remove a known node from the list.  No need to search or return a value.  This method
      // makes use of a 'before' reference in order to allow list manipulation.
      public void remove (Node&lt;V&gt; nodeToRemove) {
          // declare local variables/references
          Node&lt;V&gt; nodeBefore, currentNode;
  
          // make sure we have something to remove
          if (size == 0)
              System.err.println("Error:  Attempt to remove fron an empty list");
  
          // starting at the beginning check for removal
          currentNode = getFirst ();
          if (currentNode == nodeToRemove)
              removeFirst ();
          currentNode = getLast ();
          if (currentNode == nodeToRemove)
              removeLast ();
  
          // we've already check two nodes, check the rest
          if (size - 2 &gt; 0) {
              nodeBefore = getFirst ();
              currentNode = getFirst ().getNext ();
              for (int count = 0; count &lt; size - 2; count++) {
                  if (currentNode == nodeToRemove) {
                      // remove current node
                      nodeBefore.setNext (currentNode.getNext ());
                      size--;
                      break;
                  }  // end if node found
  
                  // change references
                  nodeBefore = currentNode;
                  currentNode = currentNode.getNext ();
              }  // end loop to process elements
          }  // end if size - 2 &gt; 0
  
      }  // end method remove
  
      // the gets to return the head and/or tail nodes and size of the list
      public Node&lt;V&gt; getFirst () { return head; }
      public Node&lt;V&gt; getLast () { return tail; }  
      public long getSize () { return size; }
  
  }  // end class SLinkedList
  </code></pre>
  
  <p>Node.java</p>
  
  <p>package chapter3.linkedList;</p>
  
  <pre><code>public class Node&lt;V&gt; {
      // instance variables
      private V element;
      private Node&lt;V&gt; next;
  
      // methods, constructor first
      public Node () {
          this (null, null);      // call the constructor with two args
      }  // end no argument constructor
      public Node (V element, Node&lt;V&gt; next) {
          this.element = element;
          this.next = next;
      }  // end constructor with arguments
  
      // set/get methods
      public V getElement () { return element; }
      public Node&lt;V&gt; getNext () { return next; }
      public void setElement (V element) { this.element = element; }
      public void setNext (Node&lt;V&gt; next) { this.next = next; }
  
  }  // end class Node
  </code></pre>
  
  <p>and GameEntry.java</p>
  
  <pre><code>package Project_1;
  
  public class GameEntry 
  {
      protected String name;  // name of the person earning this score
      protected int score;    // the score value
      /** Constructor to create a game entry */
      public GameEntry(String name, int score) 
      {
        this.name = name;
        this.score = score;
      }
      /** Retrieves the name field */
      public String getName() 
      { 
          return name; 
      }
      /** Retrieves the score field */
      public int getScore() 
      { 
          return score; 
      }
      /** Returns a string representation of this entry */
      public String toString() 
      { 
        return "(" + name + ", " + score + ")"; 
      }
  
  }
  </code></pre>
  
  <p>I've spent the past 3 hours listening to his lecture, reading through the text (Data Structures and Algorithms 5th Edition), and looking through internet forums and youtube videos, but I can't seem to grasp any understanding of how to utilize the node/slinkedlist class.</p>
  
  <p>The object of the assignment is "Write a class that maintains the top 10 scores or a game application, implementing the add and remove methods, but using a single linked list instead of an array.</p>
  
  <p>I don't want someone to do this for me, but I do want to know how to make the linked list.  I know these are NOT that hard, but doing them with this code he's given has become painfully difficult, any help would be really appreciated.</p>
  
  <p>Thank you in advance.</p>
  
  <p>Edit:</p>
  
  <p>My main function: ScoresTest.java</p>
  
  <pre><code>package Project_1;
  
  public class ScoresTest {
  
      /**
       * @param args
       */
      public static void main(String[] args) 
      {
            GameEntry entry;
            Scores highScores = new Scores();     
            entry = new GameEntry("Anna", 600);       
            highScores.add(entry);
            entry = new GameEntry("Paul", 720);
            highScores.add(entry); 
            System.out.println("The Original High Scores");
            System.out.println(highScores);
  
            entry = new GameEntry("Jill", 1150);
            highScores.add(entry);
            System.out.println("Scores after adding Jill");
            System.out.println(highScores);
      }
  
  }
  </code></pre>
  
  <p>This is for the most part exactly how it should end up looking, but it's everything that makes this work that's throwing me off...well...everything dealing with the 3 classes mentioned above, I could do this if they weren't a factor without too much of an issue, they are what's causing my blank.</p>