https://leetcode.com/problems/sort-list/

Author: harshitgindra

LeetCodeSolutions/DivideAndConquer/ConvertSortedArrayToBinarySearchTree.cs

@@ -1,5 +1,3 @@
-using LeetCodeSolutions.Utils;
-using NUnit.Framework;
 
 namespace LeetCodeSolutions.DivideAndConquer;
 
@@ -30,12 +28,12 @@ private TreeNode BuildTree(int[] nums, int i, int j)
         return node;
     }
 
-    [Test(Description = "https://leetcode.com/problems/count-complete-tree-nodes/")]
+    [Test(Description = "https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/")]
     [Category("Easy")]
     [Category("LeetCode")]
-    [Category("Count Complete Tree Nodes")]
+    [Category("Convert Sorted Array To Binary Search Tree")]
     [TestCaseSource(nameof(Input))]
-    [Category("BinaryTreeGeneral")]
+    [Category("DivideAndConquer")]
     [Category("TopInterview")]
     public void Test1((int?[] Output, int[] Input) item)
     {

LeetCodeSolutions/DivideAndConquer/Sort List.cs

@@ -0,0 +1,89 @@
+namespace LeetCodeSolutions.DivideAndConquer
+{
+    class SortListSolution
+    {
+        public ListNode SortList(ListNode head)
+        {
+            // Base case: empty list or single node is already sorted
+            if (head == null || head.next == null)
+            {
+                return head;
+            }
+
+            // Split the list into two halves
+            ListNode middle = GetMiddle(head);
+            ListNode right = middle.next;
+            middle.next = null; // Disconnect the two halves
+
+            // Recursively sort both halves
+            ListNode left = SortList(head);
+            right = SortList(right);
+
+            // Merge the sorted halves
+            return Merge(left, right);
+        }
+
+        // Find the middle of the linked list using slow/fast pointers
+        private ListNode GetMiddle(ListNode head)
+        {
+            ListNode slow = head;
+            ListNode fast = head.next;
+
+            while (fast != null && fast.next != null)
+            {
+                slow = slow.next;
+                fast = fast.next.next;
+            }
+
+            return slow;
+        }
+
+        // Merge two sorted linked lists
+        private ListNode Merge(ListNode left, ListNode right)
+        {
+            ListNode dummy = new ListNode();
+            ListNode current = dummy;
+
+            // Compare nodes and link them in sorted order
+            while (left != null && right != null)
+            {
+                if (left.val < right.val)
+                {
+                    current.next = left;
+                    left = left.next;
+                }
+                else
+                {
+                    current.next = right;
+                    right = right.next;
+                }
+
+                current = current.next;
+            }
+
+            // Attach remaining nodes (if any)
+            current.next = (left != null) ? left : right;
+
+            return dummy.next;
+        }
+
+        [Test(Description = "https://leetcode.com/problems/sort-list/")]
+        [Category("Medium")]
+        [Category("LeetCode")]
+        [Category("Sort List")]
+        [TestCaseSource(nameof(Input))]
+        [Category("DivideAndConquer")]
+        [Category("TopInterview")]
+        public void Test1((int?[] Output, int[] Input) item)
+        {
+            var response = SortList(item.Input.ToListNode());
+            Assert.That(response.ToArray(), Is.EqualTo(item.Output));
+        }
+
+        public static IEnumerable<(int[] Output, int[] Input)> Input =>
+            new List<(int[] Output, int[] Input)>()
+            {
+                ([-1, 0, 3, 4, 5], ( [-1, 5, 3, 4, 0])),
+            };
+    }
+}

README.md

@@ -167,7 +167,7 @@ The Top Interview 150 collection on Leetcode is a curated set of 150 interview q
 | 107                                          | Word Search                                                                                               | Medium     |        |
 | <br>        Divide &amp; Conquer<br>         |                                                                                                           |            |        |
 | 108                                          | Convert Sorted Array to Binary Search Tree                                                                | Easy       |   ✅     |
-| 109                                          | Sort List                                                                                                 | Medium     |        |
+| 109                                          | Sort List                                                                                                 | Medium     |   ✅     |
 | 110                                          | Construct Quad Tree                                                                                       | Medium     |        |
 | 111                                          | Merge k Sorted Lists                                                                                      | Hard       |        |
 | <br>        Kadane&#39;s Algorithm<br>       |                                                                                                           |            |        |