LeetCode_merge-k-sorted-lists

题目描述：

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

思路1：用堆排序，每次都是从k条链表里面取出这k个节点中的最小值，然后拼接起来，取这个k个节点就可以使用堆来操作了；

思路2：用分治的思想，和归并排序一样，每次合并两个已经排序好的链表即可；

import java.util.*;
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    //归并排序--分治思想
    public ListNode mergeKLists(ArrayList<ListNode> lists) {
        if(lists==null||lists.size()==0)
            return null;
           return mergeKLists(lists,0,lists.size()-1);
    }
    private ListNode mergeKLists(ArrayList<ListNode> lists,int i,int j){
        if(i>=j)
            return lists.get(i);
        int mid=(i+j)/2;
        ListNode left=mergeKLists(lists,i,mid);
        ListNode right=mergeKLists(lists,mid+1,j);
        return mearge(left,right);
    }
    private ListNode mearge(ListNode node1,ListNode node2){
        ListNode first=new ListNode(0);
        ListNode cur=first;
        while(node1!=null&&node2!=null){
            if(node1.val<node2.val){
                cur.next=node1;
                node1=node1.next;
            }
            else{
                cur.next=node2;
                node2=node2.next;
            }
            cur=cur.next;
        }
        if(node1!=null){
            cur.next=node1;
        }
        if(node2!=null){
            cur.next=node2;
        }
        return first.next;
    }
    //堆排序
    public ListNode mergeKLists(ArrayList<ListNode> lists) {
       ListNode first=new ListNode(0);
        ListNode cur=first;
        PriorityQueue<ListNode> queue=new PriorityQueue<>(new Comparator<ListNode>(){
            @Override
            public int compare(ListNode node1,ListNode node2){
                return node1.val-node2.val;
            }
        });
        ListNode[] curArray=new ListNode[lists.size()];//存每一条链的当前节点
        for(ListNode node:lists){
            if(node!=null)
                queue.add(node);
        }
        while(queue.size()>0){
            cur.next=queue.poll();
            cur=cur.next;
            if(cur.next!=null){//这个cur指向的就是刚才放入first链表中的那个链表的节点，如果这个节点还有next，则放入这个节点.next
                queue.add(cur.next);
            }
        }
        return first.next;
    }
    
}