linkedlist remove almost done

Author: Ram swaroop

src/me/ramswaroop/common/LinkedList.java

@@ -95,6 +95,7 @@ public interface LinkedList<E> {
      * Retrieves and removes the head (first element) of this list.
      *
      * @return
+     * @throws java.util.NoSuchElementException if this list is empty
      */
     E remove();
 

src/me/ramswaroop/linkedlists/SingleLinkedList.java

@@ -2,6 +2,8 @@
 
 import me.ramswaroop.common.LinkedList;
 
+import java.util.NoSuchElementException;
+
 import static java.lang.System.out;
 
 /**
@@ -19,9 +21,9 @@ public class SingleLinkedList<E> implements LinkedList<E> {
     @Override
     public boolean add(E item) {
         Node<E> newNode = new Node<>(item, null);
-        if (head == null) {
+        if (head == null) { // list empty
             head = newNode;
-        } else {
+        } else { // add to the end of list
             Node<E> curr = head;
             while (curr.next != null) {
                 curr = curr.next;
@@ -39,23 +41,19 @@ public boolean add(int index, E item) {
         if (index == 0) { // add at first
             addFirst(item);
         } else { // add at any other location
-            Node<E> curr = head;
-            int i = 0;
-            while (i < index - 1) {
-                curr = curr.next;
-                i++;
-            }
-            Node<E> newNode = new Node<>(item, curr.next);
-            curr.next = newNode;
+            Node<E> nodeAtPrevIndex = getPredecessorNode(index);
+            Node<E> newNode = new Node<>(item, nodeAtPrevIndex.next);
+            nodeAtPrevIndex.next = newNode;
+            size++;
         }
-        size++;
         return true;
     }
 
     @Override
     public void addFirst(E item) {
         Node<E> newNode = new Node<>(item, head);
         head = newNode;
+        size++;
     }
 
     @Override
@@ -80,29 +78,35 @@ public boolean contains(E item) {
 
     @Override
     public E get(int index) {
-        return null;
+        return getNode(index).item;
     }
 
     @Override
     public E getFirst() {
-        return null;
+        return head.item;
     }
 
     @Override
     public E getLast() {
-        return null;
+        return getNode(size - 1).item;
     }
 
     @Override
     public E remove() {
+        isLinkedListEmpty();
+
         E item = head.item;
         head = head.next;
         return item;
     }
 
     @Override
     public E remove(int index) {
-        return null;
+        isIndexOutOfBounds(index);
+
+        Node<E> prevNode = getPredecessorNode(index);
+        prevNode.next = prevNode.next.next;
+        return prevNode.next.item;
     }
 
     @Override
@@ -112,7 +116,11 @@ public boolean remove(E item) {
 
     @Override
     public E set(int index, E item) {
-        return null;
+        isIndexOutOfBounds(index);
+
+        Node<E> node = getNode(index);
+        node.item = item;
+        return node.item;
     }
 
     @Override
@@ -135,7 +143,7 @@ public void printList() {
         out.println(curr.item + "]");
     }
 
-    private Node<E> getNode(int index) {
+    private Node<E> getPredecessorNode(int index) {
         isIndexOutOfBounds(index);
 
         Node<E> curr = head;
@@ -147,6 +155,24 @@ private Node<E> getNode(int index) {
         return curr;
     }
 
+    private Node<E> getNode(int index) {
+        isIndexOutOfBounds(index);
+
+        Node<E> curr = head;
+        int i = 0;
+        while (i < index) {
+            curr = curr.next;
+            i++;
+        }
+        return curr;
+    }
+
+    private void isLinkedListEmpty() {
+        if (head == null) {
+            throw new NoSuchElementException("LinkedList empty");
+        }
+    }
+
     private void isIndexOutOfBounds(int index) {
         if (index < 0 && index > size) {
             throw new IndexOutOfBoundsException("Index must be less than or equal to: " + size);