refactor 203

fishercoder1534 · fishercoder1534 · commit e4ae4ee22f2a · 2018-09-12T07:48:36.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_203.java b/src/main/java/com/fishercoder/solutions/_203.java
@@ -2,39 +2,43 @@
 
 import com.fishercoder.common.classes.ListNode;
 
-/**203. Remove Linked List Elements
+/**
+ * 203. Remove Linked List Elements
  *
-Remove all elements from a linked list of integers that have value val.
-
-Example
-Given: 1 --> 2 --> 6 --> 3 --> 4 --> 5 --> 6, val = 6
-Return: 1 --> 2 --> 3 --> 4 --> 5*/
+ * Remove all elements from a linked list of integers that have value val.
+ *
+ * Example
+ * Given: 1 --> 2 --> 6 --> 3 --> 4 --> 5 --> 6, val = 6
+ * Return: 1 --> 2 --> 3 --> 4 --> 5
+ */
 public class _203 {
-	/**
-	 * This is a very good question to test your understanding of pointers/memory/addresses, although it's marked as EASY.
-	 * All the three nodes: dummy, curr and prev are indispensable.
-	 * <p>
-	 * 1. Eventually, we should return dummy.next as the final result.
-	 * 2. we assign head to curr, dummy to prev
-	 * 3. and then we use prev and curr to traverse through the list and do the work
-	 * 4. each time, we only move one node forward, so we don't need another while loop inside the while loop
-	 * 5. KEY: if(curr.val == val), then curr is the node we want to remove, so, we'll assign curr.next to prev.next, thus, prev won't have that node
-	 * else, we'll keep moving prev forward, so, just do prev = prev.next
-	 * but, for both cases, we'll also move curr forward, so we put curr = curr.next in the outside.
-	 */
-	public ListNode removeElements(ListNode head, int val) {
-		ListNode dummy = new ListNode(-1);
-		dummy.next = head;
-		ListNode curr = head;
-		ListNode prev = dummy;
-		while (curr != null) {
-			if (curr.val == val) {
-				prev.next = curr.next;
-			} else {
-				prev = prev.next;
-			}
-			curr = curr.next;
-		}
-		return dummy.next;
-	}
+    public static class Solution1 {
+        /**
+         * This is a very good question to test your understanding of pointers/memory/addresses, although it's marked as EASY.
+         * All the three nodes: dummy, curr and prev are indispensable.
+         *
+         * 1. Eventually, we should return dummy.next as the final result.
+         * 2. we assign head to curr, dummy to prev
+         * 3. and then we use prev and curr to traverse through the list and do the work
+         * 4. each time, we only move one node forward, so we don't need another while loop inside the while loop
+         * 5. KEY: if(curr.val == val), then curr is the node we want to remove, so, we'll assign curr.next to prev.next, thus, prev won't have that node
+         * else, we'll keep moving prev forward, so, just do prev = prev.next
+         * but, for both cases, we'll also move curr forward, so we put curr = curr.next in the outside.
+         */
+        public ListNode removeElements(ListNode head, int val) {
+            ListNode dummy = new ListNode(-1);
+            dummy.next = head;
+            ListNode curr = head;
+            ListNode prev = dummy;
+            while (curr != null) {
+                if (curr.val == val) {
+                    prev.next = curr.next;
+                } else {
+                    prev = prev.next;
+                }
+                curr = curr.next;
+            }
+            return dummy.next;
+        }
+    }
 }
diff --git a/src/test/java/com/fishercoder/_203Test.java b/src/test/java/com/fishercoder/_203Test.java
@@ -9,20 +9,20 @@
 import static org.junit.Assert.assertEquals;
 
 public class _203Test {
-    private static _203 test;
+    private static _203.Solution1 solution1;
     private static ListNode head;
     private static ListNode expected;
 
     @BeforeClass
     public static void setup() {
-        test = new _203();
+        solution1 = new _203.Solution1();
     }
 
     @Test
     public void test1() {
         head = LinkedListUtils.contructLinkedList(new int[]{1, 2, 6, 3, 4, 5, 6});
         expected = LinkedListUtils.contructLinkedList(new int[]{1, 2, 3, 4, 5});
-        assertEquals(expected, test.removeElements(head, 6));
+        assertEquals(expected, solution1.removeElements(head, 6));
     }
 
 }
