feat(dsa): fast and slow pointers approach to palindrome linked list

Author: BrianLusina

datastructures/linked_lists/singly_linked_list/__init__.py

@@ -576,6 +576,55 @@ def is_palindrome(self) -> bool:
 
         return True
 
+    def is_palindrome_2(self) -> bool:
+        """
+        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
+
+        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:
+            bool: True if the linked list is a palindrome, false otherwise.
+        """
+
+        # An empty LinkedList or with 1 Node is a Palindrome
+        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
+        # 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
+
+        # reverse the second half of the list
+        prev = None
+        while slow:
+            nxt = slow.next
+            slow.next = prev
+            prev = slow
+            slow = nxt
+
+        # now prev is the head of the reversed second half
+        # compare the first half and the reversed second half
+        left, right = self.head, prev
+        while right:
+            if left.data != right.data:
+                return False
+            left = left.next
+            right = right.next
+
+        return True
+
     def pairwise_swap(self) -> Optional[SingleNode]:
         """
         Swaps nodes in pairs.

datastructures/linked_lists/singly_linked_list/test_singly_linked_palindrome.py

@@ -1,5 +1,7 @@
 import unittest
 
+import pytest
+
 from . import SinglyLinkedList
 
 
@@ -14,6 +16,190 @@ def test_1(self):
         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)
+
+        actual = linked_list.is_palindrome()
+        self.assertFalse(actual)
+
+    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]"""
+        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 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_2()
+        self.assertFalse(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]"""
+        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)
+
 
 if __name__ == "__main__":
     unittest.main()

poetry.lock

@@ -8,12 +8,14 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.11"
-pytest = "^7.4.3"
-
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.3.5"
 
+[tool.poetry.group.test.dependencies]
+pytest-benchmark = "^5.1.0"
+pytest = "^8.3.5"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

pyproject.toml

@@ -0,0 +1,3 @@
+[pytest]
+markers =
+    linked_list_is_palindrome_fast_and_slow_pointer: mark a test that this is a fast and slow pointer test for palindrome property of a linked list