refactor 83

fishercoder1534 · fishercoder1534 · commit 222694792e54 · 2018-02-20T07:29:52.000-08:00
diff --git a/README.md b/README.md
@@ -605,7 +605,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |86|[Partition List](https://leetcode.com/problems/partition-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_86.java)|O(n) |O(1)||Medium|
 |85|[Maximal Rectangle](https://leetcode.com/problems/maximal-rectangle/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_85.java)|O(m*n) |O(n)||Hard|DP
 |84|[Largest Rectangle in Histogram](https://leetcode.com/problems/largest-rectangle-in-histogram/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_84.java)|O(n) |O(n)||Hard|Array, Stack
-|83|[Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_83.java)|O(n) |O(1)||Medium| Linked List
+|83|[Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_83.java)|O(n) |O(1)||Easy| Linked List
 |82|[Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_82.java)|O(n) |O(1)||Medium| Linked List
 |81|[Search in Rotated Sorted Array II](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_81.java)|O(logn)|O(1)||Medium|Binary Search
 |80|[Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_80.java)|O(n) |O(n)||Medium|
diff --git a/src/main/java/com/fishercoder/solutions/_83.java b/src/main/java/com/fishercoder/solutions/_83.java
@@ -2,22 +2,41 @@
 
 import com.fishercoder.common.classes.ListNode;
 
-/**Given a sorted linked list, delete all duplicates such that each element appear only once.
+/**
+ * 83. Remove Duplicates from Sorted List
+ *
+ * Given a sorted linked list, delete all duplicates such that each element appear only once.
 
  For example,
  Given 1->1->2, return 1->2.
- Given 1->1->2->3->3, return 1->2->3.*/
+ Given 1->1->2->3->3, return 1->2->3.
+ */
 public class _83 {
+  public static class Solution1 {
+    public ListNode deleteDuplicates(ListNode head) {
+      ListNode ret = new ListNode(-1);
+      ret.next = head;
+      while (head != null) {
+        while (head.next != null && head.next.val == head.val) {
+          head.next = head.next.next;
+        }
+        head = head.next;
+      }
+      return ret.next;
+    }
+  }
 
-    public static ListNode deleteDuplicates(ListNode head) {
-        ListNode ret = new ListNode(-1);
-        ret.next = head;
-        while (head != null) {
-            while (head.next != null && head.next.val == head.val) {
-                head.next = head.next.next;
-            }
-            head = head.next;
+  public static class Solution2 {
+    public ListNode deleteDuplicates(ListNode head) {
+      ListNode curr = head;
+      while (curr != null && curr.next != null) {
+        if (curr.val == curr.next.val) {
+          curr.next = curr.next.next;
+        } else {
+          curr = curr.next;
         }
-        return ret.next;
+      }
+      return head;
     }
+  }
 }
diff --git a/src/test/java/com/fishercoder/_83Test.java b/src/test/java/com/fishercoder/_83Test.java
@@ -2,28 +2,38 @@
 
 import com.fishercoder.common.classes.ListNode;
 import com.fishercoder.solutions._83;
+import java.util.Arrays;
 import org.junit.Assert;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 /**
  * Created by fishercoder on 4/18/17.
  */
 public class _83Test {
 
-    @Test
-    public void test1() {
-        ListNode head = new ListNode(1);
-        head.next = new ListNode(1);
-        head.next.next = new ListNode(2);
-        head.next.next.next = new ListNode(3);
-        head.next.next.next.next = new ListNode(3);
+  private static _83.Solution1 solution1;
+  private static _83.Solution2 solution2;
+  private static ListNode head;
+  private static ListNode expected;
 
-        _83 test = new _83();
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _83.Solution1();
+    solution2 = new _83.Solution2();
+  }
 
-        ListNode expected = new ListNode(1);
-        expected.next = new ListNode(2);
-        expected.next.next = new ListNode(3);
+  @Test
+  public void test1() {
+    head = ListNode.createSinglyLinkedList(Arrays.asList(1, 1, 2, 3, 3));
+    expected = ListNode.createSinglyLinkedList(Arrays.asList(1, 2, 3));
+    Assert.assertEquals(expected, solution1.deleteDuplicates(head));
+  }
 
-        Assert.assertEquals(expected, test.deleteDuplicates(head));
-    }
+  @Test
+  public void test2() {
+    head = ListNode.createSinglyLinkedList(Arrays.asList(1, 1, 2, 3, 3));
+    expected = ListNode.createSinglyLinkedList(Arrays.asList(1, 2, 3));
+    Assert.assertEquals(expected, solution2.deleteDuplicates(head));
+  }
 }
