Merge k Sorted Lists Java

Two Approach:

/*Solution1: 
* KeyWord: MergeSort,Iteration 
* Approach:
* 1. Divide K linked list into k/2 linked list
* 2. Merge two separated each time iteratively.
* example of k=6;
* => merge 1 and 4; save on 1
* => merge 2 and 5; save on 2
* => merge 3 and 6; save on 3
* then merge 1 and 2 (as a result: merge of 14 and 25); save on 1
* => merge 1 and 3 (as a result: merge of 1425 and 36); save on 1
* return 1;
* Time analysis: 
* T(k)= 2T(k/2) + O(n*k)
* in total:=> O(k*n*logk) 
* Space Complexity: O(logk) not including space cost during recursive 
*/

public ListNode mergeKListsMerge(List<ListNode> lists) {int k=lists.size();if(k==0) return null;else{while(k >1)        {            int  mid= (k+1)/2;            for(int i = 0; i < k/2; i++){                lists.set(i, mergeTwoLists(lists.get(i), lists.get(i + mid)));            }            k = mid;        }        return lists.get(0);} } public ListNode mergeTwoLists(ListNode l1, ListNode l2) {        //check for base case        if(l1==null) return l2;        if(l2==null) return l1;        if(l1==null && l2==null) return l1;        //delcare a dummy node        ListNode dummy=new ListNode(0);        //delcare a temple ListNode ll        ListNode ll=dummy;        while(l1!=null && l2!=null){        if(l1.val<l2.val){        ll.next=l1;        l1=l1.next;        }else{        ll.next=l2;        l2=l2.next;        }        ll=ll.next;                }        if(l1!=null){        ll.next=l1;        }else{        ll.next=l2;        }        return dummy.next;    }

/*Solution2: 
* KeyWord: PriorityQueue
* Approach: 
* it require to sort input lists, and merge together, then output one.
* 1. Use the DataStructure of PriorityQueue that
* 2. The idea in behind is to always keep smallest element in the top of heap. 
* Time analysis: since it require go over each element once => O(k*n),
* insert operation in PriorityQueue => O(logk)
* k is size of PriorityQueue Time complexity in total:=> O(k*n*logk) 
* Space Complexity: O(k) size of PriorityQueue
*/

public ListNode mergeKLists(List<ListNode> lists) {if(lists.size()==0) return null;// define a ListNode ComparatorComparator<ListNode> compListNode = new Comparator<ListNode>() {public int compare(ListNode a, ListNode b) {if (a.val > b.val)return 1;else if (a.val < b.val)return -1;elsereturn 0; // Assume neither ListNode is null.         // You could also just return x.val - y.val        // which would be more efficient.}};// define a PriorityQueue objectPriorityQueue<ListNode> pq = new PriorityQueue<ListNode>(lists.size(),compListNode);// travel each ListNode from listsIterator itr = lists.iterator();while (itr.hasNext()) {ListNode l = (ListNode) itr.next();if (l != null) {pq.add(l);}// System.out.println(l.printForward());}//merge into a single linkedlistListNode merge = new ListNode(0);ListNode cur=merge;while(pq.size()>0){ListNode temp=pq.poll();//connect cur->temp;cur.next=temp;if(temp.next!=null){pq.add(temp.next);}cur=cur.next;}return merge.next;}