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 Comparator
		Comparator<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;
				else
					return 0;
				 // Assume neither ListNode is null. 
		        // You could also just return x.val - y.val
		        // which would be more efficient.
			}
		};		
		// define a PriorityQueue object
		PriorityQueue<ListNode> pq = new PriorityQueue<ListNode>(lists.size(),
				compListNode);
		// travel each ListNode from lists
		Iterator 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 linkedlist
		ListNode 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;
	}