Merge branch 'master' into merge_k_ll_improve

Author: siriak

DIRECTORY.md

@@ -831,6 +831,7 @@
               * [CircleLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/CircleLinkedListTest.java)
               * [CreateAndDetectLoopTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/CreateAndDetectLoopTest.java)
               * [MergeKSortedLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/MergeKSortedLinkedListTest.java)
+              * [MergeSortedSinglyLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/MergeSortedSinglyLinkedListTest.java)
               * [QuickSortLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/QuickSortLinkedListTest.java)
               * [ReverseKGroupTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/ReverseKGroupTest.java)
               * [RotateSinglyLinkedListsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/RotateSinglyLinkedListsTest.java)

src/main/java/com/thealgorithms/datastructures/lists/MergeSortedSinglyLinkedList.java

@@ -1,31 +1,49 @@
 package com.thealgorithms.datastructures.lists;
 
+/**
+ * Utility class for merging two sorted singly linked lists.
+ *
+ * <p>This class extends the {@link SinglyLinkedList} class to support the merging of two sorted linked lists.
+ * It provides a static method, `merge`, that takes two sorted singly linked lists, merges them into a single sorted linked list,
+ * and returns the result.</p>
+ *
+ * <p>Example usage:</p>
+ * <pre>
+ * SinglyLinkedList listA = new SinglyLinkedList();
+ * SinglyLinkedList listB = new SinglyLinkedList();
+ * for (int i = 2; i <= 10; i += 2) {
+ *     listA.insert(i);   // listA: 2->4->6->8->10
+ *     listB.insert(i - 1); // listB: 1->3->5->7->9
+ * }
+ * SinglyLinkedList mergedList = MergeSortedSinglyLinkedList.merge(listA, listB);
+ * System.out.println(mergedList); // Output: 1->2->3->4->5->6->7->8->9->10
+ * </pre>
+ *
+ * <p>The `merge` method assumes that both input lists are already sorted in ascending order.
+ * It returns a new singly linked list that contains all elements from both lists in sorted order.</p>
+ *
+ * @see SinglyLinkedList
+ */
 public class MergeSortedSinglyLinkedList extends SinglyLinkedList {
 
-    public static void main(String[] args) {
-        SinglyLinkedList listA = new SinglyLinkedList();
-        SinglyLinkedList listB = new SinglyLinkedList();
-
-        for (int i = 2; i <= 10; i += 2) {
-            listA.insert(i);
-            listB.insert(i - 1);
-        }
-        assert listA.toString().equals("2->4->6->8->10");
-        assert listB.toString().equals("1->3->5->7->9");
-        assert merge(listA, listB).toString().equals("1->2->3->4->5->6->7->8->9->10");
-    }
-
     /**
-     * Merge two sorted SingleLinkedList
+     * Merges two sorted singly linked lists into a single sorted singly linked list.
+     *
+     * <p>This method does not modify the input lists; instead, it creates a new merged linked list
+     * containing all elements from both lists in sorted order.</p>
      *
-     * @param listA the first sorted list
-     * @param listB the second sored list
-     * @return merged sorted list
+     * @param listA The first sorted singly linked list.
+     * @param listB The second sorted singly linked list.
+     * @return A new singly linked list containing all elements from both lists in sorted order.
+     * @throws NullPointerException if either input list is null.
      */
     public static SinglyLinkedList merge(SinglyLinkedList listA, SinglyLinkedList listB) {
+        if (listA == null || listB == null) {
+            throw new NullPointerException("Input lists must not be null.");
+        }
+
         Node headA = listA.getHead();
         Node headB = listB.getHead();
-
         int size = listA.size() + listB.size();
 
         Node head = new Node();
@@ -40,12 +58,10 @@ public static SinglyLinkedList merge(SinglyLinkedList listA, SinglyLinkedList li
             }
             tail = tail.next;
         }
-        if (headA == null) {
-            tail.next = headB;
-        }
-        if (headB == null) {
-            tail.next = headA;
-        }
+
+        // Attach remaining nodes
+        tail.next = (headA == null) ? headB : headA;
+
         return new SinglyLinkedList(head.next, size);
     }
 }

src/main/java/com/thealgorithms/datastructures/lists/QuickSortLinkedList.java

@@ -104,36 +104,52 @@
 
 public class QuickSortLinkedList {
 
-    private SinglyLinkedList list = null; // Linked list
-    private Node head = null; // head of the list
-    // Counstructor
+    private final SinglyLinkedList list; // The linked list to be sorted
+    private Node head; // Head of the list
+
+    /**
+     * Constructor that initializes the QuickSortLinkedList with a given linked list.
+     *
+     * @param list The singly linked list to be sorted
+     */
     public QuickSortLinkedList(SinglyLinkedList list) {
         this.list = list;
         this.head = list.getHead();
     }
 
-    // Function to sort a linked list using the Quick Sort algorithm
+    /**
+     * Sorts the linked list using the QuickSort algorithm.
+     * The sorted list replaces the original list within the SinglyLinkedList instance.
+     */
     public void sortList() {
         head = sortList(head);
         list.setHead(head);
     }
-    // helper function to apply QuickSort to the stored list
-    public Node sortList(Node head) {
+
+    /**
+     * Recursively sorts a linked list by partitioning it around a pivot element.
+     *
+     * <p>Each recursive call selects a pivot, partitions the list into elements less
+     * than the pivot and elements greater than or equal to the pivot, then combines
+     * the sorted sublists around the pivot.</p>
+     *
+     * @param head The head node of the list to sort
+     * @return The head node of the sorted linked list
+     */
+    private Node sortList(Node head) {
         if (head == null || head.next == null) {
             return head;
         }
 
-        // Choose the first element as the pivot
         Node pivot = head;
         head = head.next;
         pivot.next = null;
 
-        Node lessHead = new Node(); // stores the nodes cantaining data less than pivot node
-        Node lessTail = lessHead; // tail of lessHead
-        Node greaterHead = new Node(); // stores the nodes cantaining data greater than pivot node
-        Node greaterTail = greaterHead; // tail of greaterHead
+        Node lessHead = new Node();
+        Node lessTail = lessHead;
+        Node greaterHead = new Node();
+        Node greaterTail = greaterHead;
 
-        // Partition the list around the pivot
         while (head != null) {
             if (head.value < pivot.value) {
                 lessTail.next = head;
@@ -145,15 +161,12 @@ public Node sortList(Node head) {
             head = head.next;
         }
 
-        // Seperating lessHead and greaterHead to form two seperate linkedList
         lessTail.next = null;
         greaterTail.next = null;
 
-        // Recursively sort the sublists
         Node sortedLess = sortList(lessHead.next);
         Node sortedGreater = sortList(greaterHead.next);
 
-        // Combine the sorted sublists and pivot
         if (sortedLess == null) {
             pivot.next = sortedGreater;
             return pivot;

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

@@ -0,0 +1,90 @@
+package com.thealgorithms.datastructures.lists;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+class MergeSortedSinglyLinkedListTest {
+
+    @Test
+    void testMergeTwoSortedLists() {
+        SinglyLinkedList listA = new SinglyLinkedList();
+        SinglyLinkedList listB = new SinglyLinkedList();
+
+        for (int i = 2; i <= 10; i += 2) {
+            listA.insert(i);
+            listB.insert(i - 1);
+        }
+
+        SinglyLinkedList mergedList = MergeSortedSinglyLinkedList.merge(listA, listB);
+        assertEquals("1->2->3->4->5->6->7->8->9->10", mergedList.toString(), "Merged list should contain all elements in sorted order.");
+    }
+
+    @Test
+    void testMergeWithEmptyListA() {
+        SinglyLinkedList listA = new SinglyLinkedList(); // Empty listA
+        SinglyLinkedList listB = new SinglyLinkedList();
+        listB.insert(1);
+        listB.insert(3);
+        listB.insert(5);
+
+        SinglyLinkedList mergedList = MergeSortedSinglyLinkedList.merge(listA, listB);
+        assertEquals("1->3->5", mergedList.toString(), "Merged list should match listB when listA is empty.");
+    }
+
+    @Test
+    void testMergeWithEmptyListB() {
+        SinglyLinkedList listA = new SinglyLinkedList();
+        SinglyLinkedList listB = new SinglyLinkedList(); // Empty listB
+        listA.insert(2);
+        listA.insert(4);
+        listA.insert(6);
+
+        SinglyLinkedList mergedList = MergeSortedSinglyLinkedList.merge(listA, listB);
+        assertEquals("2->4->6", mergedList.toString(), "Merged list should match listA when listB is empty.");
+    }
+
+    @Test
+    void testMergeWithBothEmptyLists() {
+        SinglyLinkedList listA = new SinglyLinkedList(); // Empty listA
+        SinglyLinkedList listB = new SinglyLinkedList(); // Empty listB
+
+        SinglyLinkedList mergedList = MergeSortedSinglyLinkedList.merge(listA, listB);
+        assertEquals("", mergedList.toString(), "Merged list should be empty when both input lists are empty.");
+    }
+
+    @Test
+    void testMergeWithDuplicateValues() {
+        SinglyLinkedList listA = new SinglyLinkedList();
+        SinglyLinkedList listB = new SinglyLinkedList();
+
+        listA.insert(1);
+        listA.insert(3);
+        listA.insert(5);
+        listB.insert(1);
+        listB.insert(4);
+        listB.insert(5);
+
+        SinglyLinkedList mergedList = MergeSortedSinglyLinkedList.merge(listA, listB);
+        assertEquals("1->1->3->4->5->5", mergedList.toString(), "Merged list should include duplicate values in sorted order.");
+    }
+
+    @Test
+    void testMergeThrowsExceptionOnNullInput() {
+        SinglyLinkedList listA = null;
+        SinglyLinkedList listB = new SinglyLinkedList();
+        listB.insert(1);
+        listB.insert(2);
+
+        SinglyLinkedList finalListA = listA;
+        SinglyLinkedList finalListB = listB;
+        assertThrows(NullPointerException.class, () -> MergeSortedSinglyLinkedList.merge(finalListA, finalListB), "Should throw NullPointerException if listA is null.");
+
+        listA = new SinglyLinkedList();
+        listB = null;
+        SinglyLinkedList finalListA1 = listA;
+        SinglyLinkedList finalListB1 = listB;
+        assertThrows(NullPointerException.class, () -> MergeSortedSinglyLinkedList.merge(finalListA1, finalListB1), "Should throw NullPointerException if listB is null.");
+    }
+}

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

@@ -4,8 +4,9 @@
 import static org.junit.jupiter.api.Assertions.assertNull;
 
 import org.junit.jupiter.api.Test;
+
 /**
- * Test cases for QuickSortLinkedList
+ * Test cases for QuickSortLinkedList.
  * Author: Prabhat-Kumar-42
  * GitHub: https://github.com/Prabhat-Kumar-42
  */
@@ -16,9 +17,8 @@ public void testSortEmptyList() {
         SinglyLinkedList emptyList = new SinglyLinkedList();
         QuickSortLinkedList sorter = new QuickSortLinkedList(emptyList);
 
-        // Test case: Sorting an empty list should result in an empty list
         sorter.sortList();
-        assertNull(emptyList.getHead());
+        assertNull(emptyList.getHead(), "Sorted empty list should have no elements.");
     }
 
     @Test
@@ -27,10 +27,51 @@ public void testSortSingleNodeList() {
         singleNodeList.insert(5);
         QuickSortLinkedList sorter = new QuickSortLinkedList(singleNodeList);
 
-        // Test case: Sorting a list with a single node should result in the same list
         sorter.sortList();
-        assertEquals(5, singleNodeList.getHead().value);
-        assertNull(singleNodeList.getHead().next);
+        assertEquals(5, singleNodeList.getHead().value, "Single node list should remain unchanged after sorting.");
+        assertNull(singleNodeList.getHead().next, "Single node should not have a next node.");
+    }
+
+    @Test
+    public void testSortAlreadySorted() {
+        SinglyLinkedList sortedList = new SinglyLinkedList();
+        sortedList.insert(1);
+        sortedList.insert(2);
+        sortedList.insert(3);
+        sortedList.insert(4);
+        sortedList.insert(5);
+        QuickSortLinkedList sorter = new QuickSortLinkedList(sortedList);
+
+        sorter.sortList();
+        assertEquals("1->2->3->4->5", sortedList.toString(), "Already sorted list should remain unchanged.");
+    }
+
+    @Test
+    public void testSortReverseOrderedList() {
+        SinglyLinkedList reverseList = new SinglyLinkedList();
+        reverseList.insert(5);
+        reverseList.insert(4);
+        reverseList.insert(3);
+        reverseList.insert(2);
+        reverseList.insert(1);
+        QuickSortLinkedList sorter = new QuickSortLinkedList(reverseList);
+
+        sorter.sortList();
+        assertEquals("1->2->3->4->5", reverseList.toString(), "Reverse ordered list should be sorted in ascending order.");
+    }
+
+    @Test
+    public void testSortWithDuplicates() {
+        SinglyLinkedList listWithDuplicates = new SinglyLinkedList();
+        listWithDuplicates.insert(3);
+        listWithDuplicates.insert(1);
+        listWithDuplicates.insert(3);
+        listWithDuplicates.insert(2);
+        listWithDuplicates.insert(2);
+        QuickSortLinkedList sorter = new QuickSortLinkedList(listWithDuplicates);
+
+        sorter.sortList();
+        assertEquals("1->2->2->3->3", listWithDuplicates.toString(), "List with duplicates should be sorted correctly.");
     }
 
     @Test
@@ -48,18 +89,7 @@ public void testSortMultipleElementsList() {
         list.insert(6);
         QuickSortLinkedList sorter = new QuickSortLinkedList(list);
 
-        // Test case: Sorting a list with multiple elements
         sorter.sortList();
-        assertEquals(1, list.getHead().value);
-        assertEquals(2, list.getHead().next.value);
-        assertEquals(3, list.getHead().next.next.value);
-        assertEquals(4, list.getHead().next.next.next.value);
-        assertEquals(5, list.getHead().next.next.next.next.value);
-        assertEquals(6, list.getHead().next.next.next.next.next.value);
-        assertEquals(7, list.getHead().next.next.next.next.next.next.value);
-        assertEquals(8, list.getHead().next.next.next.next.next.next.next.value);
-        assertEquals(9, list.getHead().next.next.next.next.next.next.next.next.value);
-        assertEquals(10, list.getHead().next.next.next.next.next.next.next.next.next.value);
-        assertNull(list.getHead().next.next.next.next.next.next.next.next.next.next);
+        assertEquals("1->2->3->4->5->6->7->8->9->10", list.toString(), "List should be sorted in ascending order.");
     }
 }