feat: add solutions to lc problem: No.0023

solution/0000-0099/0023.Merge k Sorted Lists/Solution.cpp

@@ -1,37 +1,34 @@
-/**
- * Definition for singly-linked list.
- * struct ListNode {
- *     int val;
- *     ListNode *next;
- *     ListNode() : val(0), next(nullptr) {}
- *     ListNode(int x) : val(x), next(nullptr) {}
- *     ListNode(int x, ListNode *next) : val(x), next(next) {}
- * };
- */
-class Solution {
-public:
-    ListNode* mergeKLists(vector<ListNode*>& lists) {
-        int n = lists.size();
-        if (n == 0) return nullptr;
-        for (int i = 1; i < n; ++i) lists[i] = mergeTwoLists(lists[i - 1], lists[i]);
-        return lists[n - 1];
-    }
-
-private:
-    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
-        ListNode* dummy = new ListNode();
-        ListNode* cur = dummy;
-        while (l1 && l2) {
-            if (l1->val <= l2->val) {
-                cur->next = l1;
-                l1 = l1->next;
-            } else {
-                cur->next = l2;
-                l2 = l2->next;
-            }
-            cur = cur->next;
-        }
-        cur->next = l1 ? l1 : l2;
-        return dummy->next;
-    }
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        auto cmp = [](ListNode* a, ListNode* b) { return a->val > b->val; };
+        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq;
+        for (auto head : lists) {
+            if (head) {
+                pq.push(head);
+            }
+        }
+        ListNode* dummy = new ListNode();
+        ListNode* cur = dummy;
+        while (!pq.empty()) {
+            ListNode* node = pq.top();
+            pq.pop();
+            if (node->next) {
+                pq.push(node->next);
+            }
+            cur->next = node;
+            cur = cur->next;
+        }
+        return dummy->next;
+    }
 };

solution/0000-0099/0023.Merge k Sorted Lists/Solution.cs

@@ -1,40 +1,32 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     public int val;
- *     public ListNode next;
- *     public ListNode(int val=0, ListNode next=null) {
- *         this.val = val;
- *         this.next = next;
- *     }
- * }
- */
-public class Solution {
-    public ListNode MergeKLists(ListNode[] lists) {
-        int n = lists.Length;
-        if (n == 0) {
-            return null;
-        }
-        for (int i = 1; i < n; ++i) {
-            lists[i] = MergeTwoLists(lists[i - 1], lists[i]);
-        }
-        return lists[n - 1];
-    }
-
-    private ListNode MergeTwoLists(ListNode l1, ListNode l2) {
-        ListNode dummy = new ListNode();
-        ListNode cur = dummy;
-        while (l1 != null && l2 != null) {
-            if (l1.val <= l2.val) {
-                cur.next = l1;
-                l1 = l1.next;
-            } else {
-                cur.next = l2;
-                l2 = l2.next;
-            }
-            cur = cur.next;
-        }
-        cur.next = l1 == null ? l2 : l1;
-        return dummy.next;
-    }
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode MergeKLists(ListNode[] lists) {
+        PriorityQueue<ListNode, int> pq = new PriorityQueue<ListNode, int>();
+        foreach (var head in lists) {
+            if (head != null) {
+                pq.Enqueue(head, head.val);
+            }
+        }
+        var dummy = new ListNode();
+        var cur = dummy;
+        while (pq.Count > 0) {
+            var node = pq.Dequeue();
+            cur.next = node;
+            cur = cur.next;
+            if (node.next != null) {
+                pq.Enqueue(node.next, node.next.val);
+            }
+        }
+        return dummy.next;
+    }
 }

solution/0000-0099/0023.Merge k Sorted Lists/Solution.go

@@ -5,34 +5,30 @@
  *     Next *ListNode
  * }
  */
-func mergeKLists(lists []*ListNode) *ListNode {
-	n := len(lists)
-	if n == 0 {
-		return nil
-	}
-	for i := 1; i < n; i++ {
-		lists[i] = mergeTwoLists(lists[i-1], lists[i])
+ func mergeKLists(lists []*ListNode) *ListNode {
+	pq := hp{}
+	for _, head := range lists {
+		if head != nil {
+			pq = append(pq, head)
+		}
 	}
-	return lists[n-1]
-}
-
-func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
+	heap.Init(&pq)
 	dummy := &ListNode{}
 	cur := dummy
-	for l1 != nil && l2 != nil {
-		if l1.Val <= l2.Val {
-			cur.Next = l1
-			l1 = l1.Next
-		} else {
-			cur.Next = l2
-			l2 = l2.Next
-		}
+	for len(pq) > 0 {
+		cur.Next = heap.Pop(&pq).(*ListNode)
 		cur = cur.Next
-	}
-	if l1 != nil {
-		cur.Next = l1
-	} else if l2 != nil {
-		cur.Next = l2
+		if cur.Next != nil {
+			heap.Push(&pq, cur.Next)
+		}
 	}
 	return dummy.Next
-}
+}
+
+type hp []*ListNode
+
+func (h hp) Len() int           { return len(h) }
+func (h hp) Less(i, j int) bool { return h[i].Val < h[j].Val }
+func (h hp) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *hp) Push(v any)        { *h = append(*h, v.(*ListNode)) }
+func (h *hp) Pop() any          { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }

solution/0000-0099/0023.Merge k Sorted Lists/Solution.java

@@ -1,39 +1,31 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode() {}
- *     ListNode(int val) { this.val = val; }
- *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
- * }
- */
-class Solution {
-    public ListNode mergeKLists(ListNode[] lists) {
-        int n = lists.length;
-        if (n == 0) {
-            return null;
-        }
-        for (int i = 0; i < n - 1; ++i) {
-            lists[i + 1] = mergeLists(lists[i], lists[i + 1]);
-        }
-        return lists[n - 1];
-    }
-
-    private ListNode mergeLists(ListNode l1, ListNode l2) {
-        ListNode dummy = new ListNode();
-        ListNode cur = dummy;
-        while (l1 != null && l2 != null) {
-            if (l1.val <= l2.val) {
-                cur.next = l1;
-                l1 = l1.next;
-            } else {
-                cur.next = l2;
-                l2 = l2.next;
-            }
-            cur = cur.next;
-        }
-        cur.next = l1 == null ? l2 : l1;
-        return dummy.next;
-    }
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeKLists(ListNode[] lists) {
+        PriorityQueue<ListNode> pq = new PriorityQueue<>((a, b) -> a.val - b.val);
+        for (ListNode head : lists) {
+            if (head != null) {
+                pq.offer(head);
+            }
+        }
+        ListNode dummy = new ListNode();
+        ListNode cur = dummy;
+        while (!pq.isEmpty()) {
+            ListNode node = pq.poll();
+            if (node.next != null) {
+                pq.offer(node.next);
+            }
+            cur.next = node;
+            cur = cur.next;
+        }
+        return dummy.next;
+    }
 }

solution/0000-0099/0023.Merge k Sorted Lists/Solution.js

@@ -10,29 +10,21 @@
  * @return {ListNode}
  */
 var mergeKLists = function (lists) {
-    const n = lists.length;
-    if (n == 0) {
-        return null;
-    }
-    for (let i = 1; i < n; ++i) {
-        lists[i] = mergeTwoLists(lists[i - 1], lists[i]);
+    const pq = new MinPriorityQueue({ priority: node => node.val });
+    for (const head of lists) {
+        if (head) {
+            pq.enqueue(head);
+        }
     }
-    return lists[n - 1];
-};
-
-function mergeTwoLists(l1, l2) {
     const dummy = new ListNode();
     let cur = dummy;
-    while (l1 && l2) {
-        if (l1.val <= l2.val) {
-            cur.next = l1;
-            l1 = l1.next;
-        } else {
-            cur.next = l2;
-            l2 = l2.next;
-        }
+    while (!pq.isEmpty()) {
+        const node = pq.dequeue().element;
+        cur.next = node;
         cur = cur.next;
+        if (node.next) {
+            pq.enqueue(node.next);
+        }
     }
-    cur.next = l1 || l2;
     return dummy.next;
-}
+};

solution/0000-0099/0023.Merge k Sorted Lists/Solution.py

@@ -1,27 +1,18 @@
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-class Solution:
-    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
-        n = len(lists)
-        if n == 0:
-            return None
-        for i in range(n - 1):
-            lists[i + 1] = self.mergeTwoLists(lists[i], lists[i + 1])
-        return lists[-1]
-
-    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
-        dummy = ListNode()
-        cur = dummy
-        while l1 and l2:
-            if l1.val <= l2.val:
-                cur.next = l1
-                l1 = l1.next
-            else:
-                cur.next = l2
-                l2 = l2.next
-            cur = cur.next
-        cur.next = l1 or l2
-        return dummy.next
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        setattr(ListNode, "__lt__", lambda a, b: a.val < b.val)
+        pq = [head for head in lists if head]
+        heapify(pq)
+        dummy = cur = ListNode()
+        while pq:
+            node = heappop(pq)
+            if node.next:
+                heappush(pq, node.next)
+            cur.next = node
+            cur = cur.next
+        return dummy.next