LeetCode：问题23-合并K个排序列表

Question

LeetCode上指出的问题如下：

合并k个排序的链表，并将其作为一个排序表返回。 分析并描述其复杂性。

例：

输入：[1-> 4-> 5，1-> 3-> 4，2-> 6]输出：1-> 1-> 2-> 3-> 4-> 4-> 5-> 6

我能够通过131个测试用例中的129个，但在案例130中达到“超过时间限制”。下面是我的实现。

有人可以发现瓶颈吗？ 对改善时间复杂度有何建议？

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

class Solution:
    # def print_lists(self, lists):
    #     idx = 0
    #     while idx < len(lists):
    #         ptr = lists[idx]
    #         _l = []
    #         while ptr is not None:
    #             _l.append(ptr.val)
    #             ptr = ptr.next
    #         idx += 1
    #         print(_l)

    def min_idx(self, lists):
        idx = 0

        for i in range(len(lists)):
            if lists[i] is None:
                continue
            elif lists[idx] is None:
                idx = i
            elif lists[i].val < lists[idx].val:
                idx = i
        return idx

    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        head = tail = ListNode(-1)

        while len(lists) > 0:
            m_idx = self.min_idx(lists)

            if lists[m_idx] is None:
                return head.next

            tail.next = lists[m_idx]
            tail = tail.next
            lists[m_idx] = lists[m_idx].next

            if lists[m_idx] is None:
                del lists[m_idx]

        return head.next

我在不使用del的情况下遇到了“超过时间限制”的问题。 测试用例130包含10,000个LinkedList。

Answer 1

这是您的代码的一个更简单，更快速的版本，避免了多个ifs：

def min_idx(self, lists):
    idx = 0

    for i in range(len(lists)):
        if lists[i].val < lists[idx].val:
            idx = i
    return idx

def mergeKLists(self, lists):
    head = tail = ListNode(-1)

    lists = list(filter(lambda x: x is not None, lists))

    while len(lists) > 0:
        m_idx = self.min_idx(lists)

        tail.next = lists[m_idx]
        tail = tail.next
        lists[m_idx] = lists[m_idx].next

        if lists[m_idx] is None:
            del lists[m_idx]

    return head.next

为了获得更好的时间，您将需要将实现更改为：

• 使用堆将min_idx操作减少为O（log k），而不是O（k）为列表数量的k
• 只需将所有内容放入单个数组，对其进行排序，然后将其放回ListNode中
• 将2个列表合并为O（最长列表的长度），然后成对递归合并，直到剩下1个