要合并k个排序列表，合并所有列表然后在最后排序是不是很糟糕？这是作弊吗？

Question

我遇到了合并k个排序列表的问题，我的解决方案只是创建一个包含所有元素的数组并对数组进行排序。我认为这个解决方案有O（n log n）时间（这似乎是你可以用这个问题做的最好的）。但也许我错了。这在某种程度上不是正确的解决方案或不是最佳的？我问的原因是因为这在Leetcode上被标记为“硬”问题所以我预计会有一些复杂性我没有考虑到，或者这不是问题的意图。

# Definition for singly-linked list.
# class ListNode
#     attr_accessor :val, :next
#     def initialize(val)
#         @val = val
#         @next = nil
#     end
# end

# @param {ListNode[]} lists
# @return {ListNode}
def merge_k_lists(lists)
    final_list = []
    lists.each do |list|
        while list
            final_list << list.val
            list = list.next
        end
    end
    final_list.sort!
end

编辑： 现在有意义的是，最好的算法可以是O（n log k），并且可以使用最小堆来完成。分而治之是否会给出相同的时间复杂性？

这是我的分而治之的解决方案，结果比我以前的解决方案要慢得多。 （这个不是一个公认的解决方案，因为它超过了时间限制）

def merge_k_lists(lists)
    lists.compact!
    return lists.first if lists.length == 1
    if lists.length > 2
        new_lists = []
        mid = lists.length/2
        new_lists << merge_k_lists(lists[0...2])
        new_lists << merge_k_lists(lists[2..-1])
        lists = new_lists
    end
    list_a = lists.first
    list_b = lists.last
    root = nil
    last_node = nil
    while list_a || list_b
        if !list_b.nil? && (list_a.nil? || list_a.val > list_b.val)
            list_b, list_a = list_a, list_b 
        end
        node = ListNode.new(list_a.val)
        list_a = list_a.next
        if last_node
            last_node.next = node
            last_node = node
        else
            root = node
            last_node = node
        end
    end
    return root
end