LeetCode 23 - 合并k个排序链表

题目描述

23. 合并K个排序链表

解法一：辅存（Python）

• 遍历所有链表，将所有节点的值放到一个数组中。
• 将这个数组排序，然后遍历所有元素得到正确顺序的值。
• 用遍历得到的值，创建一个新的有序链表。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        self.nodes = []
        head = point = ListNode(0)
        for l in lists:
            while l:
                self.nodes.append(l.val)
                l = l.next
        for x in sorted(self.nodes):
            point.next = ListNode(x)
            point = point.next 
        return head.next 

解法二：最小优先队列

时间复杂度：$O(N\log k)$，其中$k$是链表的数目

弹出操作时，比较操作的代价会被优化到 $O(\log k)$。同时，找到最小值节点的时间开销仅仅为 $O(1)$
最后的链表中总共有 $N$ 个节点

Python实现

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        import heapq
        que = []
        # 先取各链表的头节点放入最小堆中
        for index, node in enumerate(lists):
            if node != None:
                heapq.heappush(que, (node.val, index))
        
        dummy_node = ListNode(-1)
        cur = dummy_node
        while que:
            val, index = heapq.heappop(que)
            cur.next = lists[index]
            cur = cur.next
            lists[index] = lists[index].next
            if lists[index] != None:
                heapq.heappush(que, (lists[index].val, index))
        return dummy_node.next

关于Python heapq的内容参考 heapq — 堆队列算法

C++实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    struct cmp{
        bool operator()(ListNode* a, ListNode* b){
            return a->val > b->val;
        }
    };

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, cmp> heapk;
        for(auto p:lists)
        {
            if(p!=NULL) heapk.push(p);
        }
        ListNode* phead = new ListNode(-1);
        ListNode* pcur = phead;
        while(!heapk.empty())
        {
            ListNode* top = heapk.top();
            heapk.pop();
            pcur->next = top;
            pcur = pcur->next;
            if(top->next!=NULL) heapk.push(top->next);
        }
        return phead->next;
    }
};

关于C++ priority_queue和运算符重载的内容参考 c++优先队列(priority_queue)用法详解

解法三：分治

• 将 $k$ 个链表配对并将同一对中的链表合并。
• 第一轮合并以后，$k$ 个链表被合并成了 $\frac{k}{2}$ 个链表，平均长度为 $\frac{2N}{k}k$，然后是 $\frac{k}{4}$个链表， $\frac{k}{8}$个链表等等
• 重复这一过程，直到我们得到了最终的有序链表。

因此，我们在每一次配对合并的过程中都会遍历几乎全部 $N$ 个节点，并重复这一过程 ${\log }_{2}K$

时间复杂度： $O(N\log k)$ ，其中 $k$ 是链表的数目

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        if not lists: return None 
        n = len(lists)
        return self.merge(lists, 0, n-1)
    
    def merge(self, lists, left, right):
        if left == right: return lists[left]
        mid = left + (right - left) // 2
        list1 = self.merge(lists, left, mid)
        list2 = self.merge(lists, mid + 1, right)
        return self.mergeTwoLists(list1, list2)

    def mergeTwoLists(self, list1, list2):
        if not list1: return list2
        if not list2: return list1
        if list1.val < list2.val:
            list1.next = self.mergeTwoLists(list1.next, list2)
            return list1
        else:
            list2.next = self.mergeTwoLists(list1, list2.next)
            return list2

C++实现

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int n = lists.size();
        if(!n) return NULL;
        return mergeTwoLists(lists, 0, n-1);
    }

    ListNode* mergeTwoLists(vector<ListNode*>& lists, int begin, int end){
        if(begin==end) return lists[begin];
        else
        {
            int mid = begin+(end-begin)/2;
            ListNode* list1 = mergeTwoLists(lists, begin, mid);
            ListNode* list2 = mergeTwoLists(lists, mid+1, end);
            ListNode* dummy = new ListNode(-1);
            ListNode* cur = dummy;
            while(list1 && list2)
            {
                if(list1->val<list2->val)
                {
                    cur->next = list1;
                    list1 = list1->next;
                }
                else
                {
                    cur->next = list2;
                    list2 = list2->next;
                }
                cur = cur->next;
            }
            cur->next = list1?list1:list2;
            return dummy->next;
        }
    }
};