fix: fix C02_P01 to set tail so .add works

closes #65

Author: brycedrennan

chapter_02/linked_list.py

@@ -1,11 +1,11 @@
-from random import randint
+import random
 
 
 class LinkedListNode:
-    def __init__(self, value, nextNode=None, prevNode=None):
+    def __init__(self, value, next_node=None, prev_node=None):
         self.value = value
-        self.next = nextNode
-        self.prev = prevNode
+        self.next = next_node
+        self.prev = prev_node
 
     def __str__(self):
         return str(self.value)
@@ -36,6 +36,9 @@ def __len__(self):
             node = node.next
         return result
 
+    def values(self):
+        return [x.value for x in self]
+
     def add(self, value):
         if self.head is None:
             self.tail = self.head = LinkedListNode(value)
@@ -55,11 +58,9 @@ def add_multiple(self, values):
         for v in values:
             self.add(v)
 
-    def generate(self, n, min_value, max_value):
-        self.head = self.tail = None
-        for i in range(n):
-            self.add(randint(min_value, max_value))
-        return self
+    @classmethod
+    def generate(cls, k, min_value, max_value):
+        return cls(random.choices(range(min_value, max_value), k=k))
 
 
 class DoublyLinkedList(LinkedList):

chapter_02/p01_remove_dups.py

@@ -1,27 +1,26 @@
-from .linked_list import LinkedList
+import time
 
+from chapter_02.linked_list import LinkedList
 
-def remove_dups(ll):
-    if ll.head is None:
-        return
 
+def remove_dups(ll):
     current = ll.head
-    seen = set([current.value])
-    while current.next:
-        if current.next.value in seen:
-            current.next = current.next.next
-        else:
-            seen.add(current.next.value)
-            current = current.next
+    previous = None
+    seen = set()
 
+    while current:
+        if current.value in seen:
+            previous.next = current.next
+        else:
+            seen.add(current.value)
+            previous = current
+        current = current.next
+    ll.tail = previous
     return ll
 
 
 def remove_dups_followup(ll):
-    if ll.head is None:
-        return
-
-    current = ll.head
+    runner = current = ll.head
     while current:
         runner = current
         while runner.next:
@@ -30,18 +29,45 @@ def remove_dups_followup(ll):
             else:
                 runner = runner.next
         current = current.next
+    ll.tail = runner
+    return ll
+
+
+testable_functions = (remove_dups, remove_dups_followup)
+test_cases = (
+    ([], []),
+    ([1, 1, 1, 1, 1, 1], [1]),
+    ([1, 2, 3, 2], [1, 2, 3]),
+    ([1, 2, 2, 3], [1, 2, 3]),
+    ([1, 1, 2, 3], [1, 2, 3]),
+    ([1, 2, 3], [1, 2, 3]),
+)
+
+
+def test_remove_dupes():
+    for f in testable_functions:
+        start = time.perf_counter()
+        for _ in range(100):
+            for values, expected in test_cases:
+                expected = expected.copy()
+                deduped = f(LinkedList(values))
+                assert deduped.values() == expected
+
+                deduped.add(5)
+                expected.append(5)
+                assert deduped.values() == expected
 
-    return ll.head
+        duration = time.perf_counter() - start
+        print(f"{f.__name__} {duration * 1000:.1f}ms")
 
 
 if __name__ == "__main__":
-    ll = LinkedList()
-    ll.generate(100, 0, 9)
+    ll = LinkedList.generate(100, 0, 9)
     print(ll)
     remove_dups(ll)
     print(ll)
 
-    ll.generate(100, 0, 9)
+    ll = LinkedList.generate(100, 0, 9)
     print(ll)
     remove_dups_followup(ll)
     print(ll)

chapter_02/p04_partition.py

@@ -1,4 +1,4 @@
-from .linked_list import LinkedList
+from chapter_02.linked_list import LinkedList
 
 
 def partition(ll, x):
@@ -21,8 +21,7 @@ def partition(ll, x):
 
 
 if __name__ == "__main__":
-    ll = LinkedList()
-    ll.generate(10, 0, 99)
+    ll = LinkedList.generate(10, 0, 99)
     print(ll)
     partition(ll, ll.head.value)
     print(ll)

chapter_02/p05_sum_lists.py

@@ -48,10 +48,8 @@ def sum_lists_followup(ll_a, ll_b):
 
 
 if __name__ == "__main__":
-    ll_a = LinkedList()
-    ll_a.generate(4, 0, 9)
-    ll_b = LinkedList()
-    ll_b.generate(3, 0, 9)
+    ll_a = LinkedList.generate(4, 0, 9)
+    ll_b = LinkedList.generate(3, 0, 9)
     print(ll_a)
     print(ll_b)
     print(sum_lists(ll_a, ll_b))