feat(dsa): remove nth last node from linked list

Author: BrianLusina

datastructures/linked_lists/__init__.py

@@ -45,12 +45,14 @@ def __iter__(self):
             return
 
         if current:
-            yield current.data
+            if current.data:
+                yield current.data
 
         if current.next:
             node = current.next
             while node:
-                yield node.data
+                if node.data:
+                    yield node.data
                 node = node.next
 
     @abstractmethod
@@ -287,7 +289,7 @@ def delete_node_at_position(self, position: int):
         :param position: Position of node to delete
         """
         if not 0 <= position <= len(self) - 1:
-            raise ValueError("Position out of bounds")
+            raise ValueError(f"Position ${position} out of bounds")
 
         if self.head is None:
             return None
@@ -323,6 +325,21 @@ def delete_middle_node(self) -> Optional[Node]:
         """
         raise NotImplementedError("Not yet implemented")
 
+    @abstractmethod
+    def delete_nth_last_node(self, n: int) -> Optional[Node]:
+        """
+        Deletes the nth last node of the linked list and returns the head of the linked list.
+        Example:
+            n = 1
+            43 -> 68 -> 11 -> 5 -> 69 -> 37 -> 70 -> None
+            43 -> 68 -> 11 -> 5 -> 69 -> 37 -> None
+        Args:
+            n (int): the position from the last node of the node to delete
+        Returns:
+            Node: Head of the linked list
+        """
+        raise NotImplementedError("Not yet implemented")
+
     @abstractmethod
     def display(self):
         """

datastructures/linked_lists/singly_linked_list/__init__.py

@@ -134,10 +134,10 @@ def delete_node_at_position(self, position: int) -> Optional[SingleNode]:
                 current = current.next
 
                 if current is None:
-                    raise ValueError("Invalid position found, reached end of list")
+                    raise ValueError(f"Invalid position {position} found, reached end of list")
 
-            current.data = current.next.data
-            current.next = current.next.next
+            current.data = current.next.data if current.next else None
+            current.next = current.next.next if current.next else None
             return self.head
 
     def delete_node(self, single_node: SingleNode):
@@ -251,6 +251,21 @@ def delete_middle_node_2_pointers(self) -> Optional[SingleNode]:
 
         return middle_node
 
+    def delete_nth_last_node(self, n: int) -> Optional[Node]:
+        length_of_linked_list = len(self)
+
+        if not 1 <= n <= length_of_linked_list:
+            raise ValueError(f"Position {n} is out of bounds")
+
+        if not self.head.next:
+            return self.head
+
+        position_of_node_to_delete = length_of_linked_list - n
+
+        self.delete_node_at_position(position_of_node_to_delete)
+
+        return self.head
+
     def shift(self):
         """
         Since this is a singly linked list, this will have to make the head's next to the position of head

datastructures/linked_lists/singly_linked_list/test_singly_linked_list_remove_nth_last_node.py

@@ -0,0 +1,153 @@
+import unittest
+from . import SinglyLinkedList
+
+
+class RemoveNthLastNodeTestCases(unittest.TestCase):
+
+    def test_0(self):
+        """should raise ValueError when the value of n is out of bounds"""
+        linked_list = SinglyLinkedList()
+        data = [43, 68, 11, 5, 69, 37, 70]
+        for d in data:
+            linked_list.append(d)
+
+        with self.assertRaises(ValueError):
+            linked_list.delete_nth_last_node(0)
+
+        with self.assertRaises(ValueError):
+            linked_list.delete_nth_last_node(8)
+
+    def test_1(self):
+        """should delete nth last node where n=1 and list is 43 -> 68 -> 11 -> 5 -> 69 -> 37 -> 70 to become 43 -> 68 -> 11 -> 5 -> 69 -> 37"""
+        linked_list = SinglyLinkedList()
+        data = [43, 68, 11, 5, 69, 37, 70]
+        for d in data:
+            linked_list.append(d)
+
+        new_head = linked_list.delete_nth_last_node(1)
+        expected = [43, 68, 11, 5, 69, 37]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 43)
+        self.assertEqual(expected, list(linked_list))
+
+    def test_2(self):
+        """should delete nth last node where n=3 and list is 23 -> 28 -> 10 -> 5 -> 67 -> 39 -> 70 to become 23 -> 28 -> 10 -> 5 -> 39 -> 70"""
+        linked_list = SinglyLinkedList()
+        data = [23, 28, 10, 5, 67, 39, 70]
+        for d in data:
+            linked_list.append(d)
+
+        new_head = linked_list.delete_nth_last_node(3)
+        expected = [23, 28, 10, 5, 39, 70]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 23)
+        self.assertEqual(expected, list(linked_list))
+
+    def test_3(self):
+        """should delete nth last node where n=5 and list is 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 to become 1 -> 2 -> 4 -> 5 -> 6 -> 7"""
+        linked_list = SinglyLinkedList()
+        data = [1, 2, 3, 4, 5, 6, 7]
+        for d in data:
+            linked_list.append(d)
+
+        new_head = linked_list.delete_nth_last_node(5)
+        expected = [1, 2, 4, 5, 6, 7]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 1)
+        self.assertEqual(expected, list(linked_list))
+
+    def test_4(self):
+        """should delete nth last node where n=4 and list is 50 -> 40 -> 30 -> 20 to become 40 -> 30 -> 20"""
+        linked_list = SinglyLinkedList()
+        data = [50, 40, 30, 20]
+        for d in data:
+            linked_list.append(d)
+
+        new_head = linked_list.delete_nth_last_node(4)
+        expected = [40, 30, 20]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 40)
+        self.assertEqual(expected, list(linked_list))
+
+    def test_5(self):
+        """should delete nth last node where n=6 and list is [69,8,49,106,116,112] to become [8,49,106,116,112]"""
+        linked_list = SinglyLinkedList()
+        data = [69,8,49,106,116,112]
+        for d in data:
+            linked_list.append(d)
+
+        n = 6
+        new_head = linked_list.delete_nth_last_node(n)
+        expected = [8,49,106,116,112]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 8)
+        self.assertEqual(expected, list(linked_list))
+
+    def test_6(self):
+        """should delete nth last node where n=1 and list is 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 to become 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8"""
+        linked_list = SinglyLinkedList()
+        data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+        for d in data:
+            linked_list.append(d)
+
+        n = 1
+        new_head = linked_list.delete_nth_last_node(n)
+        expected = [1, 2, 3, 4, 5, 6, 7, 8]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 1)
+        self.assertEqual(expected, list(linked_list))
+
+    def test_7(self):
+        """should delete nth last node where n=4 and list is [288,224,275,390,4,383,330,60,193] to become [288,224,275,390,4,330,60,193]"""
+        linked_list = SinglyLinkedList()
+        data = [288,224,275,390,4,383,330,60,193]
+        for d in data:
+            linked_list.append(d)
+
+        n = 4
+        new_head = linked_list.delete_nth_last_node(n)
+        expected = [288,224,275,390,4,330,60,193]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 288)
+        self.assertEqual(expected, list(linked_list))
+
+    def test_8(self):
+        """should delete nth last node where n=3 and list is [34,53,6,95,38,28,17,63,16,76] to become [34,53,6,95,38,28,17,16,76]"""
+        linked_list = SinglyLinkedList()
+        data = [34,53,6,95,38,28,17,63,16,76]
+        for d in data:
+            linked_list.append(d)
+
+        n = 3
+        new_head = linked_list.delete_nth_last_node(n)
+        expected = [34,53,6,95,38,28,17,16,76]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 34)
+        self.assertEqual(expected, list(linked_list))
+
+    def test_9(self):
+        """should delete nth last node where n=2 and list is [23,28,10,5,67,39,70,28] to become [23,28,10,5,67,39,28]"""
+        linked_list = SinglyLinkedList()
+        data = [23,28,10,5,67,39,70,28]
+        for d in data:
+            linked_list.append(d)
+
+        n = 2
+        new_head = linked_list.delete_nth_last_node(n)
+        expected = [23,28,10,5,67,39,28]
+
+        self.assertIsNotNone(new_head)
+        self.assertEqual(new_head.data, 23)
+        self.assertEqual(expected, list(linked_list))
+
+
+if __name__ == '__main__':
+    unittest.main()