[leetcode]Merge k Sorted Lists@python

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

类似于数组合并排序的思想，化成两个链表排序，再向上合并

Complexity Analysis

• Time complexity : $O(N\log k)$ where $\text{k}$ is the number of linked lists.

  • We can merge two sorted linked list in $O(n)$ time where $n$ is the total number of nodes in two lists.
  • Sum up the merge process and we can get: O\big(\sum_{i=1}^{log_{2}{k}}N \big)= O(N\log k)O(∑​i=1​log​2​​k​​N)=O(Nlogk)

• Space complexity : $O(1)$

  • We can merge two sorted linked lists in $O(1)$ space.

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

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 = l2.next
            point = point.next
        if l1:
            point.next = l1
        else:
            point.next = l2
        return head.next