LeetCode Merge k Sorted Lists

问题网址：https://leetcode.com/problems/merge-k-sorted-lists/description/

问题描述：
合并k个已排序的链接列表并将其作为一个排序列表返回。 分析并描述其复杂性。

蛮力方法

遍历所有链表，并将节点的值收集到一个数组中。
对这个数组进行排序和迭代以获得适当的节点值。
创建一个新的排序链接列表，并用新节点扩展它。

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: 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（NlogN）其中N是节点的总数。
收集所有值O（N）时间。
稳定的排序算法花费O（NlogN）时间。
迭代创建链表需要花费O（N）时间。
空间复杂度：O（N）。
排序成本O（N）空间（取决于您选择的算法）。
创建一个新的链表要花费O（N）空间。

逐一比较方法

比较每个 k个节点（每个链表的头部），得到最小值的节点。
用选定的节点扩展最终的排序链表。

复杂性分析

时间复杂度：O（kN）其中k是链接列表的数量。
几乎每个节点在最终的链接成本中选择O（k）（k-1次比较）。
最终链表中有N节点。
空间复杂性：
O（n）创建新的链接列表花费O（n）空间。
O（1）应用就地方法并不难 - 连接选定的节点，而不是创建新的节点来填充新的链接列表。

通过优先级队列优化方法2

几乎与上面的一样，但通过优先级队列来优化比较过程。

from Queue import PriorityQueue

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        head = point = ListNode(0)
        q = PriorityQueue()
        for l in lists:
            if l:
                q.put((l.val, l))
        while not q.empty():
            val, node = q.get()
            point.next = ListNode(val)
            point = point.next
            node = node.next
            if node:
                q.put((node.val, node))
        return head.next

复杂性分析

时间复杂度：O（Nlogk）其中k是链接列表的数量。
对于每个弹出和插入优先级队列，比较成本将减少到O（logk）。 但是找到最小值的节点只需花费O（1）次。
最终链表中有N节点。
空间复杂性：
O（n）创建新的链接列表花费O（n）空间。
O（k）上面的代码适用于成本为O（1）空间的原地方法。 而优先队列（通常用堆实现）耗费O（k）空间（在大多数情况下，它远小于N）。

逐个合并列表方法
将合并\ text {k} k列表问题转换成合并2个列表（k-1）次。 这是合并2列表问题页面。

复杂性分析
时间复杂度：O（kN）其中 k是链接列表的数量。
我们可以在O（n）时间中合并两个排序后的链表，其中nn是两个列表中的节点总数。
总结合并过程，我们可以得到：O（\ sum_ {i = 1} ^ {k-1}（i （\ frac {N} {k}+\frac {N} {k}））=O（ΣI = 1k-1的（i （ķñ）+ķñ））=O（kN）。
空间复杂度：O（1）
我们可以在O（1）空间中合并两个排序后的链表。

合并分而治之方法

这种方法与上述方法并行，但是改进很多。 我们不需要多次遍历大多数节点

配对 k列表并合并每一对。
在第一次配对之后， k列表被合并成平均2N / k长度的k / 2列表，然后是k / 4，k / 8等等。
重复这个过程，直到我们得到最终的排序链表。
因此，我们将在每次配对和合并时遍历几乎NN节点，并重复有关log2k倍。

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        amount = len(lists)
        interval = 1
        while interval < amount:
            for i in range(0, amount - interval, interval * 2):
                lists[i] = self.merge2Lists(lists[i], lists[i + interval])
            interval *= 2
        return lists[0] if amount > 0 else lists

    def merge2Lists(self, l1, l2):
        head = point = ListNode(0)
        while l1 and l2:
            if l1.val <= l2.val:
                point.next = l1
                l1 = l1.next
            else:
                point.next = l2
                l2 = l1
                l1 = point.next.next
            point = point.next
        if not l1:
            point.next=l2
        else:
            point.next=l1
        return head.next

复杂性分析

时间复杂度：O（Nlogk）其中\ text {k} k是链接列表的数量。
我们可以在O（n）O（n）时间中合并两个排序后的链表，其中nn是两个列表中的节点总数。
总结合并过程，我们可以得到：O \ big（\ sum_ {i = 1} ^ {log_ {2} {k}} N \ big）= O（N \ log k）O（ΣI = 1 2kN）= O（Nlogk）
空间复杂度：O（1）
我们可以在O（1）空间中合并两个排序后的链表。