https://leetcode.com/problems/merge-k-sorted-lists/

Author: harshitgindra

HardProblems/Merge k Sorted Lists.cs

@@ -1,110 +1,75 @@
-using LeetCode.SharedUtils;
-
-
-namespace LeetCode.Hard
+namespace LeetCode.HardProblems
 {
-    //https://leetcode.com/problems/merge-k-sorted-lists/submissions/
-    class Merge_k_Sorted_Lists
+    class MergeKSortedLists
     {
         public ListNode MergeKLists(ListNode[] lists)
         {
-            if (lists != null && lists.Length > 0)
-            {
-                if (lists.Length == 1)
-                {
-                    return lists[0];
-                }
-                else
-                {
-                    var currNode = lists[0];
-
-                    for (int i = 1; i < lists.Length; i++)
-                    {
-                        currNode = Merge(currNode, lists[i]);
-                    }
+            // Handle edge cases
+            if (lists == null || lists.Length == 0) return null;
 
-                    return currNode;
-                }
-            }
-            else
-            {
-                return null;
-            }
+            // Start the divide-and-conquer process
+            return MergeDivideAndConquer(lists, 0, lists.Length - 1);
         }
 
-        private ListNode Merge(ListNode node1, ListNode node2)
+        private ListNode MergeDivideAndConquer(ListNode[] lists, int left, int right)
         {
-            ListNode returnValue = new ListNode(0);
-            var curr = returnValue;
+            // Base case: only one list in the current range
+            if (left == right) return lists[left];
 
-            while (node1 != null && node2 != null)
-            {
-                if (node1 != null && node2 != null)
-                {
-                    if (node1.val < node2.val)
-                    {
-                        curr.next = node1;
-                        node1 = node1.next;
-                    }
-                    else
-                    {
-                        curr.next = node2;
-                        node2 = node2.next;
-                    }
-                }
+            // Divide the problem into two halves
+            int mid = left + (right - left) / 2;
+            ListNode leftList = MergeDivideAndConquer(lists, left, mid);
+            ListNode rightList = MergeDivideAndConquer(lists, mid + 1, right);
 
-                curr = curr.next;
-            }
-
-            if (node1 == null)
-            {
-                curr.next = node2;
-            }
-
-            if (node2 == null)
-            {
-                curr.next = node1;
-            }
-
-            return returnValue.next;
+            // Merge the two halves
+            return MergeTwoLists(leftList, rightList);
         }
 
-        public ListNode MergeKLists2(ListNode[] lists)
+        private ListNode MergeTwoLists(ListNode l1, ListNode l2)
         {
-            if (lists != null || lists.Count() > 0)
+            // Create a dummy head to simplify edge cases
+            ListNode dummy = new ListNode();
+            ListNode current = dummy;
+
+            // Compare and link nodes in sorted order
+            while (l1 != null && l2 != null)
             {
-                List<int> vals = new List<int>();
-                foreach (var item in lists)
+                if (l1.val <= l2.val)
                 {
-                    vals = Read(item, vals);
+                    current.next = l1;
+                    l1 = l1.next;
                 }
-
-                var orderedList = vals.OrderBy(x => x).ToArray();
-
-                ListNode currNode = default, prevNode = default;
-                for (int i = orderedList.Length - 1; i >= 0; i--)
+                else
                 {
-                    prevNode = currNode;
-                    currNode = new ListNode(orderedList[i], prevNode);
+                    current.next = l2;
+                    l2 = l2.next;
                 }
 
-                return currNode;
-            }
-            else
-            {
-                return default;
+                current = current.next;
             }
+
+            // Attach remaining nodes (if any)
+            current.next = (l1 != null) ? l1 : l2;
+
+            return dummy.next;
         }
 
-        private List<int> Read(ListNode node, List<int> val)
-        {
-            if (node != null)
-            {
-                val.Add(node.val);
-                val = Read(node.next, val);
-            }
 
-            return val;
+        [Test(Description = "https://leetcode.com/problems/merge-k-sorted-lists/")]
+        [Category("Hard")]
+        [Category("LeetCode")]
+        [Category("Merge K Sorted Lists")]
+        [TestCaseSource(nameof(Input))]
+        public void Test1((int[] Output, int[][] Input) item)
+        {
+            var response = MergeKLists(item.Input.Select(x => x.ToListNode()).ToArray());
+            Assert.That(response.ToArray(), Is.EqualTo(item.Output));
         }
+
+        public static IEnumerable<(int[] Output, int[][] Input)> Input =>
+            new List<(int[] Output, int[][] Input)>()
+            {
+                ([1, 1, 2, 3, 4, 4, 5, 6], ( [[1, 4, 5], [1, 3, 4], [2, 6]])),
+            };
     }
 }

MediumProblems/Sort List.cs

@@ -1,7 +1,4 @@
-using LeetCode.SharedUtils;
-
-
-namespace LeetCode.MediumProblems
+namespace LeetCode.MediumProblems
 {
     class SortListSolution
     {
@@ -75,7 +72,7 @@ private ListNode Merge(ListNode left, ListNode right)
         [Category("LeetCode")]
         [Category("Sort List")]
         [TestCaseSource(nameof(Input))]
-        public void Test1((int?[] Output, int[] Input) item)
+        public void Test1((int[] Output, int[] Input) item)
         {
             var response = SortList(item.Input.ToListNode());
             Assert.That(response.ToArray(), Is.EqualTo(item.Output));