LeetCode 23. Merge k Sorted Lists

Priority Queue | Linked List

You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.

Merge all the linked-lists into one sorted linked-list and return it.

Example 1:

Input: lists = [[1,4,5],[1,3,4],[2,6]]
Output: [1,1,2,3,4,4,5,6]
Explanation: The linked-lists are:
[
  1->4->5,
  1->3->4,
  2->6
]
merging them into one sorted list:
1->1->2->3->4->4->5->6

Example 2:

Input: lists = []
Output: []

Example 3:

Input: lists = [[]]
Output: []

Constraints:

• k == lists.length

• 0 <= k <= 10^4

• 0 <= lists[i].length <= 500

• -10^4 <= lists[i][j] <= 10^4

• lists[i] is sorted in ascending order.

• The sum of lists[i].length won't exceed 10^4.

Solution:

English Version in Youtube

中文版解答Youtube Link

中文版解答Bilibili Link

class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        auto cmp = [] (ListNode *n1, ListNode *n2) {
            return n1->val > n2->val;
        };
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> nodes(cmp);
        for (ListNode *list : lists) {
            if (list != nullptr) {
                nodes.push(list);
            }
        }
        
        if (nodes.empty()) {
            return nullptr;
        }
        ListNode fake_head(0);
        ListNode* current = &fake_head;
        
        while (!nodes.empty()) {
            current->next = nodes.top();
            current = current->next;
            nodes.pop();
            if (current->next != nullptr) {
                nodes.push(current->next);
            }
        }
        
        return fake_head.next;
    }
};