refactor: introduce SinglyLinkedListNode (#6210)

src/test/java/com/thealgorithms/datastructures/lists/ReverseKGroupTest.java

@@ -20,8 +20,8 @@ public class ReverseKGroupTest {
     @Test
     public void testReverseKGroupWithSingleNodeList() {
         ReverseKGroup reverser = new ReverseKGroup();
-        Node singleNode = new Node(5);
-        Node result = reverser.reverseKGroup(singleNode, 2);
+        SinglyLinkedListNode singleNode = new SinglyLinkedListNode(5);
+        SinglyLinkedListNode result = reverser.reverseKGroup(singleNode, 2);
         assertEquals(5, result.value);
         assertNull(result.next);
     }
@@ -31,15 +31,15 @@ public class ReverseKGroupTest {
         ReverseKGroup reverser = new ReverseKGroup();
 
         // Create a list with multiple elements (1 -> 2 -> 3 -> 4 -> 5)
-        Node head;
-        head = new Node(1);
-        head.next = new Node(2);
-        head.next.next = new Node(3);
-        head.next.next.next = new Node(4);
-        head.next.next.next.next = new Node(5);
+        SinglyLinkedListNode head;
+        head = new SinglyLinkedListNode(1);
+        head.next = new SinglyLinkedListNode(2);
+        head.next.next = new SinglyLinkedListNode(3);
+        head.next.next.next = new SinglyLinkedListNode(4);
+        head.next.next.next.next = new SinglyLinkedListNode(5);
 
         // Test reverse with k=2
-        Node result1 = reverser.reverseKGroup(head, 2);
+        SinglyLinkedListNode result1 = reverser.reverseKGroup(head, 2);
         assertEquals(2, result1.value);
         assertEquals(1, result1.next.value);
         assertEquals(4, result1.next.next.value);
@@ -53,15 +53,15 @@ public class ReverseKGroupTest {
         ReverseKGroup reverser = new ReverseKGroup();
 
         // Create a list with multiple elements (1 -> 2 -> 3 -> 4 -> 5)
-        Node head;
-        head = new Node(1);
-        head.next = new Node(2);
-        head.next.next = new Node(3);
-        head.next.next.next = new Node(4);
-        head.next.next.next.next = new Node(5);
+        SinglyLinkedListNode head;
+        head = new SinglyLinkedListNode(1);
+        head.next = new SinglyLinkedListNode(2);
+        head.next.next = new SinglyLinkedListNode(3);
+        head.next.next.next = new SinglyLinkedListNode(4);
+        head.next.next.next.next = new SinglyLinkedListNode(5);
 
         // Test reverse with k=3
-        Node result = reverser.reverseKGroup(head, 3);
+        SinglyLinkedListNode result = reverser.reverseKGroup(head, 3);
         assertEquals(3, result.value);
         assertEquals(2, result.next.value);
         assertEquals(1, result.next.next.value);

src/test/java/com/thealgorithms/datastructures/lists/RotateSinglyLinkedListsTest.java

@@ -14,24 +14,24 @@ public class RotateSinglyLinkedListsTest {
     private final RotateSinglyLinkedLists rotator = new RotateSinglyLinkedLists();
 
     // Helper method to create a linked list from an array of values
-    private Node createLinkedList(int[] values) {
+    private SinglyLinkedListNode createLinkedList(int[] values) {
         if (values.length == 0) {
             return null;
         }
 
-        Node head = new Node(values[0]);
-        Node current = head;
+        SinglyLinkedListNode head = new SinglyLinkedListNode(values[0]);
+        SinglyLinkedListNode current = head;
         for (int i = 1; i < values.length; i++) {
-            current.next = new Node(values[i]);
+            current.next = new SinglyLinkedListNode(values[i]);
             current = current.next;
         }
         return head;
     }
 
     // Helper method to convert a linked list to a string for easy comparison
-    private String linkedListToString(Node head) {
+    private String linkedListToString(SinglyLinkedListNode head) {
         StringBuilder sb = new StringBuilder();
-        Node current = head;
+        SinglyLinkedListNode current = head;
         while (current != null) {
             sb.append(current.value);
             if (current.next != null) {
@@ -51,55 +51,55 @@ public class RotateSinglyLinkedListsTest {
     @Test
     public void testRotateRightSingleNodeList() {
         // Rotate a list with a single element
-        Node singleNode = new Node(5);
-        Node rotatedSingleNode = rotator.rotateRight(singleNode, 3);
+        SinglyLinkedListNode singleNode = new SinglyLinkedListNode(5);
+        SinglyLinkedListNode rotatedSingleNode = rotator.rotateRight(singleNode, 3);
         assertEquals("5", linkedListToString(rotatedSingleNode));
     }
 
     @Test
     public void testRotateRightMultipleElementsList() {
         // Rotate a list with multiple elements (rotate by 2)
-        Node head = createLinkedList(new int[] {1, 2, 3, 4, 5});
-        Node rotated = rotator.rotateRight(head, 2);
+        SinglyLinkedListNode head = createLinkedList(new int[] {1, 2, 3, 4, 5});
+        SinglyLinkedListNode rotated = rotator.rotateRight(head, 2);
         assertEquals("4 -> 5 -> 1 -> 2 -> 3", linkedListToString(rotated));
     }
 
     @Test
     public void testRotateRightFullRotation() {
         // Rotate by more than the length of the list
-        Node head = createLinkedList(new int[] {1, 2, 3, 4, 5});
-        Node rotated = rotator.rotateRight(head, 7);
+        SinglyLinkedListNode head = createLinkedList(new int[] {1, 2, 3, 4, 5});
+        SinglyLinkedListNode rotated = rotator.rotateRight(head, 7);
         assertEquals("4 -> 5 -> 1 -> 2 -> 3", linkedListToString(rotated));
     }
 
     @Test
     public void testRotateRightZeroRotation() {
         // Rotate a list by k = 0 (no rotation)
-        Node head = createLinkedList(new int[] {1, 2, 3, 4, 5});
-        Node rotated = rotator.rotateRight(head, 0);
+        SinglyLinkedListNode head = createLinkedList(new int[] {1, 2, 3, 4, 5});
+        SinglyLinkedListNode rotated = rotator.rotateRight(head, 0);
         assertEquals("1 -> 2 -> 3 -> 4 -> 5", linkedListToString(rotated));
     }
 
     @Test
     public void testRotateRightByListLength() {
         // Rotate a list by k equal to list length (no change)
-        Node head = createLinkedList(new int[] {1, 2, 3, 4, 5});
-        Node rotated = rotator.rotateRight(head, 5);
+        SinglyLinkedListNode head = createLinkedList(new int[] {1, 2, 3, 4, 5});
+        SinglyLinkedListNode rotated = rotator.rotateRight(head, 5);
         assertEquals("1 -> 2 -> 3 -> 4 -> 5", linkedListToString(rotated));
     }
 
     @Test
     public void testRotateRightByMultipleOfListLength() {
-        Node head = createLinkedList(new int[] {1, 2, 3, 4, 5});
-        Node rotated = rotator.rotateRight(head, 10); // k = 2 * list length
+        SinglyLinkedListNode head = createLinkedList(new int[] {1, 2, 3, 4, 5});
+        SinglyLinkedListNode rotated = rotator.rotateRight(head, 10); // k = 2 * list length
         assertEquals("1 -> 2 -> 3 -> 4 -> 5", linkedListToString(rotated));
     }
 
     @Test
     public void testRotateRightLongerList() {
         // Rotate a longer list by a smaller k
-        Node head = createLinkedList(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Node rotated = rotator.rotateRight(head, 4);
+        SinglyLinkedListNode head = createLinkedList(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9});
+        SinglyLinkedListNode rotated = rotator.rotateRight(head, 4);
         assertEquals("6 -> 7 -> 8 -> 9 -> 1 -> 2 -> 3 -> 4 -> 5", linkedListToString(rotated));
     }
 }

src/test/java/com/thealgorithms/datastructures/lists/SinglyLinkedListTest.java

@@ -18,9 +18,9 @@ public class SinglyLinkedListTest {
      * @return linked list with pre-defined number of nodes
      */
     private SinglyLinkedList createSampleList(int length) {
-        List<Node> nodeList = new ArrayList<>();
+        List<SinglyLinkedListNode> nodeList = new ArrayList<>();
         for (int i = 1; i <= length; i++) {
-            Node node = new Node(i);
+            SinglyLinkedListNode node = new SinglyLinkedListNode(i);
             nodeList.add(node);
         }
 
@@ -34,10 +34,10 @@ public class SinglyLinkedListTest {
     @Test
     void detectLoop() {
         // List has cycle
-        Node firstNode = new Node(1);
-        Node secondNode = new Node(2);
-        Node thirdNode = new Node(3);
-        Node fourthNode = new Node(4);
+        SinglyLinkedListNode firstNode = new SinglyLinkedListNode(1);
+        SinglyLinkedListNode secondNode = new SinglyLinkedListNode(2);
+        SinglyLinkedListNode thirdNode = new SinglyLinkedListNode(3);
+        SinglyLinkedListNode fourthNode = new SinglyLinkedListNode(4);
 
         firstNode.next = secondNode;
         secondNode.next = thirdNode;
@@ -112,13 +112,13 @@ public class SinglyLinkedListTest {
 
         // Reversing the LinkedList using reverseList() method and storing the head of the reversed
         // linkedlist in a head node The reversed linkedlist will be 4->3->2->1->null
-        Node head = list.reverseListIter(list.getHead());
+        SinglyLinkedListNode head = list.reverseListIter(list.getHead());
 
         // Recording the Nodes after reversing the LinkedList
-        Node firstNode = head; // 4
-        Node secondNode = firstNode.next; // 3
-        Node thirdNode = secondNode.next; // 2
-        Node fourthNode = thirdNode.next; // 1
+        SinglyLinkedListNode firstNode = head; // 4
+        SinglyLinkedListNode secondNode = firstNode.next; // 3
+        SinglyLinkedListNode thirdNode = secondNode.next; // 2
+        SinglyLinkedListNode fourthNode = thirdNode.next; // 1
 
         // Checking whether the LinkedList is reversed or not by comparing the original list and
         // reversed list nodes
@@ -134,10 +134,10 @@ public class SinglyLinkedListTest {
     void reverseListNullPointer() {
         // Creating a linkedlist with first node assigned to null
         SinglyLinkedList list = new SinglyLinkedList();
-        Node first = list.getHead();
+        SinglyLinkedListNode first = list.getHead();
 
         // Reversing the linkedlist
-        Node head = list.reverseListIter(first);
+        SinglyLinkedListNode head = list.reverseListIter(first);
 
         // checking whether the method works fine if the input is null
         assertEquals(head, first);
@@ -151,10 +151,10 @@ public class SinglyLinkedListTest {
 
         // Reversing the LinkedList using reverseList() method and storing the head of the reversed
         // linkedlist in a head node
-        Node head = list.reverseListIter(list.getHead());
+        SinglyLinkedListNode head = list.reverseListIter(list.getHead());
 
         // Storing the head in a temp variable, so that we cannot loose the track of head
-        Node temp = head;
+        SinglyLinkedListNode temp = head;
 
         int i = 20; // This is for the comparison of values of nodes of the reversed linkedlist
         // Checking whether the reverseList() method performed its task
@@ -171,7 +171,7 @@ public class SinglyLinkedListTest {
         SinglyLinkedList list = createSampleList(5);
 
         // Reversing the linked list using reverseList() method
-        Node head = list.reverseListRec(list.getHead());
+        SinglyLinkedListNode head = list.reverseListRec(list.getHead());
 
         // Check if the reversed list is: 5 -> 4 -> 3 -> 2 -> 1
         assertEquals(5, head.value);
@@ -185,10 +185,10 @@ public class SinglyLinkedListTest {
     void recursiveReverseListNullPointer() {
         // Create an empty linked list
         SinglyLinkedList list = new SinglyLinkedList();
-        Node first = list.getHead();
+        SinglyLinkedListNode first = list.getHead();
 
         // Reversing the empty linked list
-        Node head = list.reverseListRec(first);
+        SinglyLinkedListNode head = list.reverseListRec(first);
 
         // Check if the head remains the same (null)
         assertNull(head);
@@ -200,11 +200,11 @@ public class SinglyLinkedListTest {
         SinglyLinkedList list = createSampleList(20);
 
         // Reversing the linked list using reverseList() method
-        Node head = list.reverseListRec(list.getHead());
+        SinglyLinkedListNode head = list.reverseListRec(list.getHead());
 
         // Check if the reversed list has the correct values
         int i = 20;
-        Node temp = head;
+        SinglyLinkedListNode temp = head;
         while (temp != null && i > 0) {
             assertEquals(i, temp.value);
             temp = temp.next;