liknkedlist operations done but not tested

Author: Ram swaroop

src/me/ramswaroop/Main.java

@@ -100,33 +100,56 @@ public static void main(String[] args) {
                         out.println("1. Add");
                         out.println("2. Add at index");
                         out.println("3. Remove");
-                        out.println("4. Print");
-                        out.println("5. Exit module");
+                        out.println("4. Remove at index");
+                        out.println("5. Remove item");
+                        out.println("6. Edit item");
+                        out.println("7. Print");
+                        out.println("8. Exit module");
                         k2 = Integer.parseInt(in.nextLine());
-                        int input, index;
+                        int item, index;
                         switch (k2) {
                             case 1:
                                 out.println("Enter value:");
-                                input = Integer.parseInt(in.nextLine());
-                                singleLinkedList.add(input);
+                                item = Integer.parseInt(in.nextLine());
+                                singleLinkedList.add(item);
                                 singleLinkedList.printList();
                                 break;
                             case 2:
                                 out.println("Enter value:");
-                                input = Integer.parseInt(in.nextLine());
+                                item = Integer.parseInt(in.nextLine());
                                 out.println("Enter index:");
                                 index = Integer.parseInt(in.nextLine());
-                                singleLinkedList.add(index, input);
+                                singleLinkedList.add(index, item);
                                 singleLinkedList.printList();
                                 break;
                             case 3:
                                 out.println("Removed element: " + singleLinkedList.remove());
                                 singleLinkedList.printList();
                                 break;
                             case 4:
+                                out.println("Enter index:");
+                                index = Integer.parseInt(in.nextLine());
+                                out.println("Removed element: " + singleLinkedList.remove(index));
                                 singleLinkedList.printList();
                                 break;
                             case 5:
+                                out.println("Enter value:");
+                                item = Integer.parseInt(in.nextLine());
+                                out.println("Removed: " + singleLinkedList.remove(item));
+                                singleLinkedList.printList();
+                                break;
+                            case 6:
+                                out.println("Enter index to edit:");
+                                index = Integer.parseInt(in.nextLine());
+                                out.println("Enter new value:");
+                                item = Integer.parseInt(in.nextLine());
+                                singleLinkedList.set(index, item);
+                                singleLinkedList.printList();
+                                break;
+                            case 7:
+                                singleLinkedList.printList();
+                                break;
+                            case 8:
                                 continue chooseModule;
                             default:
                                 out.println("Wrong choice!");

src/me/ramswaroop/linkedlists/SingleLinkedList.java

@@ -73,7 +73,7 @@ public LinkedList<E> clone() {
 
     @Override
     public boolean contains(E item) {
-        return false;
+        return getNode(item) == null;
     }
 
     @Override
@@ -83,6 +83,7 @@ public E get(int index) {
 
     @Override
     public E getFirst() {
+        isLinkedListEmpty();
         return head.item;
     }
 
@@ -97,27 +98,41 @@ public E remove() {
 
         E item = head.item;
         head = head.next;
+        size--;
         return item;
     }
 
     @Override
     public E remove(int index) {
-        isIndexOutOfBounds(index);
-
         Node<E> prevNode = getPredecessorNode(index);
-        prevNode.next = prevNode.next.next;
-        return prevNode.next.item;
+        if (prevNode == null) { // index = 0
+            head = head.next;
+            size--;
+            return head.item;
+        } else {
+            prevNode.next = prevNode.next.next;
+            size--;
+            return prevNode.next.item;
+        }
     }
 
     @Override
     public boolean remove(E item) {
-        return false;
+        if (!contains(item)) return false;
+
+        Node<E> prevNode = getPredecessorNode(item);
+        if (prevNode == null) { // index = 0
+            head = head.next;
+            size--;
+        } else {
+            prevNode.next = prevNode.next.next;
+            size--;
+        }
+        return true;
     }
 
     @Override
     public E set(int index, E item) {
-        isIndexOutOfBounds(index);
-
         Node<E> node = getNode(index);
         node.item = item;
         return node.item;
@@ -152,7 +167,30 @@ private Node<E> getPredecessorNode(int index) {
             curr = curr.next;
             i++;
         }
-        return curr;
+        return (index == 0) ? null : curr;
+    }
+
+    private Node<E> getPredecessorNode(E item) {
+        Node<E> prev = null;
+        Node<E> curr = head;
+        if (item == null) {
+            while (curr != null) {
+                if (curr.item == item) { // when item is null, use == rather than equals()
+                    return prev;
+                }
+                prev = curr;
+                curr = curr.next;
+            }
+        } else {
+            while (curr != null) {
+                if (curr.item.equals(item)) {
+                    return prev;
+                }
+                prev = curr;
+                curr = curr.next;
+            }
+        }
+        return null;
     }
 
     private Node<E> getNode(int index) {
@@ -167,6 +205,26 @@ private Node<E> getNode(int index) {
         return curr;
     }
 
+    private Node<E> getNode(E item) {
+        Node<E> curr = head;
+        if (item == null) {
+            while (curr != null) { // when item is null, use == rather than equals()
+                if (curr.item == item) {
+                    return curr;
+                }
+                curr = curr.next;
+            }
+        } else {
+            while (curr != null) {
+                if (curr.item.equals(item)) {
+                    return curr;
+                }
+                curr = curr.next;
+            }
+        }
+        return null;
+    }
+
     private void isLinkedListEmpty() {
         if (head == null) {
             throw new NoSuchElementException("LinkedList empty");