23. Merge k Sorted Lists

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.

 

  

 

 

import heapq
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        
        def __lt__(self,other):
            return self.val < other.val
        ListNode.__lt__ = __lt__
        if not lists:
            return None
        # 虚拟头结点
        dummy = ListNode(-1)
        p = dummy
        # 优先级队列，最小堆
        pq = []
        for i in range(len(lists)):
            head = lists[i]
            if head:
                heapq.heappush(pq, head)

        while pq:
            # 获取最小节点，接到结果链表中
            node = heapq.heappop(pq)
            p.next = node
            if node.next:
                heapq.heappush(pq, node.next)
            # p 指针不断前进
            p = p.next
        return dummy.next

 

 

 

 

 

 

 

一、暴力：遍历合并2个有序数组。

/**
 * 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* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* fakehead = new ListNode(0);
        ListNode* head = fakehead;
        while(l1 != nullptr && l2 != nullptr) {
            if(l1->val < l2->val) {
                head->next = l1;
                l1 = l1->next;            
            } else {
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }

        if(l1 != nullptr ) {
            head->next = l1;
        }
        if(l2 != nullptr) {
            head->next = l2;
        }
        return fakehead->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* head = nullptr;
        for(int i = 0;i < lists.size();++i) {
            head = mergeTwoLists(head,lists[i]);
        }
        return head;
    }
};

 

 

 

二、分治

两两合并

【1，2，3】、【2，4，6】【2，4，6】【1，5，7】

 

【1，2，3】、【2，4，6】  【2，4，6】【1，5，7】

 1，2，2，3，4，6         1，2，4，5，6，7

 

1，1，2，2，2，2，3，4，4，5，6，6，7

 

 

/**
 * 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* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* fakehead = new ListNode(0);
        ListNode* head = fakehead;
        while(l1 != nullptr && l2 != nullptr) {
            if(l1->val < l2->val) {
                head->next = l1;
                l1 = l1->next;            
            } else {
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }

        if(l1 != nullptr ) {
            head->next = l1;
        }
        if(l2 != nullptr) {
            head->next = l2;
        }
        return fakehead->next;
    }
    ListNode* merge(vector<ListNode*>& lists, int low, int high) {
        if(low == high) return lists[low];
        if(low>high) return nullptr;
        int mid = low + (high-low)/2;
        auto a1 = merge(lists,low,mid);
        auto a2 = merge(lists,mid+1,high);
        return mergeTwoLists(a1,a2);
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists,0,lists.size()-1);
    }
};