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

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

#单链表的定义。
#类ListNode：
#定义初始化（self，x）：
#self.val=x
#self.next=无
类解决方案：
#def打印列表（自我，列表）：
#idx=0
#当idxListNode:
头=尾=列表节点（-1）
而len（列表）>0：
m_idx=self.min_idx（列表）
如果列表[m_idx]为无：
返回头部。下一个
tail.next=列表[m_idx]
tail=tail.next
列表[m_idx]=列表[m_idx]。下一步
如果列表[m_idx]为无：
删除列表[m_idx]
返回头部。下一个

---

我在没有使用

del

的情况下遇到了“超过时间限制”的问题。测试用例130包含10000个LinkedList。

这里是一个更简单、更快的代码版本，它避免了几个IF：

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

def min_idx（自身，列表）：
idx=0
对于范围内的i（len（列表））：
如果列出[i].val<列出[idx].val:
idx=i
返回idx
def合并列表（自身、列表）：
头=尾=列表节点（-1）
列表=列表（过滤器（lambda x:x不是无，列表））
而len（列表）>0：
m_idx=self.min_idx（列表）
tail.next=列表[m_idx]
tail=tail.next
列表[m_idx]=列表[m_idx]。下一步
如果列表[m_idx]为无：
删除列表[m_idx]
返回头部。下一个

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

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

---

不要使用

del list[m_idx]

，它会将您的算法转换为二次算法。@WillemVanOnsem在有或没有delLook-into-priority队列的测试用例中失败。其思想是将每个列表的第一个元素与其来源的列表一起保留。然后重复从队列中获取最小的元素，并从其来源的列表中补充该元素

heapq.merge（）

已经实现了这一点，但使用它可能会被视为作弊，因此您可能希望更深入一层。我接受了你使用python3的代码，tle使用python^^^出于某种原因，从python3切换到python，然后返回python3解决了这个问题。有趣的地点@juvian