refactor(data-structures, linked list): is palindrome test cases modification

Author: BrianLusina

datastructures/linked_lists/mergeklinkedlists/__init__.py

@@ -1,5 +1,5 @@
 from typing import List, Optional
-from .. import Node
+from datastructures.linked_lists import Node
 
 
 def merge_two_sorted_lists(
@@ -15,7 +15,7 @@ def merge_two_sorted_lists(
     This is because both linked lists have to be traversed to merge into a single linked list
 
     Space O(n+m) where n & m are the number of nodes in the respective linked list. This is because a new linked list
-    is created from both linked lists and the nodes from each are merged into a single linke list.
+    is created from both linked lists and the nodes from each are merged into a single linked list.
 
     Args:
         head_one(Node): optional head node of linked list one

datastructures/linked_lists/mergeklinkedlists/test_merge.py

@@ -1,6 +1,9 @@
 import unittest
-from . import merge_two_sorted_lists, merge_k_lists
-from ..singly_linked_list import SinglyLinkedList
+from datastructures.linked_lists.mergeklinkedlists import (
+    merge_two_sorted_lists,
+    merge_k_lists,
+)
+from datastructures.linked_lists.singly_linked_list import SinglyLinkedList
 
 
 class MergeSortedLinkedListsTestCase(unittest.TestCase):

datastructures/linked_lists/singly_linked_list/single_linked_list.py

@@ -153,6 +153,11 @@ def delete_node(self, single_node: SingleNode):
         if not self.head:
             return
 
+        # if the node we are deleting is the head node
+        if self.head == single_node:
+            self.head = self.head.next
+            return
+
         current_node = self.head
         previous_node = None
         while current_node is not None:
@@ -542,11 +547,26 @@ def display_backward(self):
     def display_forward(self):
         pass
 
-    def contains_cycle(self):
+    def contains_cycle(self) -> bool:
         """
-        Check if the SinglyLinkedList contains a cycle
-        :return:
+        Check if the SinglyLinkedList contains a cycle, This uses floyd's cycle detection algorithm to check if a linked
+        list contains a cycle. A cycle in a linked list is determined by a node in the linked list having its next pointer
+        point to a node in the same liked list.
+
+        Complexity Analysis:
+        n is the number of nodes in the linked list
+
+        Time: O(n), we traverse the nodes in the linked list iteratively, at the worst case, we traverse all the nodes
+        in the linked list until we reach the end of the linked list
+
+        Space: O(1) as there is no extra space used other than the pointers used to traverse the linked list.
+
+        Returns:
+            bool: True if the linked list contains a cycle, False otherwise
         """
+        if not self.head or not self.head.next:
+            return False
+
         fast_runner = self.head
         slow_runner = self.head
 
@@ -655,11 +675,8 @@ def is_palindrome(self) -> bool:
             bool: True if the linked list is a palindrome, false otherwise.
         """
 
-        if not self.head:
-            return False
-
-        # A LinkedList with 1 Node is a Palindrome
-        if not self.head.next:
+        # an empty linked list is consided a palindrome
+        if not self.head or not self.head.next:
             return True
 
         current = self.head
@@ -682,17 +699,18 @@ def is_palindrome(self) -> bool:
 
     def is_palindrome_2(self) -> bool:
         """
-        Checks to see if a Linked list is a Palindrome.
-        Returns True if it is, false otherwise.
+        Checks to see if a Linked list is a Palindrome. Returns True if it is, false otherwise.
+
         Uses two pointers approach to check if a linked list is a palindrome. First it finds the middle of the list using
         two pointers a fast and a slow pointer and then reverses the second half of the list. Once the second half is
         reversed, it compares the first half and the reversed second half
 
+        This modifies the linked list
+
         Complexity:
         We assume that n is the number of nodes in the linked list
 
         Time O(n): we traverse the linked list to check for the palindrome property.
-
         Space O(1): No extra space is used when traversing the linked list
 
         Returns:
@@ -703,20 +721,12 @@ def is_palindrome_2(self) -> bool:
         if not self.head or not self.head.next:
             return True
 
-        # find the middle of the list using fast and slow pointers. The fast pointer will have gotten to the end of the
+        # Find the middle of the list using fast and slow pointers. The fast pointer will have gotten to the end of the
         # the linked list and the slow pointer will be at the middle of the linked list
-        slow, fast = self.head, self.head
-        while fast and fast.next:
-            slow = slow.next
-            fast = fast.next.next
+        middle_node = self.middle_node()
 
         # reverse the second half of the list
-        prev = None
-        while slow:
-            nxt = slow.next
-            slow.next = prev
-            prev = slow
-            slow = nxt
+        prev = self.reverse_list(middle_node)
 
         # now prev is the head of the reversed second half
         # compare the first half and the reversed second half

datastructures/linked_lists/singly_linked_list/test_singly_linked_palindrome.py

@@ -1,205 +1,46 @@
 import unittest
-
+from typing import List, Any
+from parameterized import parameterized
 import pytest
 
-from . import SinglyLinkedList
-
-
-class LinkedListIsPalindromeTestCase(unittest.TestCase):
-    def test_1(self):
-        """should return true for ["r", "a", "c", "e", "c", "a", "r"]"""
-        linked_list = SinglyLinkedList()
-        data = ["r", "a", "c", "e", "c", "a", "r"]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome()
-        self.assertTrue(actual)
-
-    def test_2(self):
-        """should return true for [2, 4, 6, 4, 2]"""
-        linked_list = SinglyLinkedList()
-        data = [2, 4, 6, 4, 2]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome()
-        self.assertTrue(actual)
-
-    def test_3(self):
-        """should return true for [0, 3, 5, 5, 0]"""
-        linked_list = SinglyLinkedList()
-        data = [0, 3, 5, 5, 0]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome()
-        self.assertFalse(actual)
-
-    def test_4(self):
-        """should return true for [9, 7, 4, 4, 7, 9]"""
-        linked_list = SinglyLinkedList()
-        data = [9, 7, 4, 4, 7, 9]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome()
-        self.assertTrue(actual)
-
-    def test_5(self):
-        """should return true for [1,2,3,2,1]"""
-        linked_list = SinglyLinkedList()
-        data = [1, 2, 3, 2, 1]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome()
-        self.assertTrue(actual)
-
-    def test_6(self):
-        """should return true for [4,7,9,5,4]"""
-        linked_list = SinglyLinkedList()
-        data = [4, 7, 9, 5, 4]
-        for d in data:
-            linked_list.append(d)
+from datastructures.linked_lists.singly_linked_list import SinglyLinkedList
 
-        actual = linked_list.is_palindrome()
-        self.assertFalse(actual)
+IS_LINKED_LIST_PALINDROME_TEST_CASES = [
+    (["r", "a", "c", "e", "c", "a", "r"], True),
+    ([2, 4, 6, 4, 2], True),
+    ([0, 3, 5, 5, 0], False),
+    ([9, 7, 4, 4, 7, 9], True),
+    ([1, 2, 3, 2, 1], True),
+    ([4, 7, 9, 5, 4], False),
+    ([2, 3, 5, 5, 3, 2], True),
+    ([6, 1, 0, 5, 1, 6], False),
+    ([3, 6, 9, 8, 4, 8, 9, 6, 3], True),
+    ([1, 2], False),
+    ([1, 2, 3, 4, 5], False),
+]
 
-    def test_7(self):
-        """should return true for [2,3,5,5,3,2]"""
-        linked_list = SinglyLinkedList()
-        data = [2, 3, 5, 5, 3, 2]
-        for d in data:
-            linked_list.append(d)
 
-        actual = linked_list.is_palindrome()
-        self.assertTrue(actual)
-
-    def test_8(self):
-        """should return true for [6,1,0,5,1,6]"""
-        linked_list = SinglyLinkedList()
-        data = [6, 1, 0, 5, 1, 6]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome()
-        self.assertFalse(actual)
-
-    def test_9(self):
-        """should return true for [3,6,9,8,4,8,9,6,3]"""
+class LinkedListIsPalindromeTestCase(unittest.TestCase):
+    @parameterized.expand(IS_LINKED_LIST_PALINDROME_TEST_CASES)
+    def test_is_palindrome_using_stack(self, data: List[Any], expected: bool):
+        """Tests to check if a linked list is a palindrome using a stack approach"""
         linked_list = SinglyLinkedList()
-        data = [3, 6, 9, 8, 4, 8, 9, 6, 3]
         for d in data:
             linked_list.append(d)
 
         actual = linked_list.is_palindrome()
-        self.assertTrue(actual)
-
-
-class LinkedListIsPalindromeV2TestCase(unittest.TestCase):
-    """
-    Tests to check if a linked list is a palindrome using fast and slow pointers approach
-    """
-
-    @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_1(self):
-        """should return true for ["r", "a", "c", "e", "c", "a", "r"]"""
-        linked_list = SinglyLinkedList()
-        data = ["r", "a", "c", "e", "c", "a", "r"]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome_2()
-        self.assertTrue(actual)
-
-    @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_2(self):
-        """should return true for [2, 4, 6, 4, 2]"""
-        linked_list = SinglyLinkedList()
-        data = [2, 4, 6, 4, 2]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome_2()
-        self.assertTrue(actual)
-
-    @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_3(self):
-        """should return true for [0, 3, 5, 5, 0]"""
-        linked_list = SinglyLinkedList()
-        data = [0, 3, 5, 5, 0]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome_2()
-        self.assertFalse(actual)
-
-    @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_4(self):
-        """should return true for [9, 7, 4, 4, 7, 9]"""
-        linked_list = SinglyLinkedList()
-        data = [9, 7, 4, 4, 7, 9]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome_2()
-        self.assertTrue(actual)
-
-    @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_5(self):
-        """should return true for [1,2,3,2,1]"""
-        linked_list = SinglyLinkedList()
-        data = [1, 2, 3, 2, 1]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome_2()
-        self.assertTrue(actual)
-
-    @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_6(self):
-        """should return true for [4,7,9,5,4]"""
-        linked_list = SinglyLinkedList()
-        data = [4, 7, 9, 5, 4]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome_2()
-        self.assertFalse(actual)
-
-    @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_7(self):
-        """should return true for [2,3,5,5,3,2]"""
-        linked_list = SinglyLinkedList()
-        data = [2, 3, 5, 5, 3, 2]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome_2()
-        self.assertTrue(actual)
-
-    @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_8(self):
-        """should return false for [6,1,0,5,1,6]"""
-        linked_list = SinglyLinkedList()
-        data = [6, 1, 0, 5, 1, 6]
-        for d in data:
-            linked_list.append(d)
-
-        actual = linked_list.is_palindrome_2()
-        self.assertFalse(actual)
+        self.assertEqual(expected, actual)
 
     @pytest.mark.linked_list_is_palindrome_fast_and_slow_pointer
-    def test_9(self):
-        """should return true for [3,6,9,8,4,8,9,6,3]"""
+    @parameterized.expand(IS_LINKED_LIST_PALINDROME_TEST_CASES)
+    def test_is_palindrome_using_two_pointers(self, data: List[Any], expected: bool):
+        """Tests to check if a linked list is a palindrome using fast and slow pointers approach"""
         linked_list = SinglyLinkedList()
-        data = [3, 6, 9, 8, 4, 8, 9, 6, 3]
         for d in data:
             linked_list.append(d)
 
         actual = linked_list.is_palindrome_2()
-        self.assertTrue(actual)
+        self.assertEqual(expected, actual)
 
 
 if __name__ == "__main__":