refactor(linked-list): remove duplicates in singly linked lists

Author: BrianLusina

datastructures/linked_lists/__init__.py

@@ -577,6 +577,13 @@ def remove_tail(self):
         """
         raise NotImplementedError("Not yet implemented")
 
+    @abstractmethod
+    def remove_duplicates(self) -> Optional[Node]:
+        """
+        Remotes the duplicates from a linked list
+        """
+        raise NotImplementedError("Not yet implemented")
+
     @abstractmethod
     def rotate(self, k: int):
         """

datastructures/linked_lists/singly_linked_list/__init__.py

@@ -1,4 +1,4 @@
-from typing import Any, Union, Optional, Tuple
+from typing import Any, Union, Optional, Dict
 
 from datastructures.stacks import Stack
 from .node import SingleNode
@@ -440,24 +440,39 @@ def contains_cycle(self):
         # fast runner hit the end of the list
         return False
 
-    def remove_duplicates(self):
+    def remove_duplicates(self) -> Optional[SingleNode]:
         """
-        Removes duplicates from linked list
+        Removes duplicates from linked list. Uses a dictionary to keep track of seen values in the linked list.
+        For every encountered duplicate value, it is discarded and removed from the linked list.
+
+        Complexity:
+        Where n is the number of nodes in the linked list:
+
+        Time O(n): as this iterates through each node in the linked list checking its value against what's in the
+        dictionary
+
+        Space O(n); a dictionary is used to store duplicate values in the linked list. In the worst case no duplicates
+        exist so, the dictionary has all the values from every node in the linked list.
         """
 
         if self.head is None or self.head.next is None:
             return self.head
 
+        seen: Dict[Any, bool] = dict()
         current = self.head
-        next_ = self.head.next
+        previous: Optional[SingleNode] = None
 
-        while current and next_:
-            if next_.data == current.data:
-                current.next = next_.next
-                next_ = next_.next
+        while current:
+            if current.data in seen:
+                # remove node
+                previous.next = current.next
+                current = None
             else:
-                current = current.next
-                next_ = next_.next
+                # add node data to seen
+                seen[current.data] = True
+                previous = current
+
+            current = previous.next
 
         return self.head
 
@@ -720,7 +735,8 @@ def reverse_list(head_node: SingleNode) -> SingleNode:
         # tail of previous k-group to fix our linked list pointers
         tail = dummy
 
-        # set a tracking node, tracking_node, to cycle through linked list and a head of current linked list, current_head
+        # set a tracking node, tracking_node, to cycle through linked list and a head of current linked list,
+        # current_head
         tracking_node, current_head = self.head, self.head
 
         # while tracking node is tracking a node and hasn't reached end

datastructures/linked_lists/singly_linked_list/test_singly_linked_list_remove_duplicates.py

@@ -0,0 +1,30 @@
+import unittest
+
+from . import SinglyLinkedList
+
+
+class RemoveDuplicatesSinglyLinkedListTestCase(unittest.TestCase):
+    def test_remove_duplicates_empty_list(self):
+        """should return None for empty list"""
+        linked_list = SinglyLinkedList()
+        actual = linked_list.remove_duplicates()
+
+        self.assertIsNone(actual)
+
+    def test_remove_duplicates_non_empty_list_1(self):
+        """Removes duplicates from [1,6,1,4,2,2,4] to become [1,6,4,2]"""
+        linked_list = SinglyLinkedList()
+
+        data = [1, 6, 1, 4, 2, 2, 4]
+        for d in data:
+            linked_list.append(d)
+
+        new_head = linked_list.remove_duplicates()
+        expected = [1, 6, 4, 2]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(expected, list(linked_list))
+
+
+if __name__ == "__main__":
+    unittest.main()