Merge k Sorted Lists 解答

Question

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

Solution 1 -- Merge Sort

We can follow the method of merge sort. Time complexity O(nlog(n)), n is the total number of all nodes.

 /**
  * Definition for singly-linked list.
  * public class ListNode {
  *     int val;
  *     ListNode next;
  *     ListNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public ListNode mergeKLists(ListNode[] lists) {
         if (lists == null || lists.length < 1)
             return null;
         if (lists.length == 1)
             return lists[0];
         int k = lists.length;
         return MSort(lists, 0, k - 1);
     }

     private ListNode MSort(ListNode[] lists, int start, int end) {
         if (start < end) {
             int mid = (end - start) / 2 + start;
             ListNode left = MSort(lists, start, mid);
             ListNode right = MSort(lists, mid + 1, end);
             return mergeTwoLists(left, right);
         }
         return lists[start];
     }

     private ListNode mergeTwoLists(ListNode a, ListNode b) {
         ListNode newHead = new ListNode(0);
         ListNode p = newHead, p1 = a, p2 = b;
         while (p1 != null && p2 != null) {
             if (p1.val < p2.val) {
                 p.next = new ListNode(p1.val);
                 p1 = p1.next;
             } else {
                 p.next = new ListNode(p2.val);
                 p2 = p2.next;
             }
             p = p.next;
         }
         while (p1 != null) {
             p.next = new ListNode(p1.val);
             p1 = p1.next;
             p = p.next;
         }
         while (p2 != null) {
             p.next = new ListNode(p2.val);
             p2 = p2.next;
             p = p.next;
         }
         return newHead.next;
     }
 }

Solution 2 -- PriorityQueue

We can use PriorityQueue in Java. The elements of the priority queue are ordered according to their natural ordering, or by a comparator provided at the construction time.

PriorityQueue

Comparator

 /**
  * Definition for singly-linked list.
  * public class ListNode {
  *     int val;
  *     ListNode next;
  *     ListNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public ListNode mergeKLists(ListNode[] lists) {
         if (lists == null || lists.length < 1)
             return null;
         ListNode newHead = new ListNode(0);
         PriorityQueue<ListNode> pq = new PriorityQueue<ListNode>(lists.length,
                                             new Comparator<ListNode>() {
                                                 public int compare(ListNode a, ListNode b) {
                                                     return (a.val - b.val);
                                                 }});
         for (ListNode tmp : lists) {
             if (tmp != null)
                 pq.add(tmp);
         }
         ListNode p = newHead;
         while (pq.size() > 0) {
             ListNode tmp = pq.poll();
             p.next = tmp;
             if (tmp.next != null)
                 pq.add(tmp.next);
             p = p.next;
         }
         return newHead.next;
     }
 }