[LinkedList] Optimize solutions

Author: Yi Gu

LinkedList/RemoveDuplicatesFromSortedList.swift

@@ -1,6 +1,6 @@
 /**
  * Question Link: https://leetcode.com/problems/remove-duplicates-from-sorted-list/
- * Primary idea: Two pointers, iterate the list and only reserve right nodes
+ * Primary idea: Iterate the list, jump over duplicates by replacing next with next.next
  * Time Complexity: O(n), Space Complexity: O(1)
  *
  * Definition for singly-linked list.
@@ -15,22 +15,20 @@
  */
 
 class RemoveDuplicatesFromSortedList {
-    func deleteDuplicates(head: ListNode?) -> ListNode? {
+    func deleteDuplicates(_ head: ListNode?) -> ListNode? {
         guard let head = head else {
             return nil
         }
 
-        var prev = head
-        var curr = head.next
+        var curt = head
 
-        while curr != nil {
-            if prev.val != curr!.val {
-                prev.next = curr
-                prev = curr!
-            } 
-            curr = curr!.next
+        while curt.next != nil {
+            if curt.next!.val == curt.val {
+                curt.next = curt.next!.next
+            } else {
+                curt = curt.next!
+            }
         }
-        prev.next = nil
 
         return head
     }

LinkedList/RemoveDuplicatesFromSortedListII.swift

@@ -1,7 +1,6 @@
 /**
  * Question Link: https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/
- * Primary idea: Three pointers, iterate the list and only reserve right nodes, 
- *				 specially handle the last one afterwards
+ * Primary idea: Iterate the list, jump over duplicates by replacing next with next.next
  *
  * Note: Swift provides "===" to compare two objects refer to the same reference
  * 
@@ -19,40 +18,26 @@
  */
 
  class RemoveDuplicatesfromSortedListII {
-    func deleteDuplicates(head: ListNode?) -> ListNode? {
+    func deleteDuplicates(_ head: ListNode?) -> ListNode? {
         if head == nil || head!.next == nil {
             return head
         }
 
         let dummy = ListNode(0)
         dummy.next = head
-        
         var node = dummy
-        var prev = head
-        var post = head!.next
 
-        while post != nil {
-            if post!.val != prev!.val && prev!.next === post{
-                node.next = prev
-                node = prev!
-                prev = post!
-                post = post!.next
-            } else {
-                if post!.val != prev!.val {
-                    prev = post!
-                    post = post!.next
-                } else {
-                    post = post!.next
+        while node.next != nil && node.next!.next != nil {
+            if node.next!.val == node.next!.next!.val {
+                let val = node.next!.val
+                while node.next != nil && node.next!.val == val {
+                    node.next = node.next!.next
                 }
+            } else {
+                node = node.next!
             }
         }
 
-        if prev!.next != nil {
-            node.next = nil
-        } else {
-            node.next = prev
-        }
-        
         return dummy.next
     }
 }

LinkedList/RemoveLinkedListElements.swift

@@ -1,6 +1,6 @@
 /**
  * Question Link: https://leetcode.com/problems/remove-linked-list-elements/
- * Primary idea: Two pointers, iterate the list and only reserve right nodes
+ * Primary idea: Iterate the list, jump over vals by replacing next with next.next
  * Time Complexity: O(n), Space Complexity: O(1)
  *
  * Definition for singly-linked list.