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

Author: harshitgindra

LeetCodeSolutions/BitManipulation/AddBinary.cs

@@ -1,6 +1,3 @@
-using NUnit.Framework;
-using NUnit.Framework.Legacy;
-
 namespace LeetCodeSolutions.BitManipulation;
 
 public class Add_Binary
@@ -11,15 +8,15 @@ public string AddBinary(string a, string b)
         int ib = b.Length - 1;
         string returnValue = "";
         char carry = '0';
-        
+
         while (ia >= 0 || ib >= 0)
         {
             var tempA = '0';
             if (ia >= 0)
             {
                 tempA = a[ia];
             }
-            
+
             var tempB = '0';
             if (ib >= 0)
             {
@@ -30,15 +27,16 @@ public string AddBinary(string a, string b)
 
             carry = result.carry;
             returnValue = $"{result.sum}{returnValue}";
-            
+
             ia--;
             ib--;
         }
-        
+
         if (carry != '0')
         {
             returnValue = $"{carry}{returnValue}";
         }
+
         return returnValue;
     }
 

LeetCodeSolutions/BitManipulation/Single_Number.cs

@@ -1,15 +1,9 @@
-using NUnit.Framework;
-
-namespace LeetCode
+namespace LeetCodeSolutions.BitManipulation
 {
-    /// <summary>
-    /// https://leetcode.com/problems/single-number/
-    /// </summary>
-    public class Single_Number
+    public class SingleNumberSolution
     {
         public int SingleNumber(int[] nums)
         {
-
             if (nums == null || nums.Length % 2 == 0)
             {
                 return 0;
@@ -44,4 +38,4 @@ public void Test1((int Output, int[] Input) item)
                 (4, [4, 1, 2, 1, 2]),
             };
     }
-}
+}

LeetCodeSolutions/DivideAndConquer/ConvertSortedArrayToBinarySearchTree.cs

@@ -1,9 +1,6 @@
 
 namespace LeetCodeSolutions.DivideAndConquer;
 
-/// <summary>
-/// https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/
-/// </summary>
 public class ConvertSortedArrayToBinarySearchTree
 {
     public TreeNode SortedArrayToBST(int[] nums)

LeetCodeSolutions/DivideAndConquer/Merge k Sorted Lists.cs

@@ -0,0 +1,77 @@
+namespace LeetCodeSolutions.DivideAndConquer
+{
+    class MergeKSortedLists
+    {
+        public ListNode MergeKLists(ListNode[] lists)
+        {
+            // Handle edge cases
+            if (lists == null || lists.Length == 0) return null;
+
+            // Start the divide-and-conquer process
+            return MergeDivideAndConquer(lists, 0, lists.Length - 1);
+        }
+
+        private ListNode MergeDivideAndConquer(ListNode[] lists, int left, int right)
+        {
+            // Base case: only one list in the current range
+            if (left == right) return lists[left];
+
+            // 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);
+
+            // Merge the two halves
+            return MergeTwoLists(leftList, rightList);
+        }
+
+        private ListNode MergeTwoLists(ListNode l1, ListNode l2)
+        {
+            // 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)
+            {
+                if (l1.val <= l2.val)
+                {
+                    current.next = l1;
+                    l1 = l1.next;
+                }
+                else
+                {
+                    current.next = l2;
+                    l2 = l2.next;
+                }
+
+                current = current.next;
+            }
+
+            // Attach remaining nodes (if any)
+            current.next = (l1 != null) ? l1 : l2;
+
+            return dummy.next;
+        }
+
+
+        [Test(Description = "https://leetcode.com/problems/merge-k-sorted-lists/")]
+        [Category("Hard")]
+        [Category("LeetCode")]
+        [Category("Merge K Sorted Lists")]
+        [TestCaseSource(nameof(Input))]
+        [Category("DivideAndConquer")]
+        [Category("TopInterview")]
+        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]])),
+            };
+    }
+}

LeetCodeSolutions/DivideAndConquer/Sort List.cs

@@ -74,7 +74,7 @@ private ListNode Merge(ListNode left, ListNode right)
         [TestCaseSource(nameof(Input))]
         [Category("DivideAndConquer")]
         [Category("TopInterview")]
-        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));

README.md

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