23. Merge k Sorted Lists

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

用优先级队列做的

    public ListNode mergeKLists(ListNode[] lists) {        PriorityQueue<ListNode> queue = new PriorityQueue<ListNode>(new Comparator<ListNode>() {            @Override            public int compare(ListNode o1, ListNode o2) {                return o1.val - o2.val;            }        });        for (ListNode head : lists){            if (head != null) queue.add(head);        }        ListNode dummy = new ListNode(-1);        ListNode head = dummy;        while (!queue.isEmpty()){            ListNode node = queue.poll();            head.next = new ListNode(node.val);            head = head.next;            node = node.next;            if (node == null) continue;            queue.add(node);        }        return dummy.next;    }

解出来了 但是时间复杂度需要知道 正好solution里面有对于这种解法的分析

Complexity Analysis

• Time complexity : O(Nlogk) where k is the number of linked lists.
• • The comparison cost will be reduced to O(logk) for every pop and insertion to priority queue. But finding the node with the smallest value just costs O(1) time.
  • There are N nodes in the final linked list.
• Space complexity :
• • O(n) Creating a new linked list costs O(n) space.
  • O(k) The code above present applies in-place method which cost O(1) space. And the priority queue (often implemented with heaps) costs O(k) space (it's far less than N in most situations).

时间复杂度O(Nlogk)的还有下面这种

Intuition & Algorithm

Pair up k lists and merge each pair.

After the first pairing, k lists are merged into k/2 lists with average 2N/k length, then k/4k/4, k/8k/8 and so on.

Repeat this procedure until we get the final sorted linked list.

Thus, we'll traverse almost N nodes per pairing and merging, and repeat this procedure about logk times.

图片来源:https://leetcode.com/problems/merge-k-sorted-lists/solution/

描述和图片已经非常直观了 就不详细说了 上代码

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

Time complexity : O(Nlog k) where 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.

Space complexity : O(1)

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

相对于priority queue解法的空间复杂度O(n), 这个空间复杂度只有O(1)，是最佳