---
description: Priority Queue | Linked List
---

# LeetCode 23. Merge k Sorted Lists

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](https://youtu.be/Xequ4LCiHgM)

[中文版解答Youtube Link](https://youtu.be/BHoY6wjfx4g)

[中文版解答Bilibili Link](https://www.bilibili.com/video/BV1ki4y1T77r/)

```
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;
    }
};
```

