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

Author: harshitgindra

EasyProblems/ConvertSortedArrayToBinarySearchTree.cs

@@ -29,10 +29,10 @@ 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))]
     public void Test1((int?[] Output, int[] Input) item)
     {

MediumProblems/Sort List.cs

@@ -3,39 +3,88 @@
 
 namespace LeetCode.MediumProblems
 {
-    class Sort_List
+    class SortListSolution
     {
-        /// <summary>
-        /// https://leetcode.com/problems/sort-list/
-        /// </summary>
-        /// <param name="head"></param>
-        /// <returns></returns>
         public ListNode SortList(ListNode head)
         {
-            List<int> nums = new List<int>();
-            Read(head, nums);
+            // 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);
 
-            nums = nums.OrderByDescending(x => x).ToList();
+            // 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;
 
-            ListNode currNode = default, prevNode = new ListNode();
-            int i = 0;
-            while (i < nums.Count)
+            while (fast != null && fast.next != null)
             {
-                prevNode = currNode;
-                currNode = new ListNode(nums[i], prevNode);
-                i++;
+                slow = slow.next;
+                fast = fast.next.next;
             }
 
-            return currNode;
+            return slow;
         }
 
-        private void Read(ListNode node, List<int> result)
+        // Merge two sorted linked lists
+        private ListNode Merge(ListNode left, ListNode right)
         {
-            if (node != null)
+            ListNode dummy = new ListNode();
+            ListNode current = dummy;
+
+            // Compare nodes and link them in sorted order
+            while (left != null && right != null)
             {
-                result.Add(node.val);
-                Read(node.next, result);
+                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))]
+        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])),
+            };
     }
-}
+}