【LeeCode23】Merge k Sorted Lists★★★

1.题目描述：

2.解题思路：

　　题意：将K个已经排序的链表合并成一个排序的链表，分析并描述所用算法的复杂度。

　　方法一：基于“二分”思想的归并排序。本文用非递归和递归两种方法实现。

　　（1）非递归：归并排序”（Merging Sort）：将两个或两个以上的有序表组合成一个新的有序表，无论是顺序存储结构还是链式存储结构，对于任何两个长度分别为m和n的有序表，其组合都可在O(m+n)的时间复杂度量级上完成。对于K个有序表，假设共有N个元素，且这些有序表初始状态都不为空，每个有序表平均拥有N/K个元素。最常用的方法是采用“二分”的思想进行两两合并：第一轮循环，有序表lists[0]与lists[(K+1)/2]，lists[1]与lists[(K+1)/2+1]，lists[2]与lists[(K+1)/2+2]....，lists[K/2-1]与lists[K-1]。这样K个有序表就被组合成了K/2个有序表；第二轮循环后将减少为K/4个有序表；直到组合成一个具有N个元素的有序表。总的时间复杂度：O(NKlogK)。

　　（2）递归：思想和上面类似，用的是递归实现。

　　方法二：基于优先级队列的“堆排序”。

 　　在Java中，堆是一种可以自我调整的二叉树，对于最小堆来说，对树执行删除和添加操作，可以让最小元素移动到根节点。在Java中，优先级队列（Priority Queue）便采用了“堆”这种数据结构，PriorityQueue是一个泛型类，它可以保存实现了Comparable接口的类对象，也可以保存在构造器中提供比较器的对象（优先级队列实现排序中也需要比较）。

     基于优先级队列，我们可以将K个链表的头结点全部添加到队列，由于优先级队列采用了最小堆数据结构，堆顶为队列的最小元素，我们将其取出添加到结果链表中，取出元素对应的链表下移一个节点，并将这个节点添加到优先级队列中；然后我们继续取出堆顶元素，...，直到优先级队列为空，那么其中所有元素取尽，K个链表的元素已经全部排序到结果链表。

3.Java代码：

（1）归并排序：非递归

//public class LeetCode23 为测试代码
public class LeetCode23 {
    public static void main(String[] args) {
        ListNode[] lists=new  ListNode[3];
        ListNode a1=new ListNode(1);
        ListNode a2=new ListNode(4);
        ListNode a3=new ListNode(7);
        a1.next=a2;
        a2.next=a3;
        System.out.println("链表a:"+a1.val+"->"+a2.val+"->"+a3.val);
        ListNode b1=new ListNode(2);
        ListNode b2=new ListNode(5);
        ListNode b3=new ListNode(8);
        b1.next=b2;
        b2.next=b3;
        System.out.println("链表b:"+b1.val+"->"+b2.val+"->"+b3.val);
        ListNode c1=new ListNode(3);
        ListNode c2=new ListNode(6);
        ListNode c3=new ListNode(9);
        c1.next=c2;
        c2.next=c3;
        System.out.println("链表c:"+c1.val+"->"+c2.val+"->"+c3.val);
        lists[0]=a1;
        lists[1]=b1;
        lists[2]=c1;
        ListNode result=new Solution().mergeKLists(lists);
        if(result!=null){
            System.out.print("结果链表:"+result.val);
            ListNode resultNext=result.next;
            while(resultNext!=null){
                 System.out.print("->"+resultNext.val);
                 resultNext=resultNext.next;
             }
        }
       
    }
}

//class Solution为ac代码
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
    int len=lists.length;
    if(lists==null||len==0) return null;    
    while(len>1){
        int mid=(len+1)/2;//len+1是为了在len为奇数时，mid恰好是正中间那一个
        for(int i=0;i<len/2;i++){
            lists[i]=merge2Lists(lists[i],lists[mid+i]);
        }
        len=mid;
    }
    return lists[0];
    }

private ListNode merge2Lists(ListNode l1, ListNode l2) {
    if(l1==null) return l2;
    if(l2==null) return l1;
    if(l1.val<l2.val){
        l1.next=merge2Lists(l1.next, l2);
        return l1;
    }
    else{
        l2.next=merge2Lists(l1, l2.next);
        return l2;
    }
}
}
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
    }

测试结果：

（2）归并排序：递归

public class LeetCode23 {
    public static void main(String[] args) {
        ListNode[] lists=new  ListNode[3];
        ListNode a1=new ListNode(1);
        ListNode a2=new ListNode(4);
        ListNode a3=new ListNode(7);
        a1.next=a2;
        a2.next=a3;
        System.out.println("链表a:"+a1.val+"->"+a2.val+"->"+a3.val);
        ListNode b1=new ListNode(2);
        ListNode b2=new ListNode(5);
        ListNode b3=new ListNode(8);
        b1.next=b2;
        b2.next=b3;
        System.out.println("链表b:"+b1.val+"->"+b2.val+"->"+b3.val);
        ListNode c1=new ListNode(3);
        ListNode c2=new ListNode(6);
        ListNode c3=new ListNode(9);
        c1.next=c2;
        c2.next=c3;
        System.out.println("链表c:"+c1.val+"->"+c2.val+"->"+c3.val);
        lists[0]=a1;
        lists[1]=b1;
        lists[2]=c1;
        ListNode result=new Solution().mergeKLists(lists);
        if(result!=null){
            System.out.print("结果链表:"+result.val);
            ListNode resultNext=result.next;
            while(resultNext!=null){
                 System.out.print("->"+resultNext.val);
                 resultNext=resultNext.next;
             }
        }
       
    }
}
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
    int len=lists.length;
    if(lists==null||len==0) return null;    
    return partion(lists,0,len-1);
    }

private ListNode partion(ListNode[] lists, int start, int end) {
    if(start==end) return lists[start];
    if(start<end){
        int mid=(start+end)/2;
        ListNode left=partion(lists, start, mid);
        ListNode right=partion(lists, mid+1, end);
        return merge2Lists(left, right);
    }else
        return null;
    
}

private ListNode merge2Lists(ListNode l1, ListNode l2) {
    if(l1==null) return l2;
    if(l2==null) return l1;
    if(l1.val<l2.val){
        l1.next=merge2Lists(l1.next, l2);
        return l1;
    }
    else{
        l2.next=merge2Lists(l1, l2.next);
        return l2;
    }
}
}
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
    }

测试结果：

 （3）堆排序

import java.util.Comparator;
import java.util.PriorityQueue;

//public class LeetCode23 为测试代码
public class LeetCode23{
    public static void main(String[] args) {
        ListNode[] lists=new  ListNode[3];
        ListNode a1=new ListNode(1);
        ListNode a2=new ListNode(4);
        ListNode a3=new ListNode(7);
        a1.next=a2;
        a2.next=a3;
        System.out.println("链表a:"+a1.val+"->"+a2.val+"->"+a3.val);
        ListNode b1=new ListNode(2);
        ListNode b2=new ListNode(5);
        ListNode b3=new ListNode(8);
        b1.next=b2;
        b2.next=b3;
        System.out.println("链表b:"+b1.val+"->"+b2.val+"->"+b3.val);
        ListNode c1=new ListNode(3);
        ListNode c2=new ListNode(6);
        ListNode c3=new ListNode(9);
        c1.next=c2;
        c2.next=c3;
        System.out.println("链表c:"+c1.val+"->"+c2.val+"->"+c3.val);
        lists[0]=a1;
        lists[1]=b1;
        lists[2]=c1;
        ListNode result=new Solution().mergeKLists(lists);
        if(result!=null){
            System.out.print("结果链表:"+result.val);
            ListNode resultNext=result.next;
            while(resultNext!=null){
                 System.out.print("->"+resultNext.val);
                 resultNext=resultNext.next;
             }
        }
       
    }
}

//class Solution为ac代码
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
    if(lists==null||lists.length==0) return null;
    if(lists.length==1) return lists[0];
    PriorityQueue<ListNode> queue=new PriorityQueue<ListNode>(1, new Comparator<ListNode>() {
        public int compare(ListNode l1,ListNode l2){
            return l1.val-l2.val;
        }
    });
    for(ListNode list:lists){
        if(list!=null) 
            queue.offer(list);
    }
    ListNode head=new ListNode(0);//建一个辅助结点作为最终所求链表的头节点
    ListNode p=head;
    while(!queue.isEmpty()){
        ListNode node=queue.poll();
        p.next=node;
        p=p.next;
        if(node.next!=null) queue.offer(node.next);
    }
    return head.next;
    }
}
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
    }

测试结果：