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)，是最佳